//
//  Recup_base_donnees.c
//  ordi
//
//  Created by léo LELLOUCHE on 24/05/2016.
//  Copyright © 2016 léo LELLOUCHE. All rights reserved.
//

#include "Header.h"

void        recup_cartes_meres(int fd, int size, t_donnees *données)
{
    char    *chaine_lu;
    char    **chaine_transcrite;
    int     i;
    
    données->cartes_mere = malloc(sizeof(t_carte_mere) * size);
    
    i = 0;
    while(get_next_line(fd, &chaine_lu) != 0)
    {
        
        //Va convertir la chaine lu en tableau 2D en choisissant comme séparateur ';'
        chaine_transcrite = ft_strsplit(chaine_lu, ';');
        free(chaine_lu);
        chaine_lu = NULL;
        
        // On copie la marque
        données->cartes_mere[i].base.marque = malloc(sizeof(char) * strlen(chaine_transcrite[0]));
        strcpy(données->cartes_mere[i].base.marque, chaine_transcrite[0]);
        // On copie le modele
        données->cartes_mere[i].base.modele = malloc(sizeof(char) * strlen(chaine_transcrite[1]));
        strcpy(données->cartes_mere[i].base.modele, chaine_transcrite[1]);
        // On copie le type de socket processeur
        données->cartes_mere[i].socket = malloc(sizeof(char) * strlen(chaine_transcrite[2]));
        strcpy(données->cartes_mere[i].socket, chaine_transcrite[2]);
        // On copie le nombre de socket
        données->cartes_mere[i].nb_socket = atoi(chaine_transcrite[3]);
        // On copie le nombre d'emplacement de RAM
        données->cartes_mere[i].nb_RAM = atoi(chaine_transcrite[4]);
        // On copie la version de la RAM
        données->cartes_mere[i].version_RAM = atoi(chaine_transcrite[5]);
        // On copie le nombre de ports PCIE 16
        données->cartes_mere[i].nb_PCIE = atoi(chaine_transcrite[6]);
        // On copie le nombre de ports IDE
        données->cartes_mere[i].nb_IDE = atoi(chaine_transcrite[7]);
        // On copie le nombre de ports SATA
        données->cartes_mere[i].nb_SATA = atoi(chaine_transcrite[8]);
        // On copie le nombre de ports USB
        données->cartes_mere[i].nb_USB = atoi(chaine_transcrite[9]);
        // On copie le nombre de ports VGA
        données->cartes_mere[i].nb_VGA = atoi(chaine_transcrite[10]);
        // On copie le nombre de ports DVI
        données->cartes_mere[i].nb_DVI = atoi(chaine_transcrite[11]);
        // On copie le nombre de ports réseau
        données->cartes_mere[i].nb_LAN = atoi(chaine_transcrite[12]);
        // On copie le format de la carte
        données->cartes_mere[i].format_carte = malloc(sizeof(char) * strlen(chaine_transcrite[13]));
        strcpy(données->cartes_mere[i].format_carte, chaine_transcrite[13]);
        // On copie les Unique Selling Points
        données->cartes_mere[i].base.USP = malloc(sizeof(char) * strlen(chaine_transcrite[14]));
        strcpy(données->cartes_mere[i].base.USP, chaine_transcrite[14]);
        // On copie le taux de fiabilité
        chaine_transcrite[15][2] = '.'; //C'est très moche mais on va supposer que le taux de fiabilité a 2 chiffres avant la virgule (Donc entre 10% et 99,999...%)
        données->cartes_mere[i].base.fiabilite = atof(chaine_transcrite[15]); //Bug a cause du fonctionnement du double. Donne un arrondit ----------
        // On copie les restictions d'usage
        données->cartes_mere[i].base.restriction = malloc(sizeof(char) * strlen(chaine_transcrite[16]));
        strcpy(données->cartes_mere[i].base.restriction, chaine_transcrite[16]);
        // On copie le prix
        données->cartes_mere[i].base.prix = atoi(chaine_transcrite[17]);
        // On copie la consommation electrique
        données->cartes_mere[i].base.conso = atoi(chaine_transcrite[18]);
        // On copie le coefficient d'overcloking
        données->cartes_mere[i].overclocking = atoi(chaine_transcrite[19]);
        
        ft_free_2d((void ***)&chaine_transcrite, 20);
        i++;
    }
    free(chaine_lu);
}

