trabalho de algoritmos - agenda de compromissos 0.2

#include <stdio.h>
#include <curses.h>
#include <string.h>

typedef struct
{
    int ano, mes, dia;
}data;

typedef struct
{
    int horas, minutos;
}horario;

typedef struct
{
    data dia;
    horario horas;
    char descricao[80];
}dados;

typedef struct agenda *node;

struct agenda
{
    dados info;
    node ant, prox;
};

typedef struct
{
    node prim, ult;
    int qte;
}Descritor;

Descritor lista;


void flush_in()
{
   /*funcao para limpar cache do teclado, estava tendo problemas para
    * usar gets, o programa pulava a linha completamente, achei
    * essa solucao na internet, o cache do teclado ficava "sujo"
    * depois de usar scanf e bugava o gets*/
   int ch;

   while( (ch = fgetc(stdin)) != EOF && ch != '\n' ){}
}

int debugletudo (Descritor *lista) //para ver o conteúdo todo da lista, testar insercão
{
    node p;

    if (lista->qte)
    {
        p = lista->prim;
        while (p)
        {
            printf("%d/%d/%d %d:%d\n%s\n", p->info.dia.dia, p->info.dia.mes, p->info.dia.ano, p->info.horas.horas, p->info.horas.horas, p->info.descricao);
            p = p->prox;
        }
    }

    return 0;
}






int remover (Descritor *lista)
{
    data remov;
    int t;
    node p, q;

    if (lista->qte == 0)
    {
        printf("Não há dados para carregar! Tente inserir (I) ou abrir um arquivo pré-existente (A) no menu.\n");
        return 0;
    }

    do{
        t = 0;
        printf("Digite a data cujos compromissos serão removidos (formato 'dia mês ano(completo)\nex: 21 04 2013): ");
        scanf("%d %d %d", &remov.dia, &remov.mes, &remov.ano);
        flush_in();

        if ( (remov.dia > 31) || (remov.dia < 1) )
        {
            printf("\nDia deve ser entre 1 e 31!\n");
            t = 1;
        }
        else if ( (remov.mes > 12) || (remov.mes < 1) )
        {
            printf("\nMês deve ser entre 1 e 12!\n");
            t = 1;
        }

    } while (t);


    p = lista->prim;

    while ( p->info.dia.ano == remov.ano) //para remover do primeiro elemento
    {
        while ( p->info.dia.mes == remov.mes)
        {
            while ( p->info.dia.dia == remov.dia)
            {
                if (!p->prox) //se só houver um elemento
                {
                    lista->qte = 0;
                    lista->prim = lista->ult = NULL;
                    free(p);
                    printf("\nRemocão concluída e sua agenda está vazia.\n");
                    return 0;
                }

                (p->prox)->ant = NULL;
                lista->prim = p->prox;
                lista->qte -= 1;
                free(p);
                p = lista->prim;

            }

        }
    }
    //removidos elementos até o primeiro não ter a data de remocão
    p = p->prox;

    while (p)
    {

        while ( p->info.dia.ano == remov.ano)
        {
            while ( p->info.dia.mes == remov.mes)
            {
                while ( p->info.dia.dia == remov.dia)
                {
                    if (!p->prox) //se deletando o ultimo elemento
                    {
                        (p->ant)->prox = NULL;
                        lista->qte -= 1;
                        lista->ult = p->ant;
                        free(p);
                        printf("\nRemocão concluída!\n");
                        return 0; //como a lista é ordenada...
                    }
                    else
                    {
                        (p->prox)->ant = p->ant;
                        (p->ant)->prox = p->prox;
                        lista->qte -= 1;
                        q = p->prox;
                        free(p);
                        p = q;
                    }
                }
                //se entrou e saiu dessa série de whiles, acabaram os elementos a
                //serem removidos, já que a lista é ordenada
                printf("\nRemocão concluída!\n");
                return 0;

            }
        }

        //se não entrou nos whiles, andar
        p = p->prox;

    }

    printf("\nNenhum compromisso encontrado na data pedida.\n");
    return 0;
}

