#include <stdio.h>
#include <stdlib.h>
#include <roxml.h>
#include "structures.h"
#include "terrain.h"
#include "TerrainsXML.h"
#include "structures.h"

/*!
* \file classesXML.c
* \brief Fichier contenant le code des fonctions d'aquisition des terrains.
*/

Terrain* Remplir_Terrains(FILE* Terrains_XML_log, char *filename) /* Remplit le tableau de cases � partir du fichier XML */
{
    fprintf(Terrains_XML_log,"I) Chargement du fichier Terrains XML  - Definition des noeuds\n");
    node_t *rootXML, *TerrainsXML;
    unsigned int i=0, nb_terrains=0;

    rootXML = roxml_load_doc(filename);             /* Ouvre le doc XML et cr�� le noeud de base */
    TerrainsXML = roxml_get_chld(rootXML, NULL, 0);    /* Descend d'un niveau dans l'arborescence */
    nb_terrains = roxml_get_chld_nb(TerrainsXML);         /* R�cup�re le nombre de cases entr�es dans le fichier XML */

    fprintf(Terrains_XML_log,"Le fichier contient %d terrains\n", nb_terrains);

    /*---------------------------------------------------------------------------------------------------*/

    fprintf(Terrains_XML_log,"II) Chargement des terrains\n");

    Terrain* ListeTerrains = NULL;
    ListeTerrains = malloc(nb_terrains * sizeof(Terrain));     /* Allocation de la m�moire n�c�ssaire et test*/
    if (ListeTerrains == NULL)
    {
        fprintf(Terrains_XML_log,"Allocation impossible \n");
        exit(EXIT_FAILURE);
    }
    fprintf(Terrains_XML_log,"1) Memoire allouee avec succes \n");
    fprintf(Terrains_XML_log,"La memoire allouee fait %lu octets\n",nb_terrains * sizeof(Terrain));

    /*--------------------------------------------------------------------------------------------------*/

    for(i=0; i<nb_terrains; i++)   /* Boucle de remplissage des cases */
    {
        fprintf(Terrains_XML_log,"\nChargement du terrain numero %d\n", i+1);

        Terrain Terrain_en_cours;

        node_t *TerrainXML;
        char *id_text, *name_text, *FR_text, *FRS_text, *PDR_text, *DESC_text, *texture_text;
        int FR_int=0, FRS_int=0, PDR_int=0;

        TerrainXML = roxml_get_chld(TerrainsXML, NULL, i);

        id_text = roxml_get_content(roxml_get_attr(TerrainXML, "id", 0), NULL, 0, NULL);
        name_text = roxml_get_content(roxml_get_attr(TerrainXML, "name", 0), NULL, 0, NULL);
        FR_text = roxml_get_content(roxml_get_attr(TerrainXML, "FR", 0), NULL, 0, NULL);
        FRS_text = roxml_get_content(roxml_get_attr(TerrainXML, "FRS", 0), NULL, 0, NULL);
        PDR_text = roxml_get_content(roxml_get_attr(TerrainXML, "PDR", 0), NULL, 0, NULL);
        DESC_text = roxml_get_content(roxml_get_attr(TerrainXML, "Desc", 0), NULL, 0, NULL);
        texture_text = roxml_get_content(roxml_get_attr(TerrainXML, "f_default", 0), NULL, 0, NULL);

        fprintf(Terrains_XML_log,"Id : %s\n", id_text);
        fprintf(Terrains_XML_log,"Nom : %s\n", name_text);
        fprintf(Terrains_XML_log,"FR : %s\n", FR_text);
        fprintf(Terrains_XML_log,"FRS : %s\n", FRS_text);
        fprintf(Terrains_XML_log,"PDR : %s\n", PDR_text);
        fprintf(Terrains_XML_log,"DESC : %s\n", DESC_text);
        fprintf(Terrains_XML_log,"Texture : %s\n", texture_text);

        /* Convertion des caract�ristiques lues vers les types de la struct Case */
        FR_int = atoi(FR_text);
        FRS_int = atoi(FRS_text);
        PDR_int = atoi(PDR_text);

        /* Remplissage des caract�ristiques de la classe en cours */
        switch(FR_int){
        case 0 :
            Terrain_en_cours.franchissable=0;
            break;
        case 1 :
            Terrain_en_cours.franchissable=1;
            break;
        default :
            fprintf(Terrains_XML_log,"ERREUR : FR doit prendre la valeur 0 ou 1 !\n");
            Terrain_en_cours.franchissable=0;
        }

        switch(FRS_int){
        case 0 :
            Terrain_en_cours.franchissable_sorts=0;
            break;
        case 1 :
            Terrain_en_cours.franchissable_sorts=1;
            break;
        default :
            fprintf(Terrains_XML_log,"ERREUR : FRS doit prendre la valeur 0 ou 1 !\n");
            Terrain_en_cours.franchissable_sorts=0;
        }

        Terrain_en_cours.PD_requis=PDR_int;
        strcpy(Terrain_en_cours.nomTerrain, name_text);
        strcpy(Terrain_en_cours.skin_default, texture_text);

        /* Ajout du terrain rempli au tableau */
        fprintf(Terrains_XML_log,"Insertion du terrain %d dans le tableau\n", i+1);
        ListeTerrains[i] = Terrain_en_cours;
    }

    roxml_free_node(rootXML);
    roxml_free_node(TerrainsXML);

    return ListeTerrains;
}