void        recup_RAM(int fd, int size, t_donnees *données)
{
    char    *chaine_lu;
    char    **chaine_transcrite;
    int     i;
    
    données->RAM = malloc(sizeof(t_RAM) * size);
    
    i = 0;
    while(get_next_line(fd, &chaine_lu) != 0)
    {
        
        //Va convertir la chaine lu en tableau 2D en choisissant comme séparateur ';'
        chaine_transcrite = ft_strsplit(chaine_lu, ';');
        free(chaine_lu);
        chaine_lu = NULL;
        
        // On copie la marque
        données->RAM[i].base.marque = malloc(sizeof(char) * strlen(chaine_transcrite[0]));
        strcpy(données->RAM[i].base.marque, chaine_transcrite[0]);
        // On copie le modele
        données->RAM[i].base.modele = malloc(sizeof(char) * strlen(chaine_transcrite[1]));
        strcpy(données->RAM[i].base.modele, chaine_transcrite[1]);
        // On copie la version de la RAM
        données->RAM[i].version = atoi(chaine_transcrite[2]);
        // On copie la fréquence
        données->RAM[i].frequence = atoi(chaine_transcrite[3]);
        // On copie la quantité par module
        données->RAM[i].capacite = atoi(chaine_transcrite[4]);
        // On copie la fiabilité
        chaine_transcrite[5][2] = '.';
        données->RAM[i].base.fiabilite = atof(chaine_transcrite[5]);
        // On copie les restrictions
        données->RAM[i].base.restriction = malloc(sizeof(char) * strlen(chaine_transcrite[6]));
        strcpy(données->RAM[i].base.restriction, chaine_transcrite[6]);
        // On copie le prix
        données->RAM[i].base.prix = atoi(chaine_transcrite[7]);
        // On copie l'indice de performance
        données->RAM[i].perf = atoi(chaine_transcrite[8]);
        // On copie la consommation electrique
        données->RAM[i].base.conso = atoi(chaine_transcrite[9]);
        // On copie le coefficient d'overcloking
        données->RAM[i].overclocking = atoi(chaine_transcrite[10]);
        données->RAM[i].base.USP = NULL;
        
        ft_free_2d((void ***)&chaine_transcrite, 11);
        i++;
    }
    free(chaine_lu);
}

void        recup_processeurs(int fd, int size, t_donnees *données)
{
    char    *chaine_lu;
    char    **chaine_transcrite;
    int     i;
    
    données->processeurs = malloc(sizeof(t_processeur) * size);
    
    i = 0;
    while(get_next_line(fd, &chaine_lu) != 0)
    {
        
        //Va convertir la chaine lu en tableau 2D en choisissant comme séparateur ';'
        chaine_transcrite = ft_strsplit(chaine_lu, ';');
        free(chaine_lu);
        chaine_lu = NULL;
        
        // On copie la marque
        données->processeurs[i].base.marque = malloc(sizeof(char) * strlen(chaine_transcrite[0]));
        strcpy(données->processeurs[i].base.marque, chaine_transcrite[0]);
        // On copie le modele
        données->processeurs[i].base.modele = malloc(sizeof(char) * strlen(chaine_transcrite[1]));
        strcpy(données->processeurs[i].base.modele, chaine_transcrite[1]);
        // On copie le type de socket processeur
        données->processeurs[i].socket = malloc(sizeof(char) * strlen(chaine_transcrite[2]));
        strcpy(données->processeurs[i].socket, chaine_transcrite[2]);
        // On copie la fréquence
        données->processeurs[i].frequence = atoi(chaine_transcrite[3]);
        // On copie le nombre d'emplacement de RAM
        données->processeurs[i].nb_RAM = atoi(chaine_transcrite[4]);
        // On copie les USP
        données->processeurs[i].base.USP = malloc(sizeof(char) * strlen(chaine_transcrite[5]));
        strcpy(données->processeurs[i].base.USP, chaine_transcrite[5]);
        // On copie la fiabilité
        chaine_transcrite[6][2] = '.';
        données->processeurs[i].base.fiabilite = atof(chaine_transcrite[6]);
        // On copie les restrictions
        données->processeurs[i].base.restriction = malloc(sizeof(char) * strlen(chaine_transcrite[7]));
        strcpy(données->processeurs[i].base.restriction, chaine_transcrite[7]);
        // On copie le prix
        données->processeurs[i].base.prix = atoi(chaine_transcrite[8]);
        // On copie l'indice de performance
        données->processeurs[i].perf = atoi(chaine_transcrite[9]);
        // On copie la consommation electrique
        données->processeurs[i].base.conso = atoi(chaine_transcrite[10]);
        // On copie le coefficient d'overcloking
        données->processeurs[i].overclocking = atoi(chaine_transcrite[11]);
        
        ft_free_2d((void ***)&chaine_transcrite, 12);
        i++;
    }
    free(chaine_lu);
}