dados pegaDados ()
{
    dados novo;
    int t;

    do {
        t = 0;  //zerando a condicao do while toda iteracao
        printf("\nPor favor, insira a data do novo compromisso (formato 'dia mês ano(completo)' \nex: 21 04 2013): ");
        scanf("%d %d %d", &novo.dia.dia, &novo.dia.mes, &novo.dia.ano);
        flush_in();

        if ( (novo.dia.dia > 31) || (novo.dia.dia < 1) )
        {
            printf("\nDia deve ser entre 1 e 31!\n");
            t = 1;
        }
        else if ( (novo.dia.mes > 12) || (novo.dia.mes < 1) )
        {
            printf("\nMês deve ser entre 1 e 12!\n");
            t = 1;
        }

    } while (t);

    do {
        t = 0;
        printf("\nAgora, insira o horário do novo compromisso (formato 'horas minutos' \nex: 14 50): ");
        scanf("%d %d", &novo.horas.horas, &novo.horas.minutos);
        flush_in();

        if (novo.horas.horas == 24)
            novo.horas.horas = 0; //apenas para padronizar e facilitar a organizacao

        if ( (novo.horas.horas < 0) || (novo.horas.horas > 23) )
        {
            printf("\nHora 'cheia' deve ser entre 0 e 24!\n");
            t = 1;
        }

        if ( (novo.horas.minutos < 0) || (novo.horas.minutos > 59) )
        {
            printf("\nMinutos devem ser entre 0 e 59!\n");
            t = 1;
        }

    } while (t);

    printf("\nEscreva uma breve descricão para o compromisso (até 80 caractres): ");
    gets(novo.descricao);

    printf("\nDados inseridos com sucesso.\n");

    return novo;
}

int inserir (Descritor *lista)
{
    dados novo = pegaDados(); //decidi colocar a parte de interacao com o usuario separada pois ficou grande
    node p, q;

    if (lista->qte == 0)
    {
        p = (node)malloc(sizeof(struct agenda));
        p->ant = p->prox = NULL;
        p->info = novo;
        lista->qte = 1;
        lista->prim = lista->ult = p;
        return 0;
    }
    else
    {
        p = lista->prim;
        if (p->info.dia.ano > novo.dia.ano) //se o primeiro ano é maior, o elemento novo será o primeiro
        {
            q = (node)malloc(sizeof(struct agenda));
            q->info = novo;
            q->prox = p;
            q->ant = NULL;
            p->ant = q;
            lista->prim = q;
            lista->qte += 1;
            return 0;
        }

        else
        {
            while (p->info.dia.ano < novo.dia.ano)
            {
                if (!p->prox) //insere no fim da lista
                {
                    q = (node)malloc(sizeof(struct agenda));
                    q->info = novo;
                    q->ant = p;
                    q->prox = NULL;
                    p->prox = q;
                    lista->ult = q;
                    lista->qte += 1;
                    return 0;
                }
                else
                    p = p->prox;
            }
            //saindo do while, o ano de p só pode ser maior ou igual e p->ant só pode ser menor
            if (p->info.dia.ano > novo.dia.ano)
            {
                q = (node)malloc(sizeof(struct agenda));
                q->info = novo;
                q->prox = p;
                q->ant = p->ant;
                p->ant = q;
                lista->qte += 1;
                return 0;
            }
            //se não caiu em nenhuma das condicoes até agora, os anos são iguais


            while (p->info.dia.mes < novo.dia.mes)
            {
                if (!p->prox) //insere no fim da lista
                {
                    q = (node)malloc(sizeof(struct agenda));
                    q->info = novo;
                    q->ant = p;
                    q->prox = NULL;
                    p->prox = q;
                    lista->ult = q;
                    lista->qte += 1;
                    return 0;
                }
                else
                    p = p->prox;
            } //saindo do while, mês de p é maior ou igual

            if (p->info.dia.mes > novo.dia.mes)
            {
                q = (node)malloc(sizeof(struct agenda));
                q->info = novo;
                q->prox = p;
                q->ant = p->ant;
                p->ant = q;
                lista->qte += 1;
                return 0;
            }
            //sendo os meses iguais


            while (p->info.dia.dia < novo.dia.dia)
            {
                if (!p->prox) //insere no fim da lista
                {
                    q = (node)malloc(sizeof(struct agenda));
                    q->info = novo;
                    q->ant = p;
                    q->prox = NULL;
                    p->prox = q;
                    lista->ult = q;
                    lista->qte += 1;
                    return 0;
                }
                else
                    p = p->prox;
            } //saindo do while, dia de p é maior ou igual

            if (p->info.dia.dia > novo.dia.dia)
            {
                q = (node)malloc(sizeof(struct agenda));
                q->info = novo;
                q->prox = p;
                q->ant = p->ant;
                p->ant = q;
                lista->qte += 1;
                return 0;
            }
            //sendo os dias iguais

            while (p->info.horas.horas < novo.horas.horas )
            {
                if (!p->prox) //insere no fim da lista
                {
                    q = (node)malloc(sizeof(struct agenda));
                    q->info = novo;
                    q->ant = p;
                    q->prox = NULL;
                    p->prox = q;
                    lista->ult = q;
                    lista->qte += 1;
                    return 0;
                }
                else
                    p = p->prox;
            } //saindo do while, hora cheia de p é maior ou igual

            if (p->info.horas.horas > novo.horas.horas)
            {
                q = (node)malloc(sizeof(struct agenda));
                q->info = novo;
                q->prox = p;
                q->ant = p->ant;
                p->ant = q;
                lista->qte += 1;
                return 0;
            }
            //sendo horas cheias iguais

            while (p->info.horas.minutos < novo.horas.minutos )
            {
                if (!p->prox) //insere no fim da lista
                {
                    q = (node)malloc(sizeof(struct agenda));
                    q->info = novo;
                    q->ant = p;
                    q->prox = NULL;
                    p->prox = q;
                    lista->ult = q;
                    lista->qte += 1;
                    return 0;
                }
                else
                    p = p->prox;
            } //saindo do while, hora cheia de p é maior ou igual

            if (p->info.horas.minutos > novo.horas.minutos)
            {
                q = (node)malloc(sizeof(struct agenda));
                q->info = novo;
                q->prox = p;
                q->ant = p->ant;
                p->ant = q;
                lista->qte += 1;
                return 0;
            }
            //sendo minutos iguais (!)

            q = (node)malloc(sizeof(struct agenda));
            q->info = novo;
            q->prox = p;
            q->ant = p->ant;
            p->ant = q;
            lista->qte += 1;
            printf("Já existe um compromisso neste mesmo dia e horário. Ambos estão salvos, mas confira sua programacão.");
            return 0;

        }
    }

    return 0;
}


