#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <windows.h>

//+----------------------------------------+
//|            Conf management             |
//+----------------------------------------+

struct listenerList;

typedef struct conf
{
    int id;
    char title[30];
    char speaker[20];
    int day;
    int month;
    int year;
    struct listenerList *listeners;
    struct conf *next;
} tConf;

typedef struct confList
{
    struct conf *conf;
    int grade;
    struct confList *next;
} tConfList;

typedef struct listener
{
    int id;
    char name[20];
    int age;
    int level;
    struct confList *confs;
    struct listener *prev;
    struct listener *next;
} tListener;

typedef struct listenerList
{
    struct listener *listener;
    int grade;
    struct listenerList *next;
} tListenerList;

typedef tConf *ptConf;
typedef tListener *ptListener;
typedef tConfList *ptConfList;
typedef tListenerList *ptListenerList;

int findConfId(ptConf confChain);
ptConf newConfChain();
void addConf(ptConf confChain, int id, char title[], char speaker[], int day, int month, int year);
void removeConf(ptConf confChain, int id);
int findListenerId(ptListener listenerChain);
ptListener newListenerChain();
int addListener(ptListener listenerChain, int id, char name[], int age, int level);
void removeListener(ptListener listenerChain, int id);
void addConfToConfList(ptConfList confList, ptConf conf, int grade);
void removeConfFromConfList(ptConfList confList, ptConf conf);
void printConfList(ptConfList confList);
void addListenerToListenerList(ptListenerList listenerList, ptListener listener, int grade);
void removeListenerFromListenerList(ptListenerList listenerList, ptListener listener);
void printListenerList(ptListenerList listenerList);
int participateToConf(ptConf confChain, ptListener listenerChain, int confId, int listenerId, int grade);
int confGradeAvg(ptConf conf);
int confParticipations(ptConf conf);

int findConfId(ptConf confChain)
{
    ptConf px = confChain;
    int max = 0;

    while (px->next != NULL)
    {
        if (px->id > max)
        {
            max = px->id;
        }

        px = px->next;
    }

    return max + 1;
}

ptConf newConfChain()
{
    ptConf confChain = (ptConf)malloc(sizeof(tConf));

    confChain->next = (ptConf)malloc(sizeof(tConf));
    confChain->next->next = NULL;
    confChain->id = -1;

    return confChain;
}

void addConf(ptConf confChain, int id, char title[], char speaker[], int day, int month, int year)
{
    ptConf px = confChain;

    while (px->next != NULL)
    {
        px = px->next;
    }

    px->id = id;
    px->day = day;
    px->month = month;
    px->year = year;
    strcpy(px->title, title);
    strcpy(px->speaker, speaker);
    px->listeners = (ptListenerList)malloc(sizeof(tListenerList));
    px->listeners->next = (ptListenerList)malloc(sizeof(tListenerList));
    px->listeners->listener = NULL;
    px->listeners->next->next = NULL;
    px->next = (ptConf)malloc(sizeof(tConf));
    px->next->next = NULL;
}

void removeConf(ptConf confChain, int id)
{
    ptConf px = confChain;

    while (px->next != NULL && px->next->id != id)
    {
        px = px->next;
    }

    if (px->next != NULL && px->next->id == id)
    {
        ptListenerList py = px->next->listeners->next;

        while (py->next != NULL)
        {
            removeConfFromConfList(py->listener->confs, px->next);
            py = py->next;
        }

        ptConf tmp = px->next->next;
        free(px->next);
        px->next = tmp;
    }
}

int findListenerId(ptListener listenerChain)
{
    ptListener px = listenerChain;
    int max = 0;

    while (px->next != NULL)
    {
        if (px->id > max)
        {
            max = px->id;
        }

        px = px->next;
    }

    return max + 1;
}

ptListener newListenerChain()
{
    ptListener listenerChain = (ptListener)malloc(sizeof(tListener));

    listenerChain->prev = NULL;
    listenerChain->next = (ptListener)malloc(sizeof(tListener));
    listenerChain->next->prev = listenerChain;
    listenerChain->next->next = NULL;
    listenerChain->id = -1;

    return listenerChain;
}

int addListener(ptListener listenerChain, int id, char name[], int age, int level)
{
    if (level < 0 || level > 5)
    {
        return -1;
    }

    ptListener px = listenerChain;

    while (px->next != NULL)
    {
        px = px->next;
    }

    px->id = id;
    strcpy(px->name, name);
    px->age = age;
    px->level = level;
    px->confs = (ptConfList)malloc(sizeof(tConfList));
    px->confs->next = (ptConfList)malloc(sizeof(tConfList));
    px->confs->conf = NULL;
    px->confs->next->next = NULL;
    px->next = (ptListener)malloc(sizeof(tListener));
    px->next->next = NULL;
    px->next->prev = px;
    return 0;
}