void        recup_graphic(int fd, int size, t_donnees *données)
{
    char    *chaine_lu;
    char    **chaine_transcrite;
    int     i;
    
    données->graphic = malloc(sizeof(t_graphic) * size);
    
    i = 0;
    while(get_next_line(fd, &chaine_lu) != 0)
    {
        
        //Va convertir la chaine lu en tableau 2D en choisissant comme séparateur ';'
        chaine_transcrite = ft_strsplit(chaine_lu, ';');
        free(chaine_lu);
        chaine_lu = NULL;
        
        // On copie la marque
        données->graphic[i].base.marque = malloc(sizeof(char) * strlen(chaine_transcrite[0]));
        strcpy(données->graphic[i].base.marque, chaine_transcrite[0]);
        // On copie le modele
        données->graphic[i].base.modele = malloc(sizeof(char) * strlen(chaine_transcrite[1]));
        strcpy(données->graphic[i].base.modele, chaine_transcrite[1]);
        // On copie le nombre de ports VGA
        données->graphic[i].nb_VGA = atoi(chaine_transcrite[2]);
        // On copie le nombre de ports DVI
        données->graphic[i].nb_DVI = atoi(chaine_transcrite[3]);
        // On copie le nombre de ports de HDMI
        données->graphic[i].nb_HDMI = atoi(chaine_transcrite[4]);
        // On copie le nombre de ports MiniDP
        données->graphic[i].nb_MiniDP = atoi(chaine_transcrite[5]);
        // On copie les USP
        données->graphic[i].base.USP = malloc(sizeof(char) * strlen(chaine_transcrite[6]));
        strcpy(données->graphic[i].base.USP, chaine_transcrite[6]);
        // On copie la fiabilité
        chaine_transcrite[7][2] = '.';
        données->graphic[i].base.fiabilite = atof(chaine_transcrite[7]);
        // On copie les restrictions
        données->graphic[i].base.restriction = malloc(sizeof(char) * strlen(chaine_transcrite[8]));
        strcpy(données->graphic[i].base.restriction, chaine_transcrite[8]);
        // On copie le prix
        données->graphic[i].base.prix = atoi(chaine_transcrite[9]);
        // On copie l'indice de performance
        données->graphic[i].perf = atoi(chaine_transcrite[10]);
        // On copie la consommation electrique
        données->graphic[i].base.conso = atoi(chaine_transcrite[11]);
        // On copie le coefficient d'overcloking
        données->graphic[i].overclocking = atoi(chaine_transcrite[12]);
        
        ft_free_2d((void ***)&chaine_transcrite, 13);
        i++;
    }
    free(chaine_lu);
}