int menu()
{
    char opcao, sair = 'N';
    int i;

    do {
        printf("\nPara inserir um compromisso, digite 'I'. ");
        printf("Para remover os compromissos de uma \ndeterminada data, digite 'R'. ");
        printf("Para consultar um dia, digite 'C'. ");
        printf("Para procurar \ncompromissos por palavras-chave, digite 'P'. ");
        printf("Para salvar seus compomissos em um arquivo de texto, digite 'S'. ");
        printf("Para abrir um arquivo com seus compromissos \nsalvos, digite 'A'. ");
        printf("Ou digite 'E' para sair.\n");

        do {
            scanf("%c", &opcao);
            flush_in();
            opcao = toupper(opcao);

            switch (opcao)
            {
                case 'I': inserir(&lista); i = 0; break;
                case 'R': remover(&lista); i = 0; break;
                case 'C': debugletudo(&lista); i = 0; break;
                case 'P': printf("\nProcurar"); i = 0; break;
                case 'S': printf("\nSalvar"); i = 0; break;
                case 'A': printf("\nCarregar"); i = 0; break;
                case 'E':
                    printf("\nDeseja mesmo sair? (S/N)");
                    scanf("%c", &sair);
                    flush_in();
                    sair = toupper(sair);
                    if (sair == 'S')
                        return 0;
                    i = 0; break;
                default: printf("\nNenhuma opcão válida, tente novamente.\n"); i = 1; break;
            }
        } while (i);

    } while (sair != 'S');

    return 0;
}

int main()
{
    //iniciando a lista
    lista.qte = 0;
    lista.prim = lista.ult = NULL;

    //chamando o menu
    printf("                         Bem-vindo à sua agenda virtual\n");
    menu();
//  printf("%d/%d/%d %d:%d\n%s\n", p->info.dia.dia, p->info.dia.mes, p->info.dia.ano, p->info.horas.horas, p->info.horas.horas, p->info.descricao);
    return 0;
}