#include <time.h>
#include <stdlib.h>
#include <gtk/gtk.h>
#include <curl/curl.h>
typedef struct connectParam
{
    GtkBuilder gtkBuilder;
    int isConnected;
}connectParam;
// GTK Callbacks
void getFood(GtkWidget *widget,gpointer gtkBuilder);
void checkLogin(GtkWidget *widget,gpointer pData);
void clearList(GtkWidget *widget, gpointer gtkBuilder);

// Functions
GtkBuilder *initGtkBuilder(char *cFileName);
void get_page(const char* url, const char* file_name);
char* searchInJson(char* word,char* file_name);
void launchMainWindow();
void showError(GtkWindow *window,char *message);

void clearList(GtkWidget *widget, gpointer gtkBuilder){
    GtkBox *foodList = GTK_BOX(gtk_builder_get_object(gtkBuilder,"foodList"));
    GList *children, *iter;

    children = gtk_container_get_children(GTK_CONTAINER(foodList));
    for(iter = children; iter != NULL; iter = g_list_next(iter))
        gtk_widget_destroy(GTK_WIDGET(iter->data));
    g_list_free(children);

    FILE *file = fopen("api.json","r");
    char *code;

    size_t n = 0;
    int c;

    code = malloc(1000);

    while ((c = fgetc(file)) != '[')
    {
        code[n++] = (char) c;
    }

    // don't forget to terminate with the null character
    code[n] = '\0';

    fclose(file);

    remove("api.json");

    file = fopen("api.json","w+");
    fprintf(file,"%s[",code);
    fclose(file);

}
void showError(GtkWindow *window,char *message){
    GtkWidget *message_dialog =
            gtk_message_dialog_new (
                    window,
                    GTK_DIALOG_MODAL,
                    GTK_MESSAGE_ERROR,
                    GTK_BUTTONS_NONE,
                    message);
    gtk_widget_show_all (message_dialog);
}

void sendJson(GtkWidget *widget, gpointer gtkBuilder){
    FILE *api = fopen("api.json","a");

    fprintf(api,"]}");

    fclose(api);
    // Envoyer en curl

    printf("\n ENVOI DU JSON\n");
}