void        recup_HDD(int fd, int size, t_donnees *données)
{
    char    *chaine_lu;
    char    **chaine_transcrite;
    int     i;
    
    données->HDD = malloc(sizeof(t_HDD) * size);
    
    i = 0;
    while(get_next_line(fd, &chaine_lu) != 0)
    {
        
        //Va convertir la chaine lu en tableau 2D en choisissant comme séparateur ';'
        chaine_transcrite = ft_strsplit(chaine_lu, ';');
        free(chaine_lu);
        chaine_lu = NULL;
        
        // On copie la marque
        données->HDD[i].base.marque = malloc(sizeof(char) * strlen(chaine_transcrite[0]));
        strcpy(données->HDD[i].base.marque, chaine_transcrite[0]);
        // On copie le modele
        données->HDD[i].base.modele = malloc(sizeof(char) * strlen(chaine_transcrite[1]));
        strcpy(données->HDD[i].base.modele, chaine_transcrite[1]);
        // On copie l'espace disque
        données->HDD[i].capacite = atoi(chaine_transcrite[2]);
        // On copie le type de port
        données->HDD[i].type_port = malloc(sizeof(char) * strlen(chaine_transcrite[3]));
        strcpy(données->HDD[i].type_port, chaine_transcrite[3]);
        // On copie les USP
        données->HDD[i].base.USP = malloc(sizeof(char) * strlen(chaine_transcrite[4]));
        strcpy(données->HDD[i].base.USP, chaine_transcrite[4]);
        // On copie la fiabilité
        chaine_transcrite[5][2] = '.';
        données->HDD[i].base.fiabilite = atof(chaine_transcrite[5]);
        // On copie les restrictions
        données->HDD[i].base.restriction = malloc(sizeof(char) * strlen(chaine_transcrite[6]));
        strcpy(données->HDD[i].base.restriction, chaine_transcrite[6]);
        // On copie le prix
        données->HDD[i].base.prix = atoi(chaine_transcrite[7]);
        // On copie l'indice de performance
        données->HDD[i].perf = atoi(chaine_transcrite[8]);
        // On copie la consommation electrique
        données->HDD[i].base.conso = atoi(chaine_transcrite[9]);
        
        ft_free_2d((void ***)&chaine_transcrite, 10);
        i++;
    }
    free(chaine_lu);
}

void        recup_ecran(int fd, int size, t_donnees *données)
{
    char    *chaine_lu;
    char    **chaine_transcrite;
    int     i;
    
    données->ecrans = malloc(sizeof(t_ecran) * size);
    
    i = 0;
    while(get_next_line(fd, &chaine_lu) != 0)
    {
        
        //Va convertir la chaine lu en tableau 2D en choisissant comme séparateur ';'
        chaine_transcrite = ft_strsplit(chaine_lu, ';');
        
        free(chaine_lu);
        chaine_lu = NULL;
        // On copie la marque
        données->ecrans[i].base.marque = malloc(sizeof(char) * strlen(chaine_transcrite[0]));
        strcpy(données->ecrans[i].base.marque, chaine_transcrite[0]);
        // On copie le modele
        données->ecrans[i].base.modele = malloc(sizeof(char) * strlen(chaine_transcrite[1]));
        strcpy(données->ecrans[i].base.modele, chaine_transcrite[1]);
        // On copie la taille
        données->ecrans[i].size = atoi(chaine_transcrite[2]);
        // On copie la résolution (on ne prend qu'une des 2 valeurs car les écrans ont tous le même ratio)
        données->ecrans[i].resolution = atoi(chaine_transcrite[3]);
        // On copie le type de port
        données->ecrans[i].port = malloc(sizeof(char) * strlen(chaine_transcrite[4]));
        strcpy(données->ecrans[i].port, chaine_transcrite[4]);
        // On copie les USP
        données->ecrans[i].base.USP = malloc(sizeof(char) * strlen(chaine_transcrite[5]));
        strcpy(données->ecrans[i].base.USP, chaine_transcrite[5]);
        // On copie la fiabilité
        chaine_transcrite[6][2] = '.';
        données->ecrans[i].base.fiabilite = atof(chaine_transcrite[6]);
        // On copie les restrictions
        données->ecrans[i].base.restriction = malloc(sizeof(char) * strlen(chaine_transcrite[7]));
        strcpy(données->ecrans[i].base.restriction, chaine_transcrite[7]);
        // On copie le prix
        données->ecrans[i].base.prix = atoi(chaine_transcrite[8]);
        // On copie l'indice de performance
        données->ecrans[i].perf = atoi(chaine_transcrite[9]);
        // On copie la consommation electrique
        données->ecrans[i].base.conso = atoi(chaine_transcrite[10]);
        
        ft_free_2d((void ***)&chaine_transcrite, 11);
        i++;
    }
    
    free(chaine_lu);
}

