#include "filtreAval.h"
#include "../cteamid.h"

#include <sstream>
#include <iostream>
#include <algorithm>

using namespace std;

FiltreAval::FiltreAval(vector<double> &x , DualAscent& da )
{
    int nbrCol = da.A.size();
    static timestep_t week_length = (timestep_t)( T()/H() );
    map<powerplants2_t, vector<double>*> colonnesSelectionnees;

    double coutColonneNuc = 0;
    valeurObjectif=0;
    //Récupération des colonnes sélectionnées
    for( int i =0 ; i<nbrCol && colonnesSelectionnees.size()<I() ; i++)
    {
        if (x[i]>1-EPSILON_FILTRE )
        {
            powerplants2_t numPowerplant = col2powerplant2(*(da.A[i]));
            pair<powerplants2_t,vector<double>* > p(numPowerplant, da.A[i]);
            colonnesSelectionnees.insert(p);
            coutColonneNuc += da.cost[i];
            annuaireColonnesSelectionnees.insert(pair<powerplants2_t, int>( numPowerplant, i));
        }
    }


    //Boucle sur les scénarios
    for (scenario_t s = (scenario_t) 0 ; s < S() ; s=(scenario_t) (s+1))
    {
        //Traitement semaine par semaine
        detailProdParScenario menu;
        menu.costPourScenario = coutColonneNuc;
        for (week_t w = (week_t) 0; w < H() ; w = (week_t) (w+1) )
        {
            vector<double> demDeLaSemaine ;
            double somDemSemaine = 0;
            //Boucle préliminaire sur chaque timestep de la semaine afin de déterminer la proportion de la demande
            for (timestep_t t = (timestep_t) (w * week_length);
                     t<(timestep_t)(w*week_length+week_length);
                     t=(timestep_t) (t+1))
            {
                double demande = CInstance::DEM(t,s) ;
                demDeLaSemaine.push_back( demande );
                somDemSemaine += demande ;
            }

            //Boucle principale sur chaque timestep de la semaine afin de déterminer les productions
            vector<double> prodNucDuTimestep ;
            for (timestep_t t = (timestep_t) (w * week_length);
                     t<(timestep_t)(w*week_length+week_length);
                     t=(timestep_t) (t+1))
            {
                //Boucle sur les centrales nucléaire afin de déterminer leurs productions
                double prodNuclSommeePourLeTimestep = 0;
                for (powerplants2_t i = (powerplants2_t) 1;i<=I();i=(powerplants2_t) (i+1) )
                {
                    double prodNucDuTimestepDuneCentrale = (*(colonnesSelectionnees[i]))[w] * demDeLaSemaine[t-w*week_length]/somDemSemaine ;
                    prodNucDuTimestep.push_back(prodNucDuTimestepDuneCentrale);
                    prodNuclSommeePourLeTimestep += prodNucDuTimestepDuneCentrale;
                }
                menu.prodNucParTimestep.push_back(prodNucDuTimestep);
                menu.prodNuclSommeeParTimestep.push_back(prodNuclSommeePourLeTimestep);

                //Détermination de la production thermique sommée
                menu.prodThermSommeeParTimestep.push_back(CInstance::DEM(t, s) - prodNuclSommeePourLeTimestep);

                //Détermination de la production thermique de chaque centrale
                //Boucle préliminaire sur les centrales thermiques pour récupérer PMIN et trier en fonction du coût

                double resteAProduire = menu.prodThermSommeeParTimestep.back();
                multimap<double, powerplants1_t> coutProd; // ex : coutProd[100] => liste des centrales qui ont un cout de production unitaire de 100
                vector<double> prodThermDuTimestep ;

                for ( powerplants1_t j=(powerplants1_t) 0 ; j < J() ; j = (powerplants1_t) (j+1) )
                {
                    coutProd.insert(pair<double, powerplants1_t>(CInstance::type1(j).C(t, s), j));
                    prodThermDuTimestep.push_back(CInstance::type1(j).EMIN(t, s));
                    resteAProduire -= CInstance::type1(j).EMIN(t, s);
                    menu.costPourScenario += CInstance::type1(j).EMIN(t, s) * CInstance::type1(j).C(t, s);
                }

                //Boucle principale sur les centrales thermiques déterminer le production de chacune

                for ( multimap<double, powerplants1_t>::iterator it=coutProd.begin() ;
                    it != coutProd.end() && resteAProduire > 0;
                    it++ )
                {
                    double prodCentraleSupplementaire = min(resteAProduire, CInstance::type1(it->second).EMAX(t, s)-CInstance::type1(it->second).EMIN(t, s));
                    resteAProduire -= prodCentraleSupplementaire;
                    prodThermDuTimestep[it->second] += prodCentraleSupplementaire;
                    menu.costPourScenario += prodCentraleSupplementaire * CInstance::type1(it->second).C(t, s);
                }
                if ( resteAProduire > 0 )
                {
                    cerr<<"Impossible de satisfaire toute la demande"<<endl;
                }
                menu.prodThermParTimestep.push_back(prodThermDuTimestep);
            }
        }
        reponse.push_back(menu);
        valeurObjectif+=menu.costPourScenario;
    }
    valeurObjectif /= S();
}

