#include <stdio.h>
#include <stdlib.h>
#include <roxml.h>
#include "structures.h"
#include "competence.h"


/*!
* \file competence.c
* \brief Fichier contenant le code des fonctions liees aux arbres de comp�tences.
*/

/*! Copie de la struct Competence pour travailler

typedef struct Competence{
    char nomComp[TAILLE_NOMS];
    char id[TAILLE_ID];
    unsigned int prix_competence;
    struct Competence *frere;
    struct Competence *enfant;
    struct Effet_Competence *effet;
    boolean connu;
}Competence;

*/


/*!
 * \fn int set_Enfant(Competence *parent, Competence *enfant)
 * \brief La fonction ajoute un enfant � une competence.
 *
 * \return Un entier.
 */
int set_Enfant(Competence *parent, Competence *nouvel_enfant)
{
    if(estVide(parent))
    {
        parent->enfant = nouvel_enfant;
    }
   /* else
    {
        Competence *enfant = parent->enfant;
        while(enfant!=NULL)
        {
            enfant = enfant->frere;
        }
        enfant->frere = nouvel_enfant;
    }*/
    return 0;
}


int set_comp_name(Competence *comp, char *nom_donne)
{
    strcpy(comp->nomComp, nom_donne);
}

int set_comp_id(Competence *comp, char *nom_donne)
{
    strcpy(comp->id, nom_donne);
}


/*!
 * \fn int init_Competence(Competence *noeud)
 * \brief La fonction initialise une competence.
 *
 * \return Un entier.
 */
int init_Competence(Competence *noeud)
{
    memset(noeud->nomComp, 0, sizeof(noeud->nomComp));
    memset(noeud->id, 0, sizeof(noeud->id));
    noeud->prix_competence = 0;
    noeud->frere = NULL;
    noeud->enfant = NULL;
    noeud->effet = NULL;
    noeud->connu = 0;

    return 0;
}


/*!
 * \fn int taille(Competence *noeud)
 * \brief La fonction renvoie le nombre d'enfants totaux d'une competence.
 *
 * \return Un entier positif.
 */
int taille(Competence *noeud)
{
    Competence *enfant;
    int compteur = 1;
    for (enfant = noeud->enfant; enfant != NULL; enfant = enfant->frere)
        compteur += taille(enfant);
    return compteur;
}


/*!
 * \fn unsigned int hauteur(Competence *noeud)
 * \brief La fonction indique la hauteur d'une competence dans l'arbre.
 *
 * \return Un entier positif.
 */
unsigned int hauteur(Competence *noeud)
{
    if (!estVide(noeud))
    {
        int compteur = 1;
        Competence *enfant;
        for (enfant = noeud->enfant; enfant != NULL; enfant = enfant->frere)
        {
            if (hauteur(enfant) > compteur)
                compteur = 1 + hauteur(enfant);
        }
        return compteur;
    }
    else
    {
        return 0;
    }
}

/*!
 * \fn int estVide(Competence *c)
 * \brief La fonction indique si une competence n'a pas d'enfants.
 *
 * \return Un booleen.
 */
int estVide(Competence *c)
{
    if (c->enfant == NULL)
        return 0;
    else
        return 1;
}


/*!
 * \fn boolean est_connue(Competence *c)
 * \brief La fonction indique si une competence est connue ou non.
 *
 * \return Un booleen.
 */
boolean est_connue(Competence *c)
{
    return (c->connu);
}


/*!
 * \fn unsigned int * NbEnfants(Competence *noeud)
 * \brief La fonction renvoie le nombre d'enfants d'une competence.
 *
 * \return Un entier positif.
 */
unsigned int NbEnfants(Competence *noeud)
{
    unsigned int nb;
    if (estVide(noeud))
    {
        nb = 0;
    }
    else
    {
        Competence *enfant;
        for(noeud->enfant; enfant!= NULL; enfant=enfant->frere);

        nb++;
    }
    return nb;
}


int rafraichir_competences(Competence * a)
{
    return 0;
}



/*!
 * \fn boolean * est_complet(Competence *noeud)
 * \brief La fonction verifie si l'arbre est complet ou non.
 *
 * \return Un booleen.
 */
boolean est_complet(Competence *noeud)
{
    Competence *enfant;
    for(noeud->enfant; enfant!= NULL; enfant=enfant->frere)
    {
        if(!est_complet(enfant))
            return 0;
    }
    return 1;
}