void        recup_softs(int fd, int size, t_donnees *données)
{
    char    *chaine_lu;
    char    **chaine_transcrite;
    int     i;
    
    données->softs = malloc(sizeof(t_soft) * size);
    
    i = 0;
    while(get_next_line(fd, &chaine_lu) != 0)
    {
        
        //Va convertir la chaine lu en tableau 2D en choisissant comme séparateur ';'
        chaine_transcrite = ft_strsplit(chaine_lu, ';');
        free(chaine_lu);
        chaine_lu = NULL;
        
        // On copie le nom du soft
        données->softs[i].nom_logiciel = malloc(sizeof(char) * strlen(chaine_transcrite[0]));
        strcpy(données->softs[i].nom_logiciel, chaine_transcrite[0]);
        // On copie la RAM nécéssaire
        données->softs[i].RAM = atoi(chaine_transcrite[1]);
        // On copie l'espace disque nécéssaire
        données->softs[i].disque = atoi(chaine_transcrite[2]);
        // On copie la puissance graphique
        données->softs[i].graphic = atoi(chaine_transcrite[3]);
        // On copie la puissance processeur
        données->softs[i].processeur = atoi(chaine_transcrite[4]);
        // On copie les UPS
        données->softs[i].USP = malloc(sizeof(char) * strlen(chaine_transcrite[5]));
        strcpy(données->softs[i].USP, chaine_transcrite[5]);
        
        ft_free_2d((void ***)&chaine_transcrite, 6);
        i++;
    }
    free(chaine_lu);
}

void        recup_config(int fd, int size, t_donnees *données)
{
    
    char    *chaine_lu;
    char    **chaine_transcrite;
    int     i;
    int     j;
    
    données->configs = malloc(sizeof(t_config) * size);
    
    i = 0;
    while(get_next_line(fd, &chaine_lu) != 0)
    {
        //Va convertir la chaine lu en tableau 2D en choisissant comme séparateur ';'
        chaine_transcrite = ft_strsplit(chaine_lu, ';');
        free(chaine_lu);
        chaine_lu = NULL;
        
        // On cherche la carte mère
        j = 0;
        while ((strcmp(données->cartes_mere[j].base.marque, chaine_transcrite[0]) != 0) && (strcmp(données->cartes_mere[j].base.marque, chaine_transcrite[1]) != 0))
            j++;
        données->configs[i].carte_mere = &(données->cartes_mere[j]);
        
        //On recherche la RAM
        j = 0;
        while ((strcmp(données->RAM[j].base.marque, chaine_transcrite[2]) != 0) && (strcmp(données->RAM[j].base.marque, chaine_transcrite[3]) != 0))
            j++;
        données->configs[i].RAM = &(données->RAM[j]);
        
        //On recherche la processeur
        j = 0;
        while ((strcmp(données->processeurs[j].base.marque, chaine_transcrite[4]) != 0) && (strcmp(données->processeurs[j].base.marque, chaine_transcrite[5]) != 0))
            j++;
        données->configs[i].processeur = &(données->processeurs[j]);
        
        //On recherche la carte graphique
        j = 0;
        while ((strcmp(données->graphic[j].base.marque, chaine_transcrite[6]) != 0) && (strcmp(données->graphic[j].base.marque, chaine_transcrite[7]) != 0))
            j++;
        données->configs[i].graphic = &(données->graphic[j]);
        
        //On recherche le disque dur
        j = 0;
        while ((strcmp(données->HDD[j].base.marque, chaine_transcrite[8]) != 0) && (strcmp(données->HDD[j].base.marque, chaine_transcrite[9]) != 0))
            j++;
        données->configs[i].HDD = &(données->HDD[j]);
        
        // On copie le prix
        données->configs[i].prix = atoi(chaine_transcrite[10]);
        
        ft_free_2d((void ***)&chaine_transcrite, 11);
        i++;
    }
    free(chaine_lu);
}