//MAIN
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include "To-Do.h"

void waitAndClear(){
    resetColor();
    printf("\nPressione qualquer tecla para continuar...");
    getch();
    system("cls");
}

int main(){
    initCores();

    Atividade activity; //declara  o de uma variavel do tipo Fila
    Fila f; //declara  o de uma variavel do tipo Fila
    Lista l; //declara  o de uma variavel do tipo Lista
    Pilha p; //declara  o de uma variavel do tipo Pilha

    int op, pos; //variavel "op" para o switch case, "pos" para receber o retorno da fun  o que encontra a posi  o da atividade na lista
    char ativi[65]; //variavel que recebe o titulo de uma tarefa

    create_lista(&l); //inicializa  o da lista
    create_fila(&f); //inicializa  o da fila
    create_pilha(&p); //inicializa  o da pilha

    lerArquivo(&l, &f, &p, activity);

    do{ //equanto "op" n o for == 0 o menu de op  es volta a aparecer;
        colorYellow(hConsole);
        printf("================================\n~ Hello from To-Do Pendulares! ~\n================================\n\n");
        //menu de op  es
        colorMagenta(hConsole);
        printf("\t1 - Criar uma atividade\n"
               "\t2 - Visualizar uma atividade\n"
               "\t3 - Editar uma atividade\n"
               "\t4 - Excluir uma atividade\n"
               "\t5 - Listar as atividades\n"
               "\t6 - Proxima atividade a ser realizada\n"
               "\t7 - Atividades concluidas\n"
               "\t0 - SAVE & EXIT\n\n");
        resetColor(hConsole);
        printf("Selecione a sua opcao: ");
        colorGreen(hConsole);
        scanf("%d", &op);

        switch(op){
            case 1: //cria uma atividade
                nova_tarefa(&activity); //preeche a struct atividade com os seus dados
                criar_atividade(&l, &f, &p, activity); //adiciona a nova atividade nas estruturas
                enqueue_prioridade(&f, activity); //coloca uma atividade como prioritaria caso a prioridade seja 3 - alta
                resetColor();
                printf("Tarefa criada.");
                waitAndClear();
            break;

            case 2:
                colorCyan();
                printf("\nDigite o titulo da tarefa que deseja visualizar:\n");
                colorGreen();
                scanf("%s", ativi);//a variavel recebe o titulo da tarefa a ser visualizada
                visualizar_atividade(&l, ativi); //chama a fun  o de vizualizar a atividade, passando a lista por referencia e o titulo da tarefa a ser vizualizada
            break;

            case 3:
                colorCyan();
                printf("\nDigite o titulo da tarefa que deseja editar:\n");
                colorGreen();
                scanf("%s", ativi);//a variavel recebe o titulo da tarefa a ser visualizada
                visualizar_atividade(&l, ativi); //mostra a tarefa que ser  editada
                printf("\nDigite a modificacoes que deseja fazer:\n");
                nova_tarefa(&activity); //preeche a struct atividade com os dados
                editar(&l, ativi, activity); //chama a fun  o de editar, passando a lista por referencia, o titulo e o dado do tipo Atividade
                enqueue_prioridade(&f, activity); //coloca uma atividade como prioritaria caso a prioridade seja 3 - alta
                if(activity.status == 0){
                    push(&p, activity); //se uma atividade tem status 0 - concluida ele   colocada em uma pilha
                }
            break;

            case 4:
                printf("\nDigite o titulo da tarefa que deseja excluir:\n");
                scanf("%s", ativi); //a variavel recebe o titulo da tarefa a ser visualizada
                pos = encontrar_pos(&l, ativi); //a variavel pos recebe o retorno da fun  o que encontra a posi  o de um titiulo especifico de uma atividade
                activity = remove_at(&l, pos); //activity recebe o retorno da atividade que foi removida
                showAtividade(activity); // imprime a atividade que foi removida
            break;

            case 5:
                print_lista(l); // imprime a lista de todas as atividades
                waitAndClear();
            break;

            case 6:
                //print_fila(f); // imprime todas as atividades que tem uma maior prioridade primeiro
                showAtividade(peek(f)); //Imprime o primeiro da fila de prioridades
                waitAndClear();
            break;

            case 7:
                print_pilha(p); // imprime todas a atividades j  concluidas
                waitAndClear();
            break;

            case 0:
                resetColor(hConsole);
            break;

            default:
                colorRed(hConsole);
                printf("A opcao selecionada nao existe.\n");
                waitAndClear();
            break;
        }
    }while(op != 0);
    saveArquivo(&l);
    destroy_pilha(&p);
    destroy_fila(&f);
    //destroy_lista(&l);
    return 0;
}