void removeListener(ptListener listenerChain, int id)
{
    ptListener px = listenerChain;

    while (px->next != NULL && px->next->id != id)
    {
        px = px->next;
    }

    if (px->next != NULL && px->next->id == id)
    {
        ptConfList py = px->next->confs->next;

        while (py->next != NULL)
        {
            removeListenerFromListenerList(py->conf->listeners, px->next);
            py = py->next;
        }

        ptListener tmp = px->next->next;
        free(px->next);
        px->next = tmp;
        px->next->prev = px;
    }
}

void addConfToConfList(ptConfList confList, ptConf conf, int grade)
{
    ptConfList px = confList;

    while (px->next != NULL)
    {
        px = px->next;
    }

    px->conf = conf;
    px->next = (ptConfList)malloc(sizeof(tConfList));
    px->grade = grade;
    px->next->next = NULL;
}

void removeConfFromConfList(ptConfList confList, ptConf conf)
{
    ptConfList px = confList;

    while (px->next != NULL && px->next->conf != conf)
    {
        px = px->next;
    }

    if (px->next != NULL && px->next->conf == conf)
    {
        ptConfList tmp = px->next->next;
        free(px->next);
        px->next = tmp;
    }
}

void printConfList(ptConfList confList)
{
    ptConfList px = confList;

    printf("Participation aux conferences : ");
    while (px->next != NULL)
    {
        printf("%s(%d) ", px->conf->title, px->grade);
        px = px->next;
    }
    printf("\n");
}

void addListenerToListenerList(ptListenerList listenerList, ptListener listener, int grade)
{
    ptListenerList px = listenerList;

    while (px->next != NULL)
    {
        px = px->next;
    }

    px->listener = listener;
    px->next = (ptListenerList)malloc(sizeof(tListenerList));
    px->grade = grade;
    px->next->next = NULL;
}

void removeListenerFromListenerList(ptListenerList listenerList, ptListener listener)
{
    ptListenerList px = listenerList;

    while (px->next != NULL && px->next->listener != listener)
    {
        px = px->next;
    }

    if (px->next != NULL && px->next->listener == listener)
    {
        ptListenerList tmp = px->next->next;
        free(px->next);
        px->next = tmp;
    }
}

void printListenerList(ptListenerList listenerList)
{
    ptListenerList px = listenerList;

    printf("Participants : ");
    while (px->next != NULL)
    {
        printf("%s(%d) ", px->listener->name, px->grade);
        px = px->next;
    }
    printf("\n");
}

int participateToConf(ptConf confChain, ptListener listenerChain, int confId, int listenerId, int grade)
{
    if (grade < 0 || grade > 5)
    {
        return -1;
    }

    ptConf px = confChain;
    ptListener py = listenerChain;
    ptListenerList pz;

    while (px->next != NULL && px->id != confId)
    {
        px = px->next;
    }

    pz = px->listeners->next;
    while (pz->next != NULL)
    {
        if (pz->listener->id == listenerId)
        {
            return -2;
        }
        pz = pz->next;
    }

    while (py->next != NULL && py->id != listenerId)
    {
        py = py->next;
    }

    if (px->id != confId || py->id != listenerId)
    {
        return -2;
    }

    addListenerToListenerList(px->listeners, py, grade);
    addConfToConfList(py->confs, px, grade);

    return 0;
}

int confGradeAvg(ptConf conf)
{
    ptListenerList px = conf->listeners->next;
    int total = 0, nb = 0;

    while (px->next != NULL)
    {
        total += px->grade;
        nb++;
        px = px->next;
    }

    if (nb != 0)
    {
        return total / nb;
    }
    else
    {
        return -1;
    }
}

int confParticipations(ptConf conf)
{
    ptListenerList px = conf->listeners->next;
    int nb = 0;

    while (px->next != NULL)
    {
        nb++;
        px = px->next;
    }

    return nb;
}

//+----------------------------------------+
//|            Files management            |
//+----------------------------------------+

void readConfs(ptConf confChain);
void readListeners(ptListener listenerChain);
void readRelations(ptConf confChain, ptListener listenerChain);
void saveConf(ptConf confChain);
void saveListeners(ptListener listenerChain);
void saveRelations(ptConf confChain);