void getFood(GtkWidget *widget,gpointer gtkBuilder){
    // On récupère le code barre
    GtkEntry *barCodeEntry = GTK_ENTRY(gtk_builder_get_object(GTK_BUILDER(gtkBuilder),"barCode"));
    const gchar *barCodeTxt = gtk_entry_get_text(barCodeEntry);

    // Si le code barre est vide on affiche une erreur
    if(strcmp(barCodeTxt,"") == 0){

    }else{
        // Si le code barre n'est pas vide on vient attaquer l'API
        // URL de l'API
        char url[500] = "https://world.openfoodfacts.org/api/v0/product/";
        // Pour rajouter l'extension après le barcode
        char extension[6];
        sprintf(extension,".json");
        // On concatène le tout pour avoir l'URL
        strcat(url,barCodeTxt);
        strcat(url,extension);
        // On get le résultat dans un fichier
        char *jsonName = "tempFood.json";
        get_page(url,jsonName);
        // Si on l'API nous dit qu'elle a trouvé le produit
        if (strcmp(searchInJson("status_verbose",jsonName),"product found") == 0){
            // On vient chercher les paramètres qui nous intéréssent dans le json
            char *code = searchInJson("code",jsonName);
            char *quantity = searchInJson("quantity",jsonName);
            char *product_name = searchInJson("product_name",jsonName);
            char *image_url = searchInJson("image_url",jsonName);
            char *ingredients_text = searchInJson("ingredients_text",jsonName);
            char *brands = searchInJson("brands",jsonName);

            // On récupère la quantité saisie au passage
            const gchar *quantityTxt = gtk_entry_get_text(GTK_ENTRY(gtk_builder_get_object(gtkBuilder,"quantityEntry")));

            // Si aucune quantité n'a été saisie par défaut on laisse x1
            if (strcmp(quantityTxt,"") == 0){
                quantityTxt = "1";
            }

            // On rajoute le produit et sa quantité dans le fichier qui sera envoyé à l'API
            FILE *api;
            api = fopen("api.json","a");
            fprintf(api,"{\n\"code\":\"%s\",\n",code);
            fprintf(api,"\"product_name\":\"%s\",\n",product_name);
            fprintf(api,"\"ingredients_text\":\"%s\",\n",ingredients_text);
            fprintf(api,"\"quantity\":\"%s\",\n",quantity);
            fprintf(api,"\"brands\":\"%s\",\n",brands);
            fprintf(api,"\"image_url\":\"%s\",\n",image_url);
            fprintf(api,"\"quantity_nbr\":\"%s\"\n},\n",quantityTxt);

            fclose(api);

            // On le rajoute maintenant dans l'interface graphique
            GtkBox *foodList = GTK_BOX(gtk_builder_get_object(gtkBuilder,"foodList"));

            // On crée un GtkLabel qui contiendra la quantité le nom et la marque
            char foodTxt[1000] = "";
            sprintf(foodTxt,"x%s - %s - %s",quantityTxt,brands,product_name);
            GtkLabel *label = GTK_LABEL(gtk_label_new("food"));
            gtk_label_set_text(label,foodTxt);

            // On ajoute le label au container et on affiche le tout
            gtk_container_add(GTK_CONTAINER(foodList),GTK_WIDGET(label));
            gtk_widget_show_all(GTK_WIDGET(foodList));

            // On reset les deux champs de saisie pour pouvoir saisir un nouvel objet
            gtk_entry_set_text(barCodeEntry,"");
            gtk_entry_set_text(GTK_ENTRY(gtk_builder_get_object(gtkBuilder,"quantityEntry")),"");
        }else{

            GtkWindow *parent = GTK_WINDOW(gtk_builder_get_object(gtkBuilder,"mainWindow"));

            printf("Produit non trouvé\n");
        }
        remove(jsonName);
    }
}
void launchMainWindow(){
    // On initialise un nouveau builder avec la fenêtre principale
    GtkBuilder *gtkBuilder;
    GtkWindow *mainWindow;

    gtkBuilder = GTK_BUILDER(initGtkBuilder("mainWindow.glade"));

    mainWindow = GTK_WINDOW(gtk_builder_get_object(GTK_BUILDER(gtkBuilder), "mainWindow"));
    gtk_widget_show(GTK_WIDGET(mainWindow));

    // On récupère les boutons pour leur affecter un signal
    GtkButton *submitBtn = GTK_BUTTON(gtk_builder_get_object(GTK_BUILDER(gtkBuilder), "barCodeSubmit"));
    GtkButton *validateBtn = GTK_BUTTON(gtk_builder_get_object(GTK_BUILDER(gtkBuilder), "btnValidate"));
    GtkButton *clearBtn = GTK_BUTTON(gtk_builder_get_object(GTK_BUILDER(gtkBuilder),"cancelAll"));
    // On affecte les signaux

    g_signal_connect(submitBtn, "clicked", G_CALLBACK(getFood), gtkBuilder);
    g_signal_connect(validateBtn,"clicked",G_CALLBACK(sendJson),gtkBuilder);
    g_signal_connect(clearBtn,"clicked",G_CALLBACK(clearList),gtkBuilder);
}
void checkLogin(GtkWidget *widget,gpointer pData){
    struct connectParam *ptest = pData;

    GtkBuilder *gtkBuilder = &ptest->gtkBuilder;

    const gchar *passwordTxt,*emailTxt;
    GtkEntry *passwordEntry,*emailEntry;

    emailEntry = GTK_ENTRY(gtk_builder_get_object(gtkBuilder,"email"));
    passwordEntry = GTK_ENTRY(gtk_builder_get_object(gtkBuilder,"password"));

    emailTxt = gtk_entry_get_text(emailEntry);
    passwordTxt = gtk_entry_get_text(passwordEntry);

    // On va venir cURLer l'API de connexion avec nos paramètres
    CURL *curl;

    curl_global_init(CURL_GLOBAL_ALL);
    curl = curl_easy_init();
    if(curl) {
        // On crée un fichier qui contiendra le résultat de la connexion
        FILE* file = fopen("connect_result.txt", "w+");

        // On crée la chaîne de caractères qui contiendra les paramètres à passer en post
        char postParameters[1000];

        // On prépare la chaîne pour les paramètres en post en y ajoutant l'email et le password rentrés
        sprintf(postParameters,"_username=%s&_password=%s",emailTxt,passwordTxt);

        // On set l'URL à CURL et on lui passe les paramètres et le fichier de sortie
        curl_easy_setopt(curl, CURLOPT_URL, "https://ffw-pmv.com/api/user/connect");
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS,postParameters);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, file);

        // On éxécute la requête et on la termine proprement
        curl_easy_perform(curl);
        curl_easy_cleanup(curl);

        // On revient au début du fichier pour pouvoir le lire
        rewind(file);

        // On récupère le résultat de la connexion qui est stocké dans le fichier
        char result[6] = "";
        fgets(result,6,file);

        // On ferme le fichier et on le supprime car on en a plus besoin
        fclose(file);
        remove("connect_result.txt");

        // On teste si le résultat est true ou pas
        if(strcmp(result,"true") != 0){
            ptest->isConnected = 1;
            printf("Connexion réussie \n");
            // On récupère la fenêtre active
            GtkWindow *activeWindow;
            activeWindow = GTK_WINDOW(gtk_builder_get_object(GTK_BUILDER(gtkBuilder), "loginWindow"));
            // On ferme la fenêtre active
            gtk_window_close(activeWindow);

            // On vient créer un JSON qui contiendra les informations de l'utilisateur qu'on
            // enverra plus tard à l'API Web avec les produits
            FILE *json;
            json = fopen("api.json","w+");

            fprintf(json,"{\n");
            fprintf(json,"\"email\":\"%s\",\n",emailTxt);
            fprintf(json,"\"password\":\"%s\",\n",passwordTxt);
            fprintf(json,"\"articles\":[\n");

            fclose(json);

            launchMainWindow();
        }else{
            printf("Connexion échouée\n");
        }
    }
    curl_global_cleanup();
}
void get_page(const char* url, const char* file_name){
    CURL *curl;
    CURLcode res;

    curl_global_init(CURL_GLOBAL_ALL);
    curl = curl_easy_init();
    if(curl) {
        FILE* file = fopen(file_name, "w");
        curl_easy_setopt(curl, CURLOPT_URL, url);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, file);

        //curl_easy_setopt(curl, CURLOPT_POSTFIELDS, "name=daniel&project=curl");

        curl_easy_perform(curl);
        curl_easy_cleanup(curl);

        fclose(file);
    }
    curl_global_cleanup();
}
char* searchInJson(char* word,char* file_name){
    FILE *file =fopen(file_name,"r");
    int open = 0,next = 0,returnOk = 0;

    char c;
    char storedWord[5000] = "";
    do
    {
        c = fgetc(file);
        if (c == '"'){
            if(open == 0){
                open = 1;
            }else{
                open = 0;
                if(next == 1){
                    returnOk = 1;
                    break;
                }
                if(strcmp(storedWord,word) == 0){
                    next = 1;
                }
                strcpy(storedWord, "");
            }
        }else{
            if(open != 0){
                char temp[2];
                temp[0] = c;
                temp[1] = '\0';
                strcat(storedWord,temp);
            }
        }
    } while(c != EOF);
    if(returnOk == 1){
        char *string = malloc(strlen(storedWord));
        strcpy(string,storedWord);
        return string;
    }else{
        return 0;
    }
}
GtkBuilder *initGtkBuilder(char *cFileName){

    GtkBuilder *builder = NULL;
    GError *error = NULL;

    gchar *gFileName;

    //Ouverture du fichier .glade
    if((builder = gtk_builder_new())==NULL){
        return NULL;
    }
    if((gFileName = g_build_filename (cFileName, NULL))==NULL){
        return NULL;
    }
    gtk_builder_get_translation_domain (builder);
    //Chargement du fichier .glade
    if(gtk_builder_add_from_file (builder, gFileName, &error)){
        if(error!=NULL){
            g_error_free(error);
        }
        g_free (gFileName);
        return builder;
    }
    g_free (gFileName);
    return NULL;
}
int main(int argc,char **argv)
{
    // Initialisation de GTK
    gtk_init(&argc, &argv);
    GtkWidget *loginWindow;

    char *barCodeTxt;
    // On ouvre le fichier Glade du projet
    GtkBuilder *gtkBuilder = initGtkBuilder("loginWindow.glade");

    // On récupère la fenêtre principale
    loginWindow = GTK_WIDGET(gtk_builder_get_object(gtkBuilder,"loginWindow"));

    // On lance la fenêtre principale
    gtk_widget_show(GTK_WIDGET(loginWindow));

    // On récupère notre input et notre bouton
    GtkButton *btnConnect = GTK_BUTTON(gtk_builder_get_object(gtkBuilder,"btnConnect"));

    // On crée une structure pour pouvoir envoyer notre builder et savoir si l'utilisateur est connecté
    connectParam connectParam;
    connectParam.gtkBuilder = *gtkBuilder;
    connectParam.isConnected = 0;

    g_signal_connect(btnConnect,"clicked",G_CALLBACK(checkLogin),&connectParam);
    // Pour ne pas que GTK se ferme
    gtk_main();

    return EXIT_SUCCESS;
}