//To-Do
#ifndef TO-DO_H_INCLUDED
#define TO-DO_H_INCLUDED
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
#include <windows.h>

typedef struct Atividade{
    char titulo [65]; //titulo da tarefa;
    char descricao [257]; //descri  o da tarefa;
    char data [11]; //data limite para realiza  o da tarefa, no formato DDMMAAAA; D-dia, M-m s, A-ano;
    int prioridade; // 1 - baixa, 2 - m dia, 3 - alta;
    int status; //0 - concluida, 1 - em andamento, 2 - pendente, 3 atrasada;
}Atividade;

typedef struct Celula{
    Atividade dado; //dado passa a ser do tipo Atividade, contendo todos os seus atribuitos;
    struct Celula *prox; //ponteiro para a proxima celula;
}Celula;

typedef struct{
    Celula *topo;
    int tam;
}Pilha;

typedef struct{
    Celula *inicio, *fim;
    int tam;
}Fila;

typedef struct Lista{
    Celula *inicio, *fim;
    int tam;
}Lista;

//===========================================================
//Cores
//===========================================================
HANDLE hConsole;
WORD default_attributes;

void initCores(){
    hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
    CONSOLE_SCREEN_BUFFER_INFO consoleInfo;

    GetConsoleScreenBufferInfo(hConsole, &consoleInfo);
    default_attributes = consoleInfo.wAttributes;
}

void resetColor(){
    SetConsoleTextAttribute(hConsole, default_attributes);
}

void colorRed(){
    SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_INTENSITY);
}

void colorGreen(){
    SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
}

void colorBlue(){
    SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
}

void colorMagenta(){
    SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_RED | FOREGROUND_INTENSITY);
}

void colorCyan(){
    SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_INTENSITY);
}

void colorYellow(){
    SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY);
}

//===========================================================
//Show
//===========================================================
void showAtividade(Atividade a){//imprime os dados da struct Atividade
    colorMagenta();
    printf("\t\t[%s]\n", a.titulo);
    colorYellow();
    printf("\t - Descricao: ");
        colorCyan();
        printf("%s\n", a.descricao);
    colorYellow();
    printf("\t - Data: ");
        colorCyan();
        printf("%s\n", a.data);
    colorYellow();
    printf("\t - Prioridade: ");
        colorCyan();
        printf("%d\n", a.prioridade);
    colorYellow();
    printf("\t - Status: ");
        colorCyan();
        printf("%d\n\n", a.status);
}
//===========================================================
//Pilha
//===========================================================
void create_pilha(Pilha *p){
    p->topo = NULL;
    p->tam = 0;
}

void push(Pilha *p, Atividade dado){

    Celula *temp =  (Celula*)malloc(sizeof(Celula));

    temp->prox = p->topo;
    temp->dado = dado;

    p->topo = temp;
    p->tam++;
}

void print_pilha(Pilha p){
    Celula *temp = p.topo;

    printf("\nSize:%d\n", p.tam);
    while(temp!=NULL){
        showAtividade(temp->dado);
        temp = temp->prox;
    }
}

bool is_empty_pilha(Pilha p){
    return p.topo == NULL;
}

Atividade pop(Pilha *p){

    if(is_empty_pilha(*p)){
        Atividade erro;
        erro.status = -1;
        return erro;
    }

    Celula *temp = p->topo;

    p->topo = p->topo->prox;

    Atividade dado = temp->dado;
    free(temp);

    p->tam--;

    return dado;
}

void destroy_pilha(Pilha *p){

    while(!is_empty_pilha(*p))
        pop(p);
}

//==============================================================
//Fila

void create_fila(Fila *f){
    f->inicio = f->fim = (Celula *)malloc(sizeof(Celula));
    f->tam = 0;
}