void readConfs(ptConf confChain)
{
    FILE *file = fopen("./data/confs", "r");
    char line[100];
    char *token;

    if (file == NULL)
    {
        printf("ça marche pas.");
        return;
    }

    while (fgets(line, sizeof(line), file))
    {
        int id = atoi(strtok(line, ","));
        char *title = strtok(NULL, ",");
        char *speaker = strtok(NULL, ",");
        int day = atoi(strtok(NULL, ","));
        int month = atoi(strtok(NULL, ","));
        int year = atoi(strtok(NULL, ","));

        addConf(confChain, id, title, speaker, day, month, year);
    }

    fclose(file);
}

void readListeners(ptListener listenerChain)
{
    FILE *file = fopen("./data/listeners", "r");
    char line[100];
    char *token;

    if (file == NULL)
    {
        printf("ça marche pas.");
        return;
    }

    while (fgets(line, sizeof(line), file))
    {
        int id = atoi(strtok(line, ","));
        char *name = strtok(NULL, ",");
        int day = atoi(strtok(NULL, ","));
        int month = atoi(strtok(NULL, ","));
        addListener(listenerChain, id, name, day, month);
    }

    fclose(file);
}

void readRelations(ptConf confChain, ptListener listenerChain)
{
    FILE *file = fopen("./data/relations", "r");
    char line[100];
    char *token1;
    char *token2;

    if (file == NULL)
    {
        printf("ça marche pas.");
        return;
    }

    while (fgets(line, sizeof(line), file))
    {
        int confId = atoi(strtok(line, ":"));

        while ((token1 = strtok(NULL, ";")) != NULL && (token2 = strtok(NULL, ",")) != NULL)
        {
            participateToConf(confChain, listenerChain, confId, atoi(token1), atoi(token2));
        }
    }

    fclose(file);
}

void saveConf(ptConf confChain)
{
    FILE *file = fopen("./data/confs", "w");
    ptConf px = confChain;
    while (px->next != NULL)
    {
        fprintf(file, "%d,%s,%s,%d,%d,%d\n", px->id, px->title, px->speaker, px->day, px->month, px->year);
        px = px->next;
    }
    fclose(file);
}

void saveListeners(ptListener listenerChain)
{
    FILE *file = fopen("./data/listeners", "w");
    ptListener px = listenerChain;
    while (px->next != NULL)
    {
        fprintf(file, "%d,%s,%d,%d\n", px->id, px->name, px->age, px->level);
        px = px->next;
    }
    fclose(file);
}

void saveRelations(ptConf confChain)
{
    FILE *file = fopen("./data/relations", "w");
    ptConf px = confChain;
    ptListenerList py;
    printf("test");
    while (px->next != NULL)
    {
        printf("test");
        py = px->listeners->next;

        if (py->next != NULL)
        {
            fprintf(file, "%d:", px->id);
        }

        while (py->next != NULL)
        {
            fprintf(file, "%d;%d", py->listener->id, py->grade);
            if (py->next->next != NULL)
            {
                fprintf(file, ",");
            }
            else
            {
                fprintf(file, "\n");
            }
            py = py->next;
        }

        px = px->next;
    }
    fclose(file);
}

//+----------------------------------------+
//|            Screen manager              |
//+----------------------------------------+

void goToCoords(int x, int y);
void drawHoryLine(char c, int lenght);
void drawVertiLine(char c, int lenght);
void drawRectangle(int x, int y, int lenght, int height);
void drawMenu(char *options[], int lenght);
void tasse();
void menuConf(ptConf confChain, ptListener listenerChain);
void menuAbo(ptConf confChain, ptListener listenerChain);
void menu(ptConf confChain, ptListener listenerChain);

void goToCoords(int x, int y)
{
    COORD coords;

    coords.X = x;
    coords.Y = y;

    SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coords);
}

void drawHoryLine(char c, int lenght)
{
    int i = 0;

    while (i != lenght)
    {
        printf("%c", c);
        i++;
    }
}

void drawVertiLine(char c, int lenght)
{
    CONSOLE_SCREEN_BUFFER_INFO info;
    GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &info);
    int x = info.dwCursorPosition.X;
    int y = info.dwCursorPosition.Y;

    int i = 0;

    while (i != lenght)
    {
        goToCoords(x, y + i);
        printf("%c", c);
        i++;
    }
}

void drawRectangle(int x, int y, int lenght, int height)
{
    goToCoords(x, y);
    printf("%c", 201);
    drawHoryLine(205, lenght - 2);
    printf("%c", 187);
    goToCoords(x, y + 1);
    drawVertiLine(186, height - 2);
    goToCoords(x + lenght - 1, y + 1);
    drawVertiLine(186, height - 2);
    goToCoords(x, y + height - 1);
    printf("%c", 200);
    drawHoryLine(205, lenght - 2);
    printf("%c", 188);
}

