#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_CAR 60
#define MAX_DATAS 1000
#define MAX_INDICES 100

typedef struct {
    int valorMov;
    int data;
    int periodo;
    char tipoMov;
    char descMov[MAX_CAR];
    int orcamento;
} movimento;

void novoMov (movimento vec[][MAX_INDICES], int valor, int data, int periodo, char tipo, char descricao[], int contador[])
{ /*Guarda um novo movimento no vector vec*/
    int indice, controlPeriodo, aux;
    indice = contador[data];
    vec[data][indice].valorMov = valor; /*Guarda as informacoes sobre o movimento no indice*/
    vec[data][indice].data = data;
    vec[data][indice].periodo = periodo;
    vec[data][indice].tipoMov = tipo;
    strcpy(vec[data][indice].descMov, descricao);
    if (tipo == 'd') /*Se o tipo for d (despesa)*/
        vec[data][indice].orcamento = (0 - valor);
    else
        vec[data][indice].orcamento = valor;
    contador[data] = contador[data]+1; /*Incrementa-se o contador*/
    if(vec[data][indice].periodo != 0) /*Caso o movimento tenha periodo*/
    {
        for(controlPeriodo = (data+periodo); controlPeriodo < MAX_DATAS; controlPeriodo = (controlPeriodo+periodo))
        {/*Cria um ciclo que insere automaticamente movimentos equivalentes em datas com intervalos iguais ao periodo inserido.*/
            aux = contador[controlPeriodo];
            vec[controlPeriodo][aux].valorMov = valor;
            vec[controlPeriodo][aux].data = data+controlPeriodo;
            vec[controlPeriodo][aux].periodo = periodo;
            vec[controlPeriodo][aux].tipoMov = tipo;
            strcpy (vec[controlPeriodo][aux].descMov, descricao);
            if (tipo == 'd')
                vec[controlPeriodo][aux].orcamento = (0 - valor);
            else
                vec[controlPeriodo][aux].orcamento = valor;
            contador[controlPeriodo] = contador[controlPeriodo]+1;
        }
    }
}

int mostraBalanco (movimento vec[][MAX_INDICES], int data, int contador[])
{ /*Mostra o balanco numa data inserida*/
    int indice = 0;
    int datasinferiores = 0;
    int valor = 0;
    while (datasinferiores <= data)
    {
        while (indice < contador[datasinferiores] && contador[datasinferiores] <= MAX_INDICES)
        {
            valor = valor + vec[datasinferiores][indice].orcamento;
            ++indice; /*Soma-se os orcamentos em cada indice da data*/
        }
        ++datasinferiores; /*Incrementa-se as datas para verificar as proximas datas*/
        indice = 0; /*Reinicia-se os indices para verificarmos todos os indices das proximas datas*/
    }
    return valor;
}


void mostraMov(movimento vec[][MAX_INDICES], int data, int contador[])
{/*Mostra todos os indices dos movimentos de uma determinada data*/
    int indice = 0;
    while (indice < contador[data] && contador[data] <= MAX_INDICES)
    {
        printf("%d %d %c %s\n", indice, vec[data][indice].valorMov, vec[data][indice].tipoMov, vec[data][indice].descMov);
        ++indice; /*Verifica-se todos os indices para a data*/
    }
}

int veValidade (movimento vec[][MAX_INDICES], int minimo, int contador[])
{ /*Permite saber se um orcamento e valido ate a ultima data inserida*/
    int data = 0;
    int contagem=0;
    int indice = 0;
    int resultado = 1;
    while (data < MAX_DATAS)
    {
        while (indice < contador[data])
        {
            contagem=vec[data][indice].orcamento + contagem; /*Vai somando os valores em cada indice*/
            if(contagem < minimo)
            {
                resultado = 0; /*Caso algum resultado seja inferior ao minimo, o programa para e devolve invalido(Ver main)*/
                break;
            }
            ++indice; /*Verifica-se o proximo indice*/
        }
        indice=0; /*Reinicia-se o indice para se verificar nas outras datas*/
        ++data; /*Verifica-se a proxima data*/
    }
    return resultado;
}