bool is_empty_fila(Fila f){
    return f.inicio == f.fim;
}

bool enqueue(Fila *f, Atividade activity){
    Celula *temp = (Celula *)malloc(sizeof(Celula));

    if(temp == NULL)
        return false;

    temp->prox = NULL;
    temp->dado = activity;

    f->fim->prox = temp;
    f->fim =  f->fim->prox;

    f->tam++;

    return true;
}

Atividade dequeue(Fila *f){

    if(is_empty_fila(*f)){
        Atividade erro;
        erro.status = -1;
        return erro;
    }

    Celula *temp = f->inicio;

    f->inicio = f->inicio->prox;

    free(temp);

    f->tam--;

    return f->inicio->dado;
}

Atividade peek(Fila f){
    if(is_empty_fila(f)){
        Atividade erro;
        erro.status = -1;
        return erro;
    }

    return f.inicio->prox->dado;
}

void print_fila(Fila f){
    Celula *temp = f.inicio->prox;
    while(temp!=NULL){
        showAtividade(temp->dado);
        temp = temp->prox;
    }
    printf("\n");
}

void destroy_fila(Fila *f){
    while(!is_empty_fila(*f))
        dequeue(f);
    free(f->inicio);
}

//==============================================================
//Lista
//==============================================================
void create_lista(Lista *l){
    Celula *temp = (Celula*)malloc(sizeof(Celula));

    temp->prox = NULL;
    l->inicio = l->fim = temp;
    l->tam = 0;
}

void add(Lista *l, Atividade dado){
    Celula *temp = (Celula*)malloc(sizeof(Celula));

    temp->prox = NULL;
    temp->dado = dado;

    l->fim->prox = temp;
    l->fim = temp;
    l->tam++;
}

Atividade remove_at(Lista *l, int pos){
    if(pos < 0 || pos >= l->tam){
        Atividade erro;
        erro.status = -1;
        return erro;
    }

    Celula *ant = l->inicio;

    for(int i=0; i < pos;i++)
        ant = ant->prox;

    Celula *temp = ant->prox;
    Atividade dado = temp->dado;

    ant->prox = temp->prox;

    if(ant->prox == NULL)
        l->fim = ant;

    free(temp);

    l->tam--;

    return dado;
}

void print_lista(Lista l){
    resetColor();
    printf("Tamanho: %d\n", l.tam);
    Celula *temp = l.inicio->prox;
    int i=0;
    while(temp!=NULL){
        showAtividade(temp->dado);
        temp = temp->prox;
        i++;
    }
}

void destroy_lista(Lista *l){//printf("%d",l->tam);
    while(l->inicio != l->fim){
        remove_at(l, 0);
    }
    free(l->inicio);
}

//==============================================================
//To-Do!

//CRUD
void nova_tarefa(Atividade *activity){ // preeche a struct Atividade com os dados de uma nova tarefa
    colorCyan();
    printf("Titulo da tarefa: ");
    colorGreen();
    scanf("%s", &activity->titulo);
    colorCyan();
    printf("Descricao da Tarefa: ");
    colorGreen();
    scanf("%s", &activity->descricao);
    colorCyan();
    printf("Data da Tarefa: ");
    colorGreen();
    scanf("%s", &activity->data);
    fflush(stdin);
    colorCyan();
    printf("Defina a Prioridade: \n"
           "\t1 - baixa;\n"
           "\t2 - media;\n"
           "\t3 - alta;\n\n");
    colorGreen();
    scanf("%d", &activity->prioridade);
    fflush(stdin);
    colorCyan();
    printf("Defina o Status: \n"
           "\t0 - concluida; \n"
           "\t1 - em andamento; \n"
           "\t2 - pendente; \n"
           "\t3 - atrasada;\n\n");
    colorGreen();
    scanf("%d", &activity->status);
    printf("\n");
}

void criar_atividade(Lista *l, Fila *f, Pilha *p, Atividade activity){ //cria uma atividade chamando outra fun  o de adicionar na lista, pasando a lista e o dado a ser inserido
    add(l, activity);//Adiciona na lista
    if(activity.status == 0){//se uma atividade tem status 0 - concluida ela
        push(p, activity); //colocada em uma pilha para que o usuario possa ver quais atividade foram concluidas
    }
}