void FiltreAval::printOutput(std::ofstream& ofs, time_t heureDebut, DualAscent& da)
{
    /**
     * Section main
     */
    ofs<<"begin main"<<endl;
    ofs<<"team_identifier "<<DEFAULT_TEAM_ID<<endl;

    time_t rawtime;
    tm * ptm;
    time ( &rawtime );
    ptm = gmtime ( &rawtime );
    ofs<<"solution_time_date "<<printIntSurDeuxChiffres(ptm->tm_mday)<<"/"<<printIntSurDeuxChiffres(1+ptm->tm_mon);
    ofs<<"/"<<printIntSurDeuxChiffres(1900+ptm->tm_year)<<" "<<printIntSurDeuxChiffres(ptm->tm_hour)<<":";
    ofs<<printIntSurDeuxChiffres(ptm->tm_min)<<":"<<printIntSurDeuxChiffres(ptm->tm_sec)<<endl;

    time_t tempsEcoule = time (NULL) - heureDebut;//hh:mm:ss
    int heures = tempsEcoule / 3600;
    tempsEcoule -= heures * 3600;
    int minutes = tempsEcoule / 60;
    tempsEcoule -= minutes * 60;
    ofs<<"solution_running_time "<<printIntSurDeuxChiffres(heures)<<":"<<printIntSurDeuxChiffres(minutes)<<":"<<printIntSurDeuxChiffres(tempsEcoule)<<endl;

    ofs<<"data_set "<<CInstance::params().getInstanceName()<<endl;
    ofs<<"cost "<<valeurObjectif<<endl;
    ofs<<"end main"<<endl;

    /**
     * Section outage
     */
    ofs<<"begin outage"<<endl;
    for ( map<powerplants2_t, int>::iterator it = annuaireColonnesSelectionnees.begin() ;
            it != annuaireColonnesSelectionnees.end() ;
            it++ )
    {
        ofs<<"name "<<CInstance::type2((powerplants2_t) (it->first-1) ).m_name<<endl;
        ofs<<"index "<<CInstance::type2((powerplants2_t) (it->first-1) ).i<<endl;
        ofs<<"outage_dates"; //TODO completer les dates d'outages non effectues avec -1
        for ( int k=0 ; k < Clique::dateDebutOutageCampagneK[annuaireColonnesSelectionnees[it->first]].size();k++)
        {
            ofs<<" "<<Clique::dateDebutOutageCampagneK[annuaireColonnesSelectionnees[it->first]][k] ;
        }
        ofs<<endl<<"reloaded_fuel";
        for ( int k=0 ; k < Clique::dateDebutOutageCampagneK[annuaireColonnesSelectionnees[it->first]].size();k++)
        {
            ofs<<" "<<da.recharge[annuaireColonnesSelectionnees[it->first]][k] ;
        }
        ofs<<endl;
    }
    ofs<<"end outages"<<endl;
    /**
    * Section power_output
    */
    ofs<<"begin power_output"<<endl;

    for (scenario_t s = (scenario_t) 0; s < S(); s = (scenario_t) (s+1) )
    {
        ofs<<"scenario "<<s<<endl;
        ofs<<"begin type1_plants"<<endl;
        for (powerplants1_t j = (powerplants1_t) 0;j<J();j = (powerplants1_t) (j+1))
        {
            ofs<<"name "<<CInstance::type1(j).m_name<<" "<<CInstance::type1(j).j;
            for (timestep_t t = (timestep_t) 0;t < T() ; t= (timestep_t) (t+1))
            {
                ofs<<" "<<reponse[s].prodThermParTimestep[t][j];
            }
            ofs<<endl;
        }
        ofs<<"end type1_plants"<<endl,

        ofs<<"begin type2_plants"<<endl;
        for (powerplants2_t i = (powerplants2_t) 0;i<I();i = (powerplants2_t) (i+1))
        {
            string fuel_variation;
            ofs<<"name "<<CInstance::type2(i).m_name<<" "<<CInstance::type2(i).i;
            for (timestep_t t = (timestep_t) 0;t < T() ; t= (timestep_t) (t+1))
            {
                ofs<<" "<<reponse[s].prodNucParTimestep[t][i];
                ostringstream oss;
                oss << reponse[s].prodNucParTimestep[t][i] * CInstance::D(t);
                fuel_variation += " " + oss.str();
            }
            ofs<<endl;
            ofs<<"fuel_variation"<<fuel_variation<<endl;
            ofs<<"remaining_fuel_at_the_end "<< max(0., da.reste[annuaireColonnesSelectionnees[i]]) <<endl; //éviter d'avoir une qté de fuel restant=-1e-7
        }
        ofs<<"end type2_plants"<<endl;
    }
    ofs<<"end power_output";
}


string FiltreAval::printIntSurDeuxChiffres(int chiffre)
{
    std::ostringstream oss;
    oss << chiffre;
    string chiffreString = oss.str();

    string result;
    result += (chiffre < 10) ? "0" : "";
    result += chiffreString;
    return result;
}

powerplants2_t col2powerplant2(const vector<double>& colonne)
{
    for ( int i=H() ; i < colonne.size() ; i++ )
    {
        if ( colonne[i] == 1 )
        {
            return (powerplants2_t) (i-H()+1);
        }
    }

    //Si on arrive ici, c'est qu'il n'y a pas de 1 sur la colonne
    cerr<<"Colonne non attribuée"<<endl;
    return (powerplants2_t) -1;
}