void removeMov (movimento vec[][MAX_INDICES], int data, int indice, int contador[])
{ /*Remove um movimento de indice i de uma data*/
    while(indice<contador[data])
    {
        vec[data][indice].valorMov = vec[data][indice+1].valorMov; /*As posicoes sao movidas todas para a direita*/
        vec[data][indice].data = vec[data][indice+1].data;
        vec[data][indice].periodo = vec[data][indice+1].periodo;
        vec[data][indice].tipoMov = vec[data][indice+1].tipoMov;
        strcpy(vec[data][indice].descMov, vec[data][indice+1].descMov);
        vec[data][indice].orcamento = vec[data][indice+1].orcamento;
        indice++;
    }
    contador[data]--;/*O contador das datas e decrementado ate o ciclo parar*/
}

void dataComportavel (movimento vec[][MAX_INDICES], int primeiraData, int valorDespesa, int minimo, int contador[])
{ /*Devolve a primeira data a seguir a data introduzida em que e possivel introduzir uma despesa
    sem invalidar o orcamento*/
    int aux = 0;
    int auxContagem = 0;
    int dataComportavel = -1;
    while (primeiraData < MAX_DATAS)
    {
        while (aux < contador[primeiraData])
        {
            auxContagem = (mostraBalanco(vec, primeiraData, contador) - valorDespesa);
            if (auxContagem >= minimo)
            {
                int periodicidade = 0;
                int indiceAuxiliar = contador[primeiraData];
                char tipo = 'd';
                char descricao[MAX_CAR] = "Teste";
                novoMov(vec, valorDespesa, primeiraData, periodicidade, tipo, descricao, contador);
                if(veValidade(vec, minimo, contador) == 1)
                {
                    dataComportavel = primeiraData;
                    removeMov(vec, primeiraData, indiceAuxiliar, contador);
                    printf("%d\n", dataComportavel);
                    break;
                }
                else
                    removeMov(vec, primeiraData, indiceAuxiliar, contador);
            }
            ++aux;
        }
        aux = 0;
        ++primeiraData;
        if(dataComportavel != -1)
            break;
    }
    if (dataComportavel == -1)
        printf("Incomportavel\n");
}

int main ()
{
    char comando, tipo, descricao[MAX_CAR];
    int valor, data, periodo, contador[MAX_DATAS], n, minimo = 0;
    movimento vec[MAX_DATAS][MAX_INDICES]; /* Duplo vector para as datas e indices*/
    for(n = 0;n <= MAX_DATAS; n++) /*Ciclo que coloca o contador a zero*/
        contador[n] = 0;
    printf("Introduza o(s) comando(s) que pretende:\n");
    scanf("%c", &comando);
    while (comando != EOF)
    {
        if (comando == 'i')
        {
            scanf("%d %d %d %c %s", &valor, &data, &periodo, &tipo, descricao);
            novoMov(vec, valor, data, periodo, tipo, descricao, contador);
        }
        if (comando == 'm')
        {
            int novoMin;
            scanf("%d", &novoMin);
            minimo = novoMin;
        }
        if (comando == 'b')
        {
            int data;
            scanf("%d", &data);
            printf("%d\n", mostraBalanco(vec, data, contador));
        }
        if (comando == 'l')
        {
            int data;
            scanf("%d", &data);
            mostraMov(vec, data, contador);
        }
        if (comando == 'v')
        {
            if(veValidade(vec, minimo, contador) == 1)
                printf("Valido\n");
            else
                printf("Invalido\n");
        }
        if (comando == 'r')
        {
            int data, indice;
            scanf("%d %d", &data, &indice);
            removeMov(vec, data, indice, contador);
        }
        if (comando == 'w')
        {
            int data, valor;
            scanf("%d %d", &data, &valor);
            dataComportavel (vec, data, valor, minimo, contador);
        }
        scanf("%c", &comando);
    }
    return 0;
}