/*!
 * \fn Skins_Charac* Load_Skins_Terrain(char *filename)
 * \brief Fonction qui extrait les noms des fichiers images des terrains.
 *
 * \return Un tableau de noms de fichiers.
 */
Skins_Terrain * Load_Skins_Terrain(char *filename)
{

    FILE* Skins_log = NULL;
    Skins_log = fopen("Skin_XML_log", "w");
    if (Skins_log != NULL)
    {
        node_t *rootXML, *Skins, *Terrains;
        unsigned int i=0, nb_terrains=0;

        rootXML = roxml_load_doc(filename);            /* Ouvre le doc XML et cr�� le noeud de base */
        Skins = roxml_get_chld(rootXML, NULL, 0);
        Terrains = roxml_get_chld(Skins, NULL, 1);
        nb_terrains = roxml_get_chld_nb(Terrains);

        Skins_Terrain* Liste_Skins_Terrains = NULL;
        Liste_Skins_Terrains = malloc(nb_terrains * sizeof(Skins_Terrain));     /* Allocation de la m�moire n�c�ssaire et test*/
        if (Liste_Skins_Terrains == NULL)
        {
            printf("Allocation impossible \n");
            exit(EXIT_FAILURE);
        }

        /* -----------------------------------------------------------------------------------------------------------------------*/

        for(i=0; i<nb_terrains; i++)
        {
            Skins_Terrain Skins_Terrain_en_cours;

            node_t* Skin;
            char *id_text, *default_text;

            Skin = roxml_get_chld(Terrains, NULL, i);
            id_text = roxml_get_content(roxml_get_attr(Skin, "id", 0), NULL, 0, NULL);
            default_text = roxml_get_content(roxml_get_attr(Skin, "f_default", 0), NULL, 0, NULL);

            //Tests
            /*printf("TEST ID : %s\n\n",id_text);
            printf("TEST default : %s\n\n",default_text);
            */

            strcpy(Skins_Terrain_en_cours.terrain_id, id_text);
            strcpy(Skins_Terrain_en_cours.terrain_default, default_text);

            Liste_Skins_Terrains[i] = Skins_Terrain_en_cours;

            //Tests
            /*printf("ID : %s\n\n", Skins_Terrain_en_cours.terrain_id);
            printf("Default : %s\n\n", Skins_Terrain_en_cours.terrain_default);
            */
        }
        fclose(Skins_log);
        return Liste_Skins_Terrains;
    }
    else
    {
        fprintf(stderr,"Impossible d'ouvrir le fichier Skins_XML_log");

    }
}