void drawMenu(char *options[], int lenght)
{
    int max = strlen(options[0]);
    int i;

    for (i = 0; i < lenght; i++)
    {
        if (strlen(options[i]) > max)
        {
            max = strlen(options[i]);
        }
    }

    CONSOLE_SCREEN_BUFFER_INFO info;
    GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &info);
    int columns = info.srWindow.Right - info.srWindow.Left + 1;
    int rows = info.srWindow.Bottom - info.srWindow.Top + 1;

    drawRectangle((columns - max - 4) / 2, 2, max + 4, lenght + 4);

    for (i = 0; i < lenght; i++)
    {
        goToCoords((columns - max - 4) / 2 + 2, 4 + i);
        printf("%s", options[i]);
    }
}

/*
    (  )   (   )  )
     ) (   )  (  (
     ( )  (    ) )
     _____________
    <_____________> ___
    |             |/ _ \
    |               | | |
    |               |_| |
 ___|             |\___/
/    \___________/    \
\_____________________/
*/

void tasse()
{
    printf("    (  )   (   )  )\n     ) (   )  (  (\n     ( )  (    ) )\n     _____________\n    <_____________> ___\n    |             |/ _ \\\n    |               | | |\n    |               |_| |\n ___|             |\\___/\n/    \\___________/    \\\n\\_____________________/\n");
}

void menuConf(ptConf confChain, ptListener listenerChain)
{
    char *options[] = {"1/ Voir la liste des conferences", "2/ Ajouter une conference", "3/ Supprimer une conference", "4/ Supprimer les conferences inferieures a une date", "5/ Retour"};
    system("cls");
    drawMenu(options, 5);
    goToCoords(0, 13);
    tasse();
    printf("\n");
    printf("Que voulez-vous faire ? : ");
    int choice;
    scanf("%d", &choice);

    switch (choice)
    {
    case 1:
    {
        ptConf px = confChain->next;

        while (px->next != NULL)
        {
            printf("Id : %d\nTitre : %s\nConferencier : %s\n", px->id, px->title, px->speaker);
            printf("Date : %d/%d/%d\n", px->day, px->month, px->year);
            printf("Nombre de participants : %d\n", confParticipations(px));
            if (px->listeners->next != NULL)
            {
                printListenerList(px->listeners->next);
            }
            int avg;
            if ((avg = confGradeAvg(px) != -1))
            {
                printf("Moyenne des notes : %d\n", confGradeAvg(px));
            }
            printf("\n");
            px = px->next;
        }
        system("pause");
        menuConf(confChain, listenerChain);
        break;
    }

    case 2:
    {
        int id, day, month, year;
        char title[30];
        char speaker[20];

        id = findConfId(confChain);
        printf("Titre de la conference : ");
        scanf("%29s", &title);
        printf("Nom du conferencier : ");
        scanf("%19s", &speaker);
        printf("Jour : ");
        scanf("%d", &day);
        printf("Mois : ");
        scanf("%d", &month);
        printf("Annee : ");
        scanf("%d", &year);

        addConf(confChain, id, title, speaker, day, month, year);
        saveConf(confChain->next);
        menuConf(confChain, listenerChain);
        break;
    }

    case 3:
    {
        ptConf px = confChain->next;

        printf("\n");
        while (px->next != NULL)
        {
            printf("%d : %s\n", px->id, px->title);
            px = px->next;
        }
        printf("\n");

        int id;

        printf("Id de la conference a supprimer : ");
        scanf("%d", &id);

        removeConf(confChain, id);
        saveConf(confChain->next);
        saveRelations(confChain->next);
        menuConf(confChain, listenerChain);
        break;
    }

    case 4:
    {
        int day, month, year, time;
        printf("Jour : ");
        scanf("%d", &day);
        printf("Mois : ");
        scanf("%d", &month);
        printf("Annee : ");
        scanf("%d", &year);

        time = day + 31 * month + 365 * year;

        ptConf px = confChain;

        while (px->next != NULL)
        {
            if ((px->day + px->month * 31 + px->year * 365) < time && px != confChain)
            {
                ptConf py = px->next;
                removeConf(confChain, px->id);
                px = py;
            }
            else if ((px->day + px->month * 31 + px->year * 365) < time && px == confChain)
            {
                removeConf(confChain, px->id);
            }
            else
            {
                px = px->next;
            }
        }

        saveConf(confChain->next);

        menuConf(confChain, listenerChain);
    }

    case 5:
        menu(confChain, listenerChain);
        break;

    default:
        break;
    }
}

