#include "filtreavalcplexultime_1passe.h"


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

FiltreAvalCplexUltime1Passe::FiltreAvalCplexUltime1Passe()
    : 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_min.resize(I());
    m_type2_prod_max.resize(I());
}

euros FiltreAvalCplexUltime1Passe::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 et appel à cplex
    setproblemdata();
    m_cplex.resolution();

    vector<double> deCplex;

    // récupération des recharges
    for (powerplants2_t i=(powerplants2_t)0; i<I(); ++i)
    {
        deCplex = m_cplex.getResult( string("recharges ")+i );
        for (campaign_t k; k<K(); ++k) {
            recharges[i][k] = (kWh) deCplex[k] ;
        }
    }

    // Boucle sur les scénarios et récupération de la solution
    for (scenario_t s = (scenario_t) 0 ; s < S() ; ++s)
    {
        reponse[s].costPourScenario = (euros) 0;

        // coût des recharges
        for (powerplants2_t i=(powerplants2_t)0; i<I(); ++i)
            for (campaign_t k; k<K(); ++k)
                reponse[s].costPourScenario += C(i,k) * recharges[i][k] ;

        // remplissage des productions
        // thermiques
        for (powerplants1_t j=(powerplants1_t)0; j<J(); ++j)
        {
            deCplex = m_cplex.getResult( string("production thermique centrale ")+j+" scenario "+s );
            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+" scenario "+s );
            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]);
        }
        for (powerplants2_t i=(powerplants2_t)0; i<I(); ++i)
        {
            deCplex = m_cplex.getResult( string("fuel fin  , centrale ")+i+" scenario "+s );
            reponse[s].costPourScenario -= C(i,K_Tp1) * (kWh) deCplex[m_plans[i]->m_arcs.size()-1];
        }
    }

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


FiltreAvalCplexUltime1Passe::~FiltreAvalCplexUltime1Passe()
{
}