void visualizar_atividade(Lista *l, char ativi[65]){
    Celula *temp = l->inicio->prox;
    while(temp != NULL){
        if(strcmp(temp->dado.titulo, ativi)==0){//Se o t tulo for igual, exibe os dados da atividde
            showAtividade(temp->dado);
            return;
        }
        temp = temp->prox;
    }
    colorRed();
    printf("Atividade nao encontrada.\n");
    resetColor();
}

void editar(Lista *l, char ativi[65], Atividade activity){
    //FIXME edita apenas a lista...
    Celula *temp = l->inicio->prox;

    while(strcmp(temp->dado.titulo, ativi)!=0 && temp->prox != NULL){ //ir  comparar o titulo da atividade que o usuarios quer
        temp = temp->prox; //vizualizar e enquanto for diferente ele passa aiante para a proxima celula
    }
    strcpy(temp->dado.titulo, activity.titulo);
    strcpy(temp->dado.descricao, activity.descricao);
    strcpy(temp->dado.data, activity.data);
    temp->dado.prioridade = activity.prioridade;
    temp->dado.status = activity.status;
}

int encontrar_pos(Lista *l, char ativi[65]){
    int pos=0;
    Celula *temp = l->inicio->prox;

    while(strcmp(temp->dado.titulo, ativi)!=0 && temp->prox != NULL){//ir  comparar o titulo da atividade que o usuarios quer
        temp = temp->prox; //vizualizar e enquanto for diferente ele passa aiante para a proxima celula
        pos++;
    }
    return pos;
}

void saveArquivo(Lista *l){//Salva os dados da lista no arquivo, e destr i a lista.
    FILE *arquivo = fopen("atividades.txt","w");
    Atividade save;
    char str[10000] = "";
    char buffer[2]="";
    while(l->inicio != l->fim){
        save = remove_at(l, 0);
        strcat(str, save.titulo);
        strcat(str, "\t");
        strcat(str, save.descricao);
        strcat(str, "\t");
        strcat(str, save.data);
        strcat(str, "\t");
        itoa(save.prioridade,buffer,10);
        strcat(str, buffer);
        strcat(str, "\t");
        itoa(save.status,buffer,10);
        strcat(str, buffer);
        strcat(str, "\n");
    }
    free(l->inicio);
    fprintf(arquivo,"%s", str);
    fclose(arquivo);
}

void lerArquivo(Lista *l, Fila *f, Pilha *p, Atividade activity){
    FILE *arquivo = fopen("atividades.txt","r");
    if(arquivo == NULL){
        return;
    }
    while(!feof(arquivo)){
        fscanf(arquivo,"%s\t%s\t%s\t%i\t%i\n",&activity.titulo,&activity.descricao,&activity.data,&activity.prioridade,&activity.status);
        criar_atividade(l,f,p,activity);
    }
    fclose(arquivo);
}

//Enfilerar com prioridade
void enqueue_prioridade(Fila *f, Atividade activity){

    int prioridade = activity.prioridade;

    printf("%d", prioridade);

    if(activity.prioridade==0){ //caso a prioridade da atividade n o seja 0 ela sera enfilieirada normalmente, tornando a ultima da fila
        enqueue(f, activity);
        return;
    }

    printf("ok1");

    Celula *temp = (Celula*)malloc(sizeof(Celula)); //cria uma nova celula
    temp->prox = NULL; // o prox recebe NULL
    temp->dado = activity; // o dado recebe a struct com os detalhes da tarefa

    printf("ok2");

    Celula *ant = f->inicio;// a celula anterior recebe o inicio da fila

    while(ant->prox!=NULL && ant->prox->dado.prioridade >= 3){// enquanto o proximo da fila for diferente de NULL e os dados forem
        ant = ant->prox;// maior ou igual a prioridade da atividade inserida ela ir  avan ar at  encontar alguem menor
    }

    printf("ok3");

    temp->prox = ant->prox;
    ant->prox = temp;

    printf("ok4");

    if(temp->prox == NULL){
        f->fim = temp;
    }
    printf("ok5");
    f->tam++;
}



#endif // TO-DO_H_INCLUDED