#include "filtreAval.h"

#include <iomanip>
#include <sstream>
#include <iostream>
#include <algorithm>
#include <cstdlib>

#include <cteamid.h>
#include <cinstance.h>
#include <cplan.h>

using namespace std;

FiltreAval::FiltreAval()
{
    valeurObjectif=(euros)0;
    m_plans.resize(I(), NULL);
    reponse.resize(S());
    recharges.resize(I(), vector<kWh>(K()));

    for (scenario_t s = (scenario_t) 0 ; s < S() ; ++s)
    {
        reponse[s].costPourScenario = (euros)0 ;
        reponse[s].prod_nucleaire.resize(I(), vector<kWh>(T(),           (kWh)0)); // I vecteurs de production nucléaire
        reponse[s].stock         .resize(I(), vector<kWh>(T()+(tlen_t)1, (kWh)0)); // I vecteurs de stock nucléaire
        reponse[s].prod_thermique.resize(J(), vector<kWh>(T(),           (kWh)0)); // J vecteurs de production thermique
        reponse[s].prod_nucleaire_totale.resize(T(), (kWh)0);
        reponse[s].prod_thermique_totale.resize(T(), (kWh)0);
    }
}


euros FiltreAval::calcule_solution(vector<size_t> x, double, bool)
{

    //Récupération des colonnes sélectionnées
    for( size_t i =0 ; i<x.size() ; i++) {
        m_plans[CPlan::getPlan(x[i])->m_i] = CPlan::getPlan(x[i]);
    }

    // vérification : on doit avoir un plan par centrale nucléaire
    for (size_t i=0; i<m_plans.size(); i++) {
        if (m_plans[i]==NULL)
            throw string("Erreur : une centrale n'a pas de plan de production");
    }

    // recharges
    for (powerplants2_t i; i<I(); ++i)
        m_plans[i]->remplis_recharges( recharges[i] ) ;

    //Boucle sur les scénarios
    for (scenario_t s = (scenario_t) 0 ; s < S() ; ++s)
    {
        vector<kWh> demande_restante(T());

        // recopie de la demande dans demande_restante
        for (timestep_t t=(timestep_t)0; t<T(); ++t) demande_restante[t] = EDEM(t,s);

        // remplissage des productions forcées BO sur les centrales nucléaires
        for (size_t i=0; i<m_plans.size(); i++)
            m_plans[i]->remplis_BO_en_visant_bien( reponse[s].prod_nucleaire[i], reponse[s].stock[i], demande_restante );

        // remplissage des productions non forcées
        for (size_t i=0; i<m_plans.size(); i++)
            m_plans[i]->remplis_campagnes_non_BO( reponse[s].prod_nucleaire[i], reponse[s].stock[i], demande_restante );

        // calcul de la production nucléaire totale
        for (size_t i=0; i<m_plans.size(); i++)
            for (size_t t=0; t<(unsigned)T(); t++)
                reponse[s].prod_nucleaire_totale[t] += reponse[s].prod_nucleaire[i][t] ;

        // calcul du coût de la production nucléaire
        for (size_t i=0; i<m_plans.size(); i++)
            reponse[s].costPourScenario += m_plans[i]->m_cout ;

        // fuel restant dans les centrales nucléaires
        for (size_t i=0; i<m_plans.size(); i++)
            reponse[s].stock[i][T()] = m_plans[i]->m_reste ;

        // calcul de la production thermique totale
        for (timestep_t t=(timestep_t)0; t<T(); ++t)
            reponse[s].prod_thermique_totale[t] = EDEM(t, s) - reponse[s].prod_nucleaire_totale[t] ;

        // calcul de la production thermique de chaque centrale
        for (timestep_t t=(timestep_t)0; t<T(); ++t)
        {
            kWh resteAProduire = reponse[s].prod_thermique_totale[t];

            // Boucle préliminaire sur les centrales thermiques pour récupérer leur PMIN et les trier en fonction de leur coût
            typedef pair<euros_par_kWh, powerplants1_t> tri_el ;
            typedef multimap<euros_par_kWh, powerplants1_t> tri_powerplant ;
            typedef tri_powerplant::iterator tri_it ;
            tri_powerplant coutProd;

            for ( powerplants1_t j=(powerplants1_t) 0 ; j < J() ; ++j )
            {
                coutProd.insert(tri_el( type1(j).C(t, s), j ));
                reponse[s].prod_thermique[j][t] = EMIN(j, t, s);
                resteAProduire -= EMIN(j, t, s) ;
            }

            // Parcours des centrales thermiques par coût croissant pour déterminer la production de chacune
            for ( tri_it it=coutProd.begin(); it != coutProd.end() && resteAProduire > (kWh)0; it++ )
            {
                powerplants1_t & j = it->second ;
                kWh prodCentraleSupplementaire = min(resteAProduire, EMAX(j, t, s) - EMIN(j, t, s));
                resteAProduire -= prodCentraleSupplementaire;
                reponse[s].prod_thermique[j][t] += prodCentraleSupplementaire;
            }
            if ( resteAProduire > (kWh) 0 )
            {
                throw string("Impossible de satisfaire toute la demande");
            }
        }

        // calcul du coût de la production thermique
        for (timestep_t t=(timestep_t)0; t<T(); ++t)
            for (powerplants1_t j=(powerplants1_t)0; j<J(); ++j)
                reponse[s].costPourScenario += C( j, t, s ) * reponse[s].prod_thermique[j][t]  ;


        // vérification
/*        for (timestep_t t=(timestep_t)0; t<T(); ++t) {
            double prod_nucl = 0 ;
            for (powerplants2_t _i=(powerplants2_t)0; _i<I(); ++_i) prod_nucl  += reponse[s].prod_nucleaire[_i][t] ;
            double prod_therm = 0 ;
            for (powerplants1_t _j=(powerplants1_t)0; _j<J(); ++_j) prod_therm += reponse[s].prod_thermique[_j][t] ;
            cout << "scénario " << setprecision(9) << s
                 << " prod. nucléaire : " << prod_nucl / D()<< " sommée : " << reponse[s].prod_nucleaire_totale[t]/D()
                 << " prod. thermique : " << prod_therm/D() << " somme : " << prod_nucl/D()+prod_therm/D() << " demande : " << EDEM(t,s)/D()
                 << std::endl ;
        }
    	std::cout << endl ;*/
    }

    // calcul du coût moyen de la solution
    valeurObjectif = (euros)0 ;
    for (scenario_t s = (scenario_t) 0 ; s < S() ; ++s)
        valeurObjectif += reponse[s].costPourScenario ;
    valeurObjectif /= S();

    return valeurObjectif;
}