int chemin_auto_competence(Competence* c)       /* Renvoie la liste des comp�tences non connues se trouvant sur le chemin d'une comp�tence s�lectionn�e */
{
    return 0;
}

Effet_Competence * get_effet(Competence *c)       /* Renvoie l'effet d'une competence */
{
    return c->effet;
}




Competence* Extraire_Arbres(char *filename)
{
    node_t *rootXML, *Arbres;
    char *id_text, *name_text;
    int nb_Arbres=0, i_0=0;

    rootXML = roxml_load_doc(filename);
    Arbres = roxml_get_chld(rootXML,"Arbres",0);
    nb_Arbres = roxml_get_chld_nb(Arbres);
    printf("On a %d arbres de competences \n", nb_Arbres);

    /* ---------------------------------------------------------------------------------------------- */
    /* Extraction des arbres */
    /* ---------------------------------------------------------------------------------------------- */

    for(i_0=0; i_0<nb_Arbres; i_0++)
    {
        node_t *ArbreXML_Actuel = roxml_get_chld(Arbres, NULL, i_0);
        Competence *Arbre_Actuel;
        int nb_Comp1=0, i_1=0;

        init_Competence(Arbre_Actuel);

        nb_Comp1 = roxml_get_chld_nb(ArbreXML_Actuel);
        printf("L'arbre %d contient %d competences de niveau 1\n",i_0, nb_Comp1);
        set_comp_name(Arbre_Actuel,roxml_get_content(roxml_get_attr(ArbreXML_Actuel,"id",0),NULL,0,NULL));
        printf("L'arbre actuel a pour nom : %s\n", Arbre_Actuel->nomComp);

        /* ---------------------------------------------------------------------------------------------- */
        /* Extraction des competences 1 */
        /* ---------------------------------------------------------------------------------------------- */

        for(i_1=0; i_1<nb_Comp1; i_1++)
        {
            node_t *CompetenceXML_1;
            Competence *Competence_1;
            int nb_Comp2=0, i_2=0;

            init_Competence(Competence_1);

            CompetenceXML_1 = roxml_get_chld(ArbreXML_Actuel, NULL, i_1);
            nb_Comp2 = roxml_get_chld_nb(CompetenceXML_1);
            printf("La competence numero %d de niveau 1 contient %d competences de niveau 2\n",i_1+1,nb_Comp2);

            set_comp_name(Competence_1,roxml_get_content(roxml_get_attr(CompetenceXML_1,"nom",0),NULL,0,NULL));

            for(i_2=0; i_2<nb_Comp1; i_2++)
            {
            }


            /* La competence j devient un enfant de la competence i */
            set_Enfant(Arbre_Actuel, Competence_1);
            printf("L'enfant est : %s\n", Arbre_Actuel->enfant->nomComp);
        }
    }
    return 0;
}


int Test_Competences()
{
    char* nomTest = "LeNom";
    printf("Debut Test Competences\n");

    Competence *Comp_Test_Parent, *Comp_Test_Enfant;
/*
    set_comp_name(Comp_Test_Parent, "Papa");
    set_comp_id(Comp_Test_Parent, "ID_PA");
    set_comp_name(Comp_Test_Enfant, "Bebe");
    set_comp_id(Comp_Test_Enfant, "ID_BE");

    init_Competence(Comp_Test_Parent);
    init_Competence(Comp_Test_Enfant);



*/


    /*Verif */
   /* printf("Le nom est : %s\n", Comp_Test_Parent->nomComp);
    printf("L'ID est : %s\n", Comp_Test_Parent->id);
    printf("Le nom est : %s\n", Comp_Test_Enfant->nomComp);
    printf("L'ID est : %s\n", Comp_Test_Enfant->id);

    printf("Lol");
*/
    //printf("On a : %d\n", Comp_Test_Parent->connu);



  // set_Enfant(&Comp_Test_Parent, &Comp_Test_Enfant);

//   printf("L'enfant de %s est : %s\n",Comp_Test_Parent.nomComp,Comp_Test_Enfant.nomComp);
//   printf("L'id de l'enfant de %s est : %s\n",Comp_Test_Parent.nomComp,Comp_Test_Parent.enfant.nomComp);


   return 0;
}