void FiltreAvalCplexUltime1Passe::setproblemdata()
{
    // calcul préalable des bornes de production par pas de temps, pour chaque centrale
    for (powerplants2_t i=(powerplants2_t)0; i<I(); ++i)
        m_plans[i]->remplis_min_max(m_type2_prod_min[i],m_type2_prod_max[i]);

    /** définition des zones horizontales */

    // zones horizontales = variables

    // 1 - production par pas de temps pour chaque scénario


    for (scenario_t s=(scenario_t)0; s<S(); ++s)
    {
        for (powerplants1_t j=(powerplants1_t)0; j<J(); ++j) {
            m_cplex.addZoneHorizontale( string("production thermique centrale ")+j+" scenario "+s, T());
            m_cplex.setZoneHorizontale( string("production thermique centrale ")+j+" scenario "+s );
            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 / S() );
        }
        for (powerplants2_t i=(powerplants2_t)0; i<I(); ++i) {
            m_cplex.addZoneHorizontale( string("production nucléaire centrale ")+i+" scenario "+s, T());
            m_cplex.setZoneHorizontale( string("production nucléaire centrale ")+i+" scenario "+s);
            for ( timestep_t t=(timestep_t) 0; t<T(); ++t)
                m_cplex.addToObj( t,
                                  m_type2_prod_min[i][t].v,
                                        m_type2_prod_max[i][t].v,
                                            CPlexModel::Continuous,
                                            0 );
        }
    }
    // 2 - recharges de chaque campagne
    for (powerplants2_t i=(powerplants2_t)0; i<I(); ++i)
    {
        m_cplex.addZoneHorizontale( string("recharges ")+i, K());
        m_cplex.setZoneHorizontale( string("recharges ")+i );
        // 0 par défaut
        for (campaign_t k; k<K(); ++k)
        {
            m_cplex.addToObj( i, 0, 0, CPlexModel::Continuous, 0 );
        }
        // entre RMIN et RMAX si la recharge est programmée
        for (size_t a=0; a<m_plans[i]->m_arcs.size(); a++)
        {
            const CPlan::CArc & arc = m_plans[i]->m_arcs[a];
            campaign_t k = arc.m_depart->m_campaign ;
            if (arc.m_depart->m_type == TYPE_OUTAGE) {
                m_cplex.addToObj(   k, RMIN(i,k).v, RMAX(i,k).v, CPlexModel::Continuous, C(i,k).v );
            }
        }
    }
    // 3 - fuel au début et à la fin de chaque arc, et après recharge
    for (scenario_t s=(scenario_t)0; s<S(); ++s)
    {
        for (powerplants2_t i=(powerplants2_t)0; i<I(); ++i)
        {
            m_cplex.addZoneHorizontale( string("fuel début, centrale ")+i+" scenario "+s, m_plans[i]->m_arcs.size());
            m_cplex.setZoneHorizontale( string("fuel début, centrale ")+i+" scenario "+s);
            for (size_t a=0;a<m_plans[i]->m_arcs.size();a++) m_cplex.addToObj(a,0,INFINI,CPlexModel::Continuous,0);

            m_cplex.addZoneHorizontale( string("fuel après, centrale ")+i+" scenario "+s, m_plans[i]->m_arcs.size());
            m_cplex.setZoneHorizontale( string("fuel après, centrale ")+i+" scenario "+s);
            for (size_t a=0;a<m_plans[i]->m_arcs.size();a++) m_cplex.addToObj(a,0,INFINI,CPlexModel::Continuous,0);

            m_cplex.addZoneHorizontale( string("fuel fin  , centrale ")+i+" scenario "+s, m_plans[i]->m_arcs.size());
            m_cplex.setZoneHorizontale( string("fuel fin  , centrale ")+i+" scenario "+s);
            for (size_t a=0;a<m_plans[i]->m_arcs.size()-1;a++) m_cplex.addToObj(a,0,INFINI,CPlexModel::Continuous,0);
            m_cplex.addToObj(   m_plans[i]->m_arcs.size()-1, 0, INFINI, CPlexModel::Continuous, - C(i,K_Tp1).v / S() );
        }
    }




    /** contraintes */

    /// A - production = demande
    for (scenario_t s=(scenario_t)0; s<S(); ++s)
    {
        m_cplex.addZoneVerticale( string("production=demande scenario ")+s, T() ) ;
        m_cplex.setZoneVerticale( string("production=demande scenario ")+s);
        // partie droite : demande
        for ( timestep_t t=(timestep_t) 0; t<T(); ++t) {
            m_cplex.addToRHS(t, CPlexModel::Equals, EDEM(t,s).v);
        }
        // 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+" scenario "+s);
            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+" scenario "+s);
            for ( timestep_t t=(timestep_t) 0; t<T(); ++t)
                m_cplex.addToZ(t,t,1);
        }
    }

    /// B - productions et stocks pour chaque arc

    // fuel avant recharge (a+1) = fuel après recharge(a) + somme productions(a)
    for (scenario_t s=(scenario_t)0; s<S(); ++s)
    {
        for (powerplants2_t i=(powerplants2_t)0; i<I(); ++i)
        {
            // fuel début des arcs - fuel fin des arcs précédents = 0
            size_t nb_arcs = m_plans[i]->m_arcs.size() ;
            m_cplex.addZoneVerticale( string("fd=ff ")+s+" "+i, nb_arcs-1 );
            m_cplex.setZoneVerticale( string("fd=ff ")+s+" "+i);
            m_cplex.setZoneHorizontale( string("fuel début, centrale ")+i+" scenario "+s);
            for (size_t a=1; a<nb_arcs; a++)    m_cplex.addToZ(a-1, a, 1);
            m_cplex.setZoneHorizontale( string("fuel fin  , centrale ")+i+" scenario "+s);
            for (size_t a=0; a<nb_arcs-1; a++)  m_cplex.addToZ(a,   a,-1);
            for (size_t a=0; a<nb_arcs-1; a++)  m_cplex.addToRHS(a, CPlexModel::Equals, 0);

            // fuel après refuel - B*fuel avant refuel  - recharge = C
            m_cplex.addZoneVerticale( string("far_is_f(f)")+s+" "+i+" ", nb_arcs );
            m_cplex.setZoneVerticale( string("far_is_f(f)")+s+" "+i+" ");
            for (size_t a=0; a<nb_arcs; a++)
            {
                const CPlan::CArc & arc = m_plans[i]->m_arcs[a];
                campaign_t k = arc.m_depart->m_campaign;
                switch ( arc.m_depart->m_type ) {

                    case TYPE_OUTAGE :
                        m_cplex.setZoneHorizontale( string("fuel début, centrale ")+i+" scenario "+s);
                        m_cplex.addToZ(a, a, ((coeff_t)1-(coeff_t)1/Q(i,k)).v);
                        m_cplex.setZoneHorizontale( string("recharges ")+i);
                        m_cplex.addToZ(a, k, 1);
                        m_cplex.setZoneHorizontale( string("fuel après, centrale ")+i+" scenario "+s);
                        m_cplex.addToZ(a, a, -1);
                        m_cplex.addToRHS(a, CPlexModel::Equals, (BO(i,(campaign_t)(k-1)) * ((Q(i,k)-(coeff_t)1)/Q(i,k)) - BO(i,k)).v);
                        break;

                    default :
                        m_cplex.setZoneHorizontale( string("fuel début, centrale ")+i+" scenario "+s);
                        m_cplex.addToZ(a, a, 1);
                        m_cplex.setZoneHorizontale( string("fuel après, centrale ")+i+" scenario "+s);
                        m_cplex.addToZ(a, a,-1);
                        m_cplex.addToRHS(a, CPlexModel::Equals, 0);
                        break;
                }
            }

            for (size_t a=0; a<nb_arcs; a++)
            {
                const CPlan::CArc & arc = m_plans[i]->m_arcs[a];
                campaign_t k = arc.m_depart->m_campaign;
                if ( arc.m_depart->m_type == TYPE_OUTAGE ) {
                    // fuel après refuel < SMAX
                    m_cplex.addZoneVerticale( string("far<smax")+s+" "+i+" "+a, 1 );
                    m_cplex.setZoneVerticale( string("far<smax")+s+" "+i+" "+a);

                    m_cplex.setZoneHorizontale( string("fuel après, centrale ")+i+" scenario "+s);
                    m_cplex.addToZ(0, a, 1);
                    m_cplex.addToRHS(0, CPlexModel::LowerThan, SMAX(i,k).v);

                    // fuel avant refuel < AMAX
                    m_cplex.addZoneVerticale( string("far<amax")+s+" "+i+" "+a, 1 );
                    m_cplex.setZoneVerticale( string("far<amax")+s+" "+i+" "+a);

                    m_cplex.setZoneHorizontale( string("fuel début, centrale ")+i+" scenario "+s);
                    m_cplex.addToZ(0, a, 1);
                    m_cplex.addToRHS(0, CPlexModel::LowerThan, AMAX(i,k).v);
                }
                if ( arc.m_depart->m_type != TYPE_BO and arc.m_fin->m_date!=0 ) {
                    // fuel fin > BO
                    m_cplex.addZoneVerticale( string("ff>BO")+s+" "+i+" "+a, 1 );
                    m_cplex.setZoneVerticale( string("ff>BO")+s+" "+i+" "+a);

                    m_cplex.setZoneHorizontale( string("fuel fin  , centrale ")+i+" scenario "+s);
                    m_cplex.addToZ(0, a, 1);
                    m_cplex.addToRHS(0, CPlexModel::GreaterThan, sup(BO(i,k)).v);
                }
                if ( arc.m_depart->m_type == TYPE_BO or arc.m_depart->m_date == (week_t)0 ) {
                    // fuel debut fixé
                    m_cplex.addZoneVerticale( string("fuel début fixe, scenario ")+s+" centrale "+i+" arc "+a, 1 );
                    m_cplex.setZoneVerticale( string("fuel début fixe, scenario ")+s+" centrale "+i+" arc "+a);

                    m_cplex.setZoneHorizontale( string("fuel début, centrale ")+i+" scenario "+s);
                    m_cplex.addToZ(0, a, 1);
                    m_cplex.addToRHS(0, CPlexModel::Equals, arc.m_depart->m_fuel.v);
                }
            }
            // fuel après - fuel fin - production = 0
            m_cplex.addZoneVerticale( string("fa_-_ff_-_p_=_0_")+s+"_"+i, nb_arcs );
            for (size_t a=0; a<nb_arcs; a++)
            {
                const CPlan::CArc & arc = m_plans[i]->m_arcs[a];
                campaign_t k = arc.m_depart->m_campaign;

                // fuel après - fuel fin - production = 0
                m_cplex.setZoneVerticale( string("fa_-_ff_-_p_=_0_")+s+"_"+i );
                m_cplex.setZoneHorizontale( string("fuel après, centrale ")+i+" scenario "+s);
                m_cplex.addToZ(a, a, 1);
                m_cplex.setZoneHorizontale( string("fuel fin  , centrale ")+i+" scenario "+s);
                m_cplex.addToZ(a, a,-1);
                m_cplex.setZoneHorizontale( string("production nucléaire centrale ")+i+" scenario "+s);
                kWh prod_max = (kWh) 0;
                for ( timestep_t t=week2timestep(arc.m_depart->m_date_campaign); t<week2timestep(arc.m_fin->m_date); ++t) {
                    m_cplex.addToZ(a,t,-1);
                    prod_max += EMAX(i,t);
                }
                m_cplex.addToRHS(a, CPlexModel::Equals, 0);

                // modulation
                if (arc.m_depart->m_type != TYPE_BO) {
                    m_cplex.addZoneVerticale( string("fa_m_ff_greater_pmax_m_mmax")+s+" "+i+" "+a, 1 );
                    m_cplex.setZoneVerticale( string("fa_m_ff_greater_pmax_m_mmax")+s+" "+i+" "+a );
                    m_cplex.setZoneHorizontale( string("fuel après, centrale ")+i+" scenario "+s);
                    m_cplex.addToZ(0, a, 1);
                    m_cplex.setZoneHorizontale( string("fuel fin  , centrale ")+i+" scenario "+s);
                    m_cplex.addToZ(0, a,-1);
                    m_cplex.addToRHS(0, CPlexModel::GreaterThan, (prod_max-MMAX(i,k)).v);
                }
            }
        }
    }
}