void menuAbo(ptConf confChain, ptListener listenerChain)
{
    char *options[] = {"1/ Voir la liste des abonnes", "2/ Ajouter un abonne", "3/ Suprimer un abonne", "4/ Retour"};
    system("cls");
    drawMenu(options, 4);
    goToCoords(0, 12);
    tasse();
    printf("\n");
    printf("Que voulez-vous faire ? : ");
    int choice;
    scanf("%d", &choice);

    switch (choice)
    {
    case 1:
    {
        ptListener py = listenerChain->next;

        while (py->next != NULL)
        {
            printf("Id : %d\nNom: %s\nAge: %d\nNiveau: %d\n", py->id, py->name, py->age, py->level);
            if (py->confs->next != NULL)
            {
                printConfList(py->confs->next);
            }
            printf("\n");
            py = py->next;
        }
        system("pause");
        menuAbo(confChain, listenerChain);
        break;
    }

    case 2:
    {
        int id, age, level;
        char name[20];

        id = findListenerId(listenerChain);
        printf("Nom : ");
        scanf("%19s", &name);
        printf("Age : ");
        scanf("%d", &age);
        printf("Niveau : ");
        scanf("%d", &level);

        if (addListener(listenerChain, id, name, age, level) != -1)
        {
            saveListeners(listenerChain->next);
        }
        else
        {
            printf("Le niveau de l'abonne doit etre compris entre 0 et 5.\n\n");
            system("pause");
        }
        menuAbo(confChain, listenerChain);
        break;
    }

    case 3:
    {
        ptListener px = listenerChain->next;

        printf("\n");
        while (px->next != NULL)
        {
            printf("%d : %s\n", px->id, px->name);
            px = px->next;
        }
        printf("\n");

        int id;

        printf("Id de l'abonne a supprimer : ");
        scanf("%d", &id);

        removeListener(listenerChain, id);
        saveListeners(listenerChain->next);
        saveRelations(confChain->next);
        menuAbo(confChain, listenerChain);
        break;
    }

    case 4:
        menu(confChain, listenerChain);
        break;

    default:
        break;
    }
}

void menu(ptConf confChain, ptListener listenerChain)
{
    char *options[] = {"1/ Gestion des conferences", "2/ Gestion des abonnes", "3/ Participer a une conference", "4/ Voir la meilleure conference", "5/ Quitter"};
    system("cls");
    drawMenu(options, 5);
    goToCoords(0, 13);
    tasse();
    printf("\n");
    printf("Que voulez-vous faire ? : ");
    int choice;
    scanf("%d", &choice);

    switch (choice)
    {
    case 1:
        menuConf(confChain, listenerChain);
        break;

    case 2:
        menuAbo(confChain, listenerChain);
        break;

    case 3:
    {
        ptConf px = confChain->next;
        ptListener py = listenerChain->next;

        printf("\n");
        while (px->next != NULL)
        {
            printf("%d : %s\n", px->id, px->title);
            px = px->next;
        }
        printf("\n");
        while (py->next != NULL)
        {
            printf("%d : %s\n", py->id, py->name);
            py = py->next;
        }
        printf("\n");

        int confId, listenerId, grade;
        printf("Entrez l'ID de la conference : ");
        scanf("%d", &confId);
        printf("Entrez l'ID du participant : ");
        scanf("%d", &listenerId);
        printf("Entrez la note attribuee par le participant : ");
        scanf("%d", &grade);

        if (participateToConf(confChain, listenerChain, confId, listenerId, grade) != -1)
        {
            saveRelations(confChain->next);
        }
        else
        {
            printf("La note doit etre comprise entre 0 et 5 et l'abonne ne doit pas avoir deja participe a la conference\n\n");
            system("pause");
        }

        menu(confChain, listenerChain);
        break;
    }

    case 4:
    {
        ptConf px = confChain;
        int max = confGradeAvg(px);
        ptConf confMax = px;

        while (px->next != NULL)
        {
            int tmp = confGradeAvg(px);
            if (tmp > max)
            {
                confMax = px;
                max = tmp;
            }

            px = px->next;
        }

        printf("La conférence la mieux notee est : %s\n\n", confMax->title);

        system("pause");
        menu(confChain, listenerChain);

        break;
    }

    case 5:
        break;

    default:
        break;
    }
}

//+----------------------------------------+
//|            Main function               |
//+----------------------------------------+

int main()
{
    ptConf confChain = newConfChain();
    ptListener listenerChain = newListenerChain();

    readConfs(confChain);
    readListeners(listenerChain);
    readRelations(confChain, listenerChain);
    menu(confChain, listenerChain);

    return 0;
}