#include <iostream>
#include <vector>
#include <string>

//si vous en avez besoin
#include <set>
#include <map>

#include "noeud.h"

using namespace std;




/***********************************************************
Code pour la partie 2
***********************************************************/ 

//Représente un individu de la population.  
struct Personne {
    int id;
    string province;
    string ville;

    Personne() : Personne(0, "", "") { }

    Personne(int id, string province, string ville) {
        this->id = id;
        this->province = province;
        this->ville = ville;
    }
};

void afficher_populations(vector<Personne>& personnes) {
    //à implémenter

    map<string, map<string, int> > comptes;
    set<int> ids;

    for (Personne& p : personnes) {

        if (ids.find(p.id) != ids.end()) {
            cout << "Erreur: il y a un id avec un duplicat!" << endl;
            return;
        }

        ids.insert(p.id);

        if (comptes.find(p.province) == comptes.end() ||
                comptes[p.province].find(p.ville) == comptes[p.province].end()) {
            comptes[p.province][p.ville] = 1;
        }
        else {
            comptes[p.province][p.ville]++;
        }
    }


    for (auto it_prov : comptes) {
        for (auto it_ville : comptes[it_prov.first]) {
            cout << it_prov.first << ", " << it_ville.first << ":" << it_ville.second << endl;
        }
    }

}










/**
Fait le parcours à partir du noeud n avec l'itérateur.
**/
void iterer(Noeud<int>* n)
{
    for (Noeud<int>::iterator it = n->begin(); it != n->end(); ++it)
    {
        cout<<(*it)<<" ";
    }
    cout<<endl;
}

/**
Fait le parcours à partir du noeud n avec l'itérateur, à l'envers.
**/
void iterer_rev(Noeud<int>* n)
{
    Noeud<int>::iterator itrev = n->end();
  itrev--;
    while (itrev != n->begin())
    {
        cout<<(*itrev)<<" ";
        itrev--;  
    }
    cout<<(*itrev); //pour ne pas manquer le begin()
    cout<<endl;
}




int main()
{
    //ici on construit l'arbre en exemple
    Noeud<int>* racine = new Noeud<int>(13);
    Noeud<int>* n3 = racine->ajouter_enfant(3);
    Noeud<int>* n12 = racine->ajouter_enfant(12);

    n3->ajouter_enfant(1);
    n3->ajouter_enfant(2);

    n12->ajouter_enfant(4);
    n12->ajouter_enfant(5);
    n12->ajouter_enfant(7)->ajouter_enfant(6);  //oui ceci fonctionne
    n12->ajouter_enfant(8);
    Noeud<int>* n11 = n12->ajouter_enfant(11);
    n11->ajouter_enfant(9);
    n11->ajouter_enfant(10);


    cout<<"Sortie avec afficher_postordre():"<<endl;
    racine->afficher_postordre();
    cout<<endl;

    cout<<"Test 1: iteration simple."<<endl;
    iterer(racine);



    cout<<"Test 2: iteration inverse."<<endl;
    iterer_rev(racine);


    cout<<"Test 3: iteration d'un sous-arbre."<<endl;
    iterer(n12);

    cout<<"Test 4: iteration inverse d'un sous-arbre."<<endl;
    iterer_rev(n12);


    cout<<"Test 5: un peu de va-et-vient."<<endl;
    {   //les accolades pour limiter la portee de it
        Noeud<int>::iterator it = racine->begin();
        it = ++(++it);  //3
        cout<<(*it)<<" ";
        it--;
        cout<<(*it)<<" ";   //2
        ++ ++ ++it;    //5
        cout<<(*it)<<" ";
        -- --it;       //3
        cout<<(*it)<<" ";
        ++ ++ ++ ++it;
    ++ -- ++ -- --it; //6
        cout<<(*it)<<" ";
        it++; it++; it++; it++; it++; it++; it++; it--; it--; it++; it++; it++;
        cout<<(it == racine->end() ? "fin" : "non-fin")<<" ";

        cout<<endl;
    }



    //pour tester la suppression pendant une itération
    cout<<"Test 6: test avec suppression."<<endl;
    Noeud<int>* rcopie = new Noeud<int>(*racine);
    auto it = rcopie->begin();
    while (it != rcopie->end()) {
        cout << *it << " ";

        if (*it == 4) {
            rcopie->get_enfant(1)->supprimer_enfant(1);
            rcopie->get_enfant(1)->supprimer_enfant(1);
        }
        it++;
    }
    delete rcopie;


    delete racine;





    /**********************************
    Tests partie 2
    ***********************************/
    vector<Personne> v;

    v.push_back(Personne(1, "Quebec", "Sherbrooke"));
    v.push_back(Personne(2, "Ontario", "Windsor"));
    v.push_back(Personne(3, "Quebec", "Sherbrooke"));
    v.push_back(Personne(4, "Quebec", "Windsor"));
    v.push_back(Personne(5, "Alberta", "Calgary"));
    v.push_back(Personne(6, "Ontario", "Windsor"));
    v.push_back(Personne(7, "Quebec", "Sherbrooke"));

    cout << endl << endl << "Tests partie 2" << endl;

    afficher_populations(v);

    cout << endl << "Tests duplicat" << endl;
    v.push_back(Personne(3, "Saskatchewan", "Saskatoon"));

    afficher_populations(v);


    return 0;

}