#include "Beloeil-Masson-arcs.h"

using namespace std;

arcs::arcs(int dep, int arr, int dis){

    _dep=dep;
    _arr=arr;
    _dis=dis;
}

sommet::sommet(int id,int place,arcs tmparc){
    _place=place;
    _id=id;
    listeArcs.push_back(tmparc);
}
sommet::sommet(int id,int place){
    _place=place;
    _id=id;
}

graph::graph(){


}

graph::graph(string mon_fichier){
    ifstream File;
    File.open(mon_fichier.c_str());
    string tmp;

    if(File) {
        // On elimine la première ligne
        File >> tmp;

        // Recupéreration du nbSommets
        File >> tmp;


        /** Nous considérons que le fichier est bien formaté */
        cout << " Nombre de sommet : " << tmp << endl;
        while(tmp != "graphe") {
          nb_sommet = atoi(tmp.c_str());
          File >> tmp;
        }

        File >> tmp;
        while(tmp != "FIN") {
          string dep_tmp;
          dep_tmp = tmp;
          string dis_tmp;
          File >> dis_tmp;
          string arr_tmp;
          File >> arr_tmp;

          File >> tmp;

          /** Initialisation des arcs */
          arcs tmparc(atoi(dep_tmp.c_str()),atoi(arr_tmp.c_str()),atoi(dis_tmp.c_str()));
          listeArcs.push_back(tmparc);
        }

    }
    // génération des sommets
    // si ca marche pas
    /** pour chaque arc
        rajouter le premier sommet trouver avec l'arc correspondant

        pour chaque arc regarder les point d'arriver
            si ils existe pas, creer un sommet vide */


    int i=0;
    for (unsigned int j=0; j<listeArcs.size(); j++){
        bool cont=false;

        cout << " ----##------Arc : " << listeArcs[j]._dep << " " << listeArcs[j]._dis << " " << listeArcs[j]._arr << endl;
        cout << " taille sommet " << listeSom.size() << endl;
        if (listeSom.size() != 0){ for (unsigned int k=0; k < listeSom.size(); k++){
                cout << "parcour du sommet :" << k << endl;
                if ( listeArcs[j]._dep == listeSom[k]._id ) cont=true;
                cout << " sommet : " << listeSom[k]._id  << " " << ((cont)? 'V':'F') << endl;

        }}
        if (cont){ // si on a trouver le sommet d'un depart ou d'une arriver
             cout << " sommet trouver : rajout de l'arc" << endl;
             unsigned int k=0;
             for (k=0; k < listeSom.size(); k++){
                if ( listeArcs[j]._dep == listeSom[k]._id ){
                    cout << "k avant break " << k << endl;
                    break;
                }
             }
             cout << "k après break " << k << endl;
             cout << "size avant push " << listeSom[k].listeArcs.size() << endl;
             listeSom[k].listeArcs.push_back(listeArcs[j]);
             cout << "size après push " << listeSom[k].listeArcs.size() << endl;
        }
        if (! cont){ // si on a pas trouver de sommet on le rajoute a la liste
            cout << "aucun sommet trouver pour  :" << listeArcs[j]._dep << endl;
                sommet s1(listeArcs[j]._dep,i,listeArcs[j]);i++;
                cout << " ------- sommet s1 --------" << endl;
                cout << " id: " <<s1._id << endl;
                cout << " place: " <<  s1._place << endl;
                listeSom.push_back(s1);
            }

    }


    for (unsigned int j=0; j<listeArcs.size(); j++){
        bool cont=false;
        for (unsigned int k=0; k < listeSom.size(); k++){
            if ( listeArcs[j]._arr == listeSom[k]._id ) cont=true;
        }
        if (! cont){ // si on a pas trouver le sommet d'arriver, on le rajoute
            sommet s1(listeArcs[j]._arr,i);i++;
            cout << " ------- sommet s1 --------" << endl;
            cout << " id: " <<s1._id << endl;
            cout << " place: " <<  s1._place << endl;

            listeSom.push_back(s1);

        }

    }

    cout << endl;
    /** print sommet */
    for (unsigned int m=0; m < listeSom.size(); m++){
        cout << " ------- sommet --------" << endl;
        cout << " id: " <<listeSom[m]._id << endl;
        cout << " place: " <<  listeSom[m]._place << endl;
        for (unsigned int n=0; n < listeSom[m].listeArcs.size();n++){
            cout << listeSom[m].listeArcs[n]._dep << " " << listeSom[m].listeArcs[n]._dis << " " << listeSom[m].listeArcs[n]._arr << endl;
        }
    }


    /*
        Pour chaque arc
            si le depart ou l'arriver : deja dans la list
                si l'arc est deja dans la list=> nexr
                sinon le rajouter
            sinon creer nouveau sommet id (dep ou arriver) place=boucle, arc=actuel
        */
    cout << "fin Constructeur " << endl;
}

int graph::setPrim(graph& g2){

    bool cont=false,val=false,couvrant=false;
    g2.listeSom = listeSom;
    vector < arcs > arcstest;

    while (! couvrant){

    // choix arrete

        arcstest.clear();
        while (!val){
            // selection arrete

            arcs min=listeArcs[0];
            cont=false;
            for (unsigned int i=0; i < listeArcs.size(); i++){
                for (unsigned int j=0; j< arcstest.size(); j++){
                    if ( ! (listeArcs[i] == arcstest[j])){
                        cont=true; // si on le trouve dans la liste , il a deja été refusé
                    }
                }
                if (( listeArcs[i]._dis < min._dis )&& (! cont)){
                    min=listeArcs[i];
                    count=false;
                }
            }
            g2.listeArcs.push_back(min);
            arcstest.push_back(min); // ajout a la liste des arcs tester
            // test cycle

        }

        // test arbre couvrant

    }





    /*while (!cont){ // je connais pas la conditions d'arret pour que ce soit un arbre couvrant
         // selection des arêtes
        std::vector < arcs > arctmp;
        for (unsigned int i=0; i < listeArcs.size(); i++){
           for (unsigned int j=0; j < g2.listeSom.size(); j++){
               if ( listeArcs[i]._dep == g2.listeSom[j]._id ){
                   for (unsigned int k=0 ; k<g2.listeSom.size();k++){
                       if (listeArcs[i]._arr != listeSom[k]._id){
                           val=true;
                       }
                   }

               }
               if (val){
                   arctmp.push_back(listeArcs[i]);
                   val=false;
               }
           }
        }


    }*/


}

void graph::printgraph(){

    cout << " Fin de calcule du graph | affichage des rangs" << endl;
    cout << "list : " << listeSom.size() << endl;
    // s'affiche dans l'ordre de creation du parseur

    }