void FiltreAval::exportePlans()
{
    for ( powerplants2_t i; i<I(); ++i)
    {
        std::ostringstream oss;
        oss << "plans_centrale_" << i ;
        ofstream ofs( oss.str().c_str() );
        for (scenario_t s; s<S(); ++s)
        {
            for (timestep_t t; t<T(); ++t)
            {
                if (t>(timestep_t)0) ofs << "\t";
                ofs << reponse[s].prod_nucleaire[i][t] ;
            }
            ofs << endl;
        }
        ofs.close();
    }
}


void FiltreAval::printOutput(std::ofstream& ofs, time_t heureDebut)
{
    /**
     * Section main
     */
    ofs <<  fixed   << setprecision(10) ;
    ofs <<  "begin main"    <<  endl;
    ofs <<  "team_identifier "  <<  CTeamId::getTeamId() <<  endl;

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

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

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

    /**
     * Section outage
     */
    ofs <<  "begin outages" <<  endl;
    for ( powerplants2_t i=(powerplants2_t)0; i<I(); ++i)
    {
#ifdef VERBOSE_NUMEROS_PLANS
        cout << "PLAN de la centrale " << (int) i << " ID " << m_plans[i]->m_id << endl ;
#endif
        ofs <<  "name "         <<  type2(i).m_name <<  endl;
        ofs <<  "index "        <<  (int) i         <<  endl;
        ofs <<  "outage_dates";
        vector<week_t> dates_outages( K(), (week_t) -1 );
        m_plans[i]->remplis_dates_outages( dates_outages ) ;
        for ( campaign_t k=(campaign_t) 0 ; k < K() ; k = ++k )
            ofs <<  " " <<  dates_outages[k] ;
        ofs <<  endl ;
        ofs <<  "reloaded_fuel" ;

        for ( campaign_t k=(campaign_t) 0 ; k < K() ; k = ++k )
            ofs <<  " " <<  recharges[i][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 )
    {
        ofs <<  "scenario " <<  s   <<  endl;

        /**
         * types 1
         */
        ofs <<  "begin type1_plants"    <<  endl;
        for (powerplants1_t j = (powerplants1_t) 0; j<J();  ++j)
        {
            ofs <<  "name " <<  type1(j).m_name <<  " " <<  (int) j;
            for (timestep_t t = (timestep_t) 0; t < T() ; ++t)
            {
                ofs <<  " " <<  reponse[s].prod_thermique[j][t] / D(t);
            }
            ofs <<  endl;
        }
        ofs <<  "end type1_plants"  <<  endl,


        /**
         * types 2
         */
        ofs <<  "begin type2_plants"    <<  endl;
        for (powerplants2_t i = (powerplants2_t)0; i<I(); ++i)
        {
            ofs <<  "name " <<  type2(i).m_name <<  " " <<  (int) i;
            for (timestep_t t = (timestep_t) 0; t<T() ; ++t)
            {
                ofs <<  " " <<  reponse[s].prod_nucleaire[i][t] / D();
            }
            ofs <<  endl;

            ofs <<  "fuel_variation";
            for (timestep_t t = (timestep_t) 0; t<T() ; ++t)
            {
                ofs <<  " " <<  reponse[s].stock[i][t] ;
            }
            ofs <<  endl;
            ofs <<  "remaining_fuel_at_the_end "    <<  reponse[s].stock[i][T()] <<  endl;
        }
        ofs <<  "end type2_plants"  <<  endl;
    }
    ofs <<  "end power_output" << endl;
}


string printIntSurDeuxChiffres(int chiffre)
{
    if (chiffre<0 or chiffre>99)
        throw string("chiffre invalide");
    char s[3];
    sprintf(s,"%02d",chiffre);
    return s;
}
string printIntSurQuatreChiffres(int chiffre)
{
    if (chiffre<0 or chiffre>9999)
        throw string("chiffre invalide");
    char s[5];
    sprintf(s,"%04d",chiffre);
    return s;
}

powerplants2_t col2powerplant2(const vector<double>& colonne)
{
    for ( size_t c=(size_t) H() ; c < colonne.size() ; c++ )
    {
        if ( colonne[c] == 1 )
        {
            return (powerplants2_t) (c-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;
}