TP2 To-Do

//MAIN

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

int main(){

    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

    do{ //equanto "op" não for == 0 o menu de opções volta a aparecer;
        printf("\t\tHello to To-Do Pendulares!\n");
        //menu de opções
        printf("\t1 - Criar uma atividade\n"
               "\t2 - Vizualizar 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 - EXIT\n\n");
        scanf("%d", &op);

        switch(op){
            case 1: //cria uma atividade
                nova_tarefa(&activity); //preeche a struct atividade com os seus dados
                criar_atividade(&l, activity); //adiciona a nova atividade na lista de atividades
                enqueue_prioridade(&f, activity); //coloca uma atividade como prioritaria caso a prioridade seja 3 - alta
                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
                }
            break;

            case 2:
                printf("\nDigite o titulo da tarefa que deseja vizualizar:\n");
                scanf("%s", ativi);//a variavel recebe o titulo da tarefa a ser visualizada
                vizualizar_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:
                printf("\nDigite o titulo da tarefa que deseja editar:\n");
                scanf("%s", ativi);//a variavel recebe o titulo da tarefa a ser visualizada
                vizualizar_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
                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
                imprimir_atividade(activity); // imprime a atividade que foi removida
            break;

            case 5:
                print_lista(l); // imprime a lista de todas as atividades
                printf("\n");
            break;

            case 6:
                print_fila(f); // imprime todas as atividades que tem uma maior prioridade primeiro
                printf("\n");
            break;

            case 7:
                print_pilha(p); // imprime todas a atividades já concluidas
                printf("\n");
            break;
        }
    }while(op != 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>

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 atrazada;
}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;

//===========================================================
//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){
        printf("\t|%s|\n", temp->dado.titulo);
        printf("%s\n", temp->dado.descricao);
        printf("%s\n", temp->dado.data);
        printf("%d\n", temp->dado.prioridade);
        printf("%d\n", temp->dado.status);
        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){

    printf("\nSize: %d\n", f.tam);
    Celula *temp = f.inicio->prox;
    while(temp!=NULL){
        printf("\t|%s|\n", temp->dado.titulo);
        printf("%s\n", temp->dado.descricao);
        printf("%s\n", temp->dado.data);
        printf("%d\n", temp->dado.prioridade);
        printf("%d\n", temp->dado.status);
        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){

    printf("\nSize: %d\n", l.tam);
    Celula *temp = l.inicio->prox;
    int i=0;
    while(temp!=NULL){
        printf("\t|%s|\n", temp->dado.titulo);
        printf("%s\n", temp->dado.descricao);
        printf("%s\n", temp->dado.data);
        printf("%d\n", temp->dado.prioridade);
        printf("%d\n", temp->dado.status);
        temp = temp->prox;
        i++;
    }
}

void destroy_lista(Lista *l){
    while(l->inicio != l->fim)
        remove_at(l, 0);
    free(l->inicio);
}

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

//CRUD
void imprimir_atividade(Atividade activity){//imprime os dados da struct Atividade
    printf("%s\n", activity.titulo);
    printf("%s\n", activity.descricao);
    printf("%s\n", activity.data);
    printf("%d\n", activity.prioridade);
    printf("%d\n", activity.status);
}

void nova_tarefa(Atividade *activity){ // preeche a struct Atividade com os dados de uma nova tarefa

    printf("Titulo da tarefa:\n");
    scanf("%s", &activity->titulo);
    printf("Descricao da Tarefa:\n");
    scanf("%s", &activity->descricao);
    printf("Data da Tarefa:\n");
    scanf("%s", &activity->data);
    fflush(stdin);
    printf("Defina a Prioridade: "
           "1 - baixa; "
           "2 - media; "
           "3 - alta;\n\n");
    scanf("%d", &activity->prioridade);
    fflush(stdin);
    printf("\n");
    printf("Defina o Status: "
           "0 - concluida; "
           "1 - em andamento; "
           "2 - pendente; "
           "3 - atrazada;\n\n");
    scanf("%d", &activity->status);
    printf("\n");
}

void criar_atividade(Lista *l, 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);
}

void vizualizar_atividade(Lista *l, char ativi[65]){

    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 adiante para a proxima celula
    }
    printf("\t|%s|\n", temp->dado.titulo);
    printf("%s\n", temp->dado.descricao);
    printf("%s\n", temp->dado.data);
    printf("%d\n", temp->dado.prioridade);
    printf("%d\n", temp->dado.status);
}

void editar(Lista *l, char ativi[65], Atividade activity){

    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;
}

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

    if(activity.prioridade < 3){ //caso a prioridade da atividade não seja alta ela sera enfilieirada tornando a ultima da fila
        enqueue(f, activity);
        return;
    }

    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

    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 3 ela irá avançar até encontar alguem menor
    }

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

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

#endif // TO-DO_H_INCLUDED