#include "filtreavalcplex.h"

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

FiltreAvalCplex::~FiltreAvalCplex()
{
}

FiltreAvalCplex::FiltreAvalCplex()
    : FiltreAval(),
                 m_cplex( "filtreAval", CPlexModel::Minimisation, CPlexModel::Linear,
#ifndef VERBOSE_CPLEX_INTERNAL
                         true,
#else
                         false,
#endif
#ifndef VERBOSE_SOLUTION_STATUS
                         true,
#else
                         false,
#endif
#ifdef WRITE_CPLEX_FILE
                         true,
                         true
#else
                         false,
                         false
#endif
                        )
{
    m_type2_prod_max.resize(I());
}

euros FiltreAvalCplex::calcule_solution(std::vector<size_t> x, 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");
    }

    // création du modèle, partie indépendante des scénarios
    setproblemdata();

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

    // Boucle sur les scénarios et récupération de la solution
    for (scenario_t s = (scenario_t) 0 ; s < S() ; ++s)
    {
        // mise-à-jour du problème, partie dépendante du scénario
        setproblemdata(s) ;
        // résolution par cplex
        m_cplex.resolution();

        vector<double> deCplex;
        // remplissage des productions
        // thermiques
        for (powerplants1_t j=(powerplants1_t)0; j<J(); ++j)
        {
            deCplex = m_cplex.getResult( string("production thermique centrale ")+j );
            for (timestep_t t; t<T(); ++t) {
                reponse[s].prod_thermique[j][t] = (kWh) deCplex[t];//std::max( EMIN(j,t,s), std::min( EMAX(j,t,s), (kWh) deCplex[t]));
                reponse[s].prod_thermique_totale[t] += reponse[s].prod_thermique[j][t];
                reponse[s].costPourScenario += C(j,t,s) * reponse[s].prod_thermique[j][t];
            }
        }
        // nucléaires
        for (powerplants2_t i=(powerplants2_t)0; i<I(); ++i)
        {
            deCplex = m_cplex.getResult( string("production nucléaire centrale ")+i );
            for (timestep_t t; t<T(); ++t) {
                reponse[s].prod_nucleaire[i][t] = std::max( (kWh)0, std::min( m_type2_prod_max[i][t], (kWh) deCplex[t]));
                reponse[s].prod_nucleaire_totale[t] += reponse[s].prod_nucleaire[i][t];
            }
            reponse[s].stock[i] = m_plans[i]->remplis_stock(reponse[s].prod_nucleaire[i], recharges[i]);
        }
        deCplex = m_cplex.getResult( string("coût recharges centrales nucléaires ") );
        for (powerplants2_t i=(powerplants2_t)0; i<I(); ++i)
        {
            reponse[s].costPourScenario += (euros) deCplex[i] ;
        }
        deCplex = m_cplex.getResult( string("restes centrales nucléaires") );
        for (powerplants2_t i=(powerplants2_t)0; i<I(); ++i)
        {
            reponse[s].costPourScenario -= C(i,K_Tp1) * (kWh) deCplex[i];
        }
    }

    // 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;
}








/**
 *                  mise en forme du problème Cplex
 *                  en fixant uniquement ce qui est indépendant des scénarios
 */

void FiltreAvalCplex::setproblemdata()
{
    /** définition des zones */
/*    for (scenario_t s=(scenario_t)0; s<S(); ++s)
    {*/
        m_cplex.addZoneVerticale( string("production=demande"), T());

        for (powerplants1_t j=(powerplants1_t)0; j<J(); ++j)
            m_cplex.addZoneHorizontale( string("production thermique centrale ")+j, T());
        for (powerplants2_t i=(powerplants2_t)0; i<I(); ++i)
            m_cplex.addZoneHorizontale( string("production nucléaire centrale ")+i, T());

        for (powerplants2_t i=(powerplants2_t)0; i<I(); ++i) {
            m_cplex.addZoneVerticale( string("somme productions non BO centrale ")+i+ "= production non BO",
                                       m_plans[i]->arcs_non_BO().size() );
        }
        m_cplex.addZoneHorizontale( string("restes centrales nucléaires"), I() );
//     }
    m_cplex.addZoneHorizontale( string("coût recharges centrales nucléaires "), I() );

    /** fonction objectif et ses contraintes verticales */

    // coût des recharges des centrales nucléaires : indépendant des scénarios
    m_cplex.setZoneHorizontale( string("coût recharges centrales nucléaires ") );
    for (powerplants2_t i=(powerplants2_t)0; i<I(); ++i)
    {
        double min = (m_plans[i]->m_cout + C(i,K_Tp1) * m_plans[i]->m_reste ).v ;
        double max = min ;
        m_cplex.addToObj( i, min, max, CPlexModel::Continuous, 1 );
    }

    // prix de revente des stocks des centrales nucléaires : dépend de la quantité de stock restante
    m_cplex.setZoneHorizontale( string("restes centrales nucléaires") );
    for (powerplants2_t i=(powerplants2_t)0; i<I(); ++i)
    {
        double min = m_plans[i]->m_reste.v;
        double max = min;
        m_cplex.addToObj( i, min, max, CPlexModel::Continuous, - C(i,K_Tp1).v );
    }


    /** autres contraintes verticales : production nucléaire */
    for (powerplants2_t i=(powerplants2_t)0; i<I(); ++i)
    {
        m_cplex.setZoneHorizontale( string("production nucléaire centrale ")+i );
        vector<kWh> min;
        m_plans[i]->remplis_min_max(min, m_type2_prod_max[i]);
        for ( timestep_t t=(timestep_t) 0; t<T(); ++t)
            m_cplex.addToObj( t,
                                min[t].v,
                                m_type2_prod_max[i][t].v,
                                CPlexModel::Continuous,
                                0 );
    }

    /** contraintes horizontales */

    /// I - production = demande
    m_cplex.setZoneVerticale( string("production=demande"));
    // partie gauche : production thermique et nucléaire
    for (powerplants1_t j=(powerplants1_t)0; j<J(); ++j) {
        m_cplex.setZoneHorizontale( string("production thermique centrale ")+j );
        for ( timestep_t t=(timestep_t) 0; t<T(); ++t)
            m_cplex.addToZ(t,t,1);
    }
    for (powerplants2_t i=(powerplants2_t)0; i<I(); ++i) {
        m_cplex.setZoneHorizontale( string("production nucléaire centrale ")+i );
        for ( timestep_t t=(timestep_t) 0; t<T(); ++t)
            m_cplex.addToZ(t,t,1);
    }

    /// II - somme productions non BO = production non BO
    for (powerplants2_t i=(powerplants2_t)0; i<I(); ++i) {
        m_cplex.setZoneVerticale( string("somme productions non BO centrale ")+i+ "= production non BO");
        m_cplex.setZoneHorizontale( string("production nucléaire centrale ")+i );

        vector<const CPlan::CArc * > arcs_non_BO = m_plans[i]->arcs_non_BO();
        for (size_t a=0; a<arcs_non_BO.size(); a++)
        {
            m_cplex.addToRHS( a, CPlexModel::Equals,
                                (arcs_non_BO[a]->m_depart->m_fuel_avant_refuel
                                        + arcs_non_BO[a]->m_recharge
                                        - arcs_non_BO[a]->m_reste).v );
            for (timestep_t t=week2timestep(arcs_non_BO[a]->m_depart->m_date_campaign);
                    t<week2timestep(arcs_non_BO[a]->m_fin->m_date);
                    ++t)
            {
                m_cplex.addToZ( a, t, 1);
            }
        }
    }
}



/**
 * mise-à-jour du modèle sur les parties dépendant du scénario
 */

void FiltreAvalCplex::setproblemdata(scenario_t s)
{
    /** fonction objectif et ses contraintes verticales */
    // les coûts thermiques dépendent de la consommation thermique
    for (powerplants1_t j=(powerplants1_t)0; j<J(); ++j)
    {
        m_cplex.setZoneHorizontale( string("production thermique centrale ")+j );
        for ( timestep_t t=(timestep_t) 0; t<T(); ++t)
            m_cplex.addToObj( t,
                              EMIN(j,t,s).v,
                                   EMAX(j,t,s).v,
                                        CPlexModel::Continuous,
                                        C(j,t,s).v );
    }

    /** contraintes horizontales */
    /// I - production = demande
    m_cplex.setZoneVerticale( string("production=demande") );
    // partie droite : demande
    for ( timestep_t t=(timestep_t) 0; t<T(); ++t) {
        m_cplex.addToRHS(t, CPlexModel::Equals, EDEM(t,s).v);
    }

}