#include "cdualcplexscenario.h"

#include <cplexmutable.h>
#include <cinstance.h>
#include <cinstancereduite.h>
#include <cplan.h>

#include <algorithm>

using namespace std;

CDualCplexScenario::CDualCplexScenario(scenario_t s, bool internal_silent, bool silent, bool writeToFile)
{
    m_s = s;
    m_cplex = new CPlexMutable( "DualCalc", CPlexModel::Minimisation, CPlexModel::Linear,
                                internal_silent, silent, writeToFile, writeToFile );
    ajoute_thermiques();
    ajoute_contraintes();
}


CDualCplexScenario::~CDualCplexScenario()
{
    delete m_cplex;
}


std::vector< euros_par_kWh > CDualCplexScenario::calculeDuals() const
{
    vector<euros_par_kWh> duals( H() + I() );

    m_cplex->resolution();
    cout << "Objectif : " << m_cplex->getObjectiveValue() << endl;
    vector<double> cplex_duals = m_cplex->getDuals("production=demande");
    for (week_t h; h<H(); ++h)
        duals[h] = (euros_par_kWh) cplex_duals[h];

    cplex_duals = m_cplex->getDuals( "unicité colonnes nucléaires" );
    for (powerplants2_t i; i<I(); ++i)
        duals[H()+i] = (euros_par_kWh) cplex_duals[i];

    CConstraint::collecte_duales_14_a_21(m_cplex);

    return duals ;
}

void CDualCplexScenario::ajoutcolonne(CPlan* cplan)
{
    // ajout du plan à la liste des plans
    m_plans.push_back(cplan);

    // ajout de la zone horizontale pour la colonne
    m_cplex->addColonne( string("production nucléaire plan ")+cplan->m_id, 1);

    // fonction objectif : coût du plan
    m_cplex->setColonne( string("production nucléaire plan ")+cplan->m_id );
//     m_cplex->addToObj( 0, 0, 1, CPlexModel::Continuous, cplan->m_cout.v );
    m_cplex->addToObj( 0, 0, INFINI, CPlexModel::Continuous, cplan->m_cout.v );

    // Z : partie production
    m_cplex->setLigne("production=demande");
    for (week_t h=(week_t)0; h<H(); ++h)
        m_cplex->addToZ( h, 0, cplan->m_colonne[h].v );
    // Z : partie sélection de colonne
    m_cplex->setLigne( "unicité colonnes nucléaires" );
    m_cplex->addToZ( cplan->m_i, 0, 1 );

    // ajout des contraintes de type 14 à 21
    CConstraint::ajoute_plan_contraintes_14_a_21(cplan, m_cplex);

    // ajout des coefficients (abarre-a) les contraintes des variables de recours ?" delta+
    m_cplex->setLigne  (string("delta_date_plus_i_")+cplan->m_i+"_k");
    for (campaign_t k; k<K(); ++k) {
        if (k<cplan->K())
            m_cplex->addToZ(k, 0, m_dates_ref[cplan->m_i][k] - cplan->ha(k));
        else
            m_cplex->addToZ(k, 0, m_dates_ref[cplan->m_i][k] - H());
    }
    // ajout des coefficients sur les variables "de recours ?" delta-
    m_cplex->setLigne  (string("delta_date_moins_i_")+cplan->m_i+"_k");
    for (campaign_t k; k<K(); ++k) {
        if (k<cplan->K())
            m_cplex->addToZ(k, 0, cplan->ha(k) - m_dates_ref[cplan->m_i][k]);
        else
            m_cplex->addToZ(k, 0, H()          - m_dates_ref[cplan->m_i][k]);
    }
    // affichage
//     cout << "scenario " << m_s << " centrale " << cplan->m_i << ", arrêts : ";
//     for (campaign_t k; k<K(); ++k) {
//         cout << " " << k << ":";
//         if (k<cplan->K()) cout << cplan->ha(k);
//         else cout << H() ;
//     }
//     cout << endl;
}

pair<vector<double>,vector<double>> CDualCplexScenario::getDualsDates(powerplants2_t i)
{
    pair<vector<double>,vector<double>> duals;
    duals = make_pair(m_cplex->getDuals(string("delta_date_plus_i_")+i+"_k"), m_cplex->getDuals(string("delta_date_moins_i_")+i+"_k"));
    return duals;
}


///Calculer la moyenne x(i)*cplan->ha(k)
vector<vector<double>> CDualCplexScenario::getMoyenneDates()
{
    vector<vector<double>> dates(I(),vector<double>(K(),0.0));
    vector<double> probas = getResults();
    for (size_t p=0; p <m_plans.size(); ++p) {
      CPlan*&plan = m_plans[p];
      for (campaign_t k;k<K();++k) {
         dates[plan->m_i][k] += probas[p]*(k<plan->K()?plan->ha(k):H());
	 ///Affichage
	 //cout << "centrale " << plan->m_i << " id plan " << plan->m_id << " x " << probas[p] << " dates " << dates[plan->m_i][k] << endl;
	 /// end Affichage
      }
//       //cout << "scenario " << m_s << " centrale " << plan->m_i << ", x : " << probas[p] <<  ", arrêts : ";
//       for (campaign_t k; k<K(); ++k) {
//         cout << " " << k << ":";
//         if (k<plan->K()) cout << plan->ha(k);
//         else cout << H() ;
//     }
//     cout << endl;
    }  
    return dates;
}
///

/// retrait d'un plan de production nucléaire
void CDualCplexScenario::retraitColonne(const CPlan* plan)
{
    size_t indice = std::find(m_plans.begin(), m_plans.end(), plan) - m_plans.begin() ;
    m_cplex->removeZoneHorizontale( string("production nucléaire plan ")+plan->m_id );
    m_plans.erase( m_plans.begin()+indice );
}


vector<euros> CDualCplexScenario::getReducedCosts() const
{
    vector<euros> cr( m_plans.size() );
    for (size_t p=0; p<cr.size(); p++)
    {
        cr[p] = (euros) m_cplex->getReducedCosts(string("production nucléaire plan ")+m_plans[p]->m_id)[0];
    }
    return cr;
}

vector<double> CDualCplexScenario::getResults() const
{
    vector<double> vars( m_plans.size() );
    for (size_t p=0; p<vars.size(); p++)
    {
        vars[p] = m_cplex->getResult(string("production nucléaire plan ")+m_plans[p]->m_id)[0];
    }
    return vars;
}

double CDualCplexScenario::getObjectiveValue() const
{
    return m_cplex->getObjectiveValue() ;
}

void CDualCplexScenario::collecte_duales_14_a_21() const
{
    CConstraint::collecte_duales_14_a_21(m_cplex);
}


void CDualCplexScenario::ajoute_thermiques()
{
    // définition des zones
    m_cplex->addLigne( "production=demande", H());
    for (powerplants1_t j=(powerplants1_t)0; j<J(); ++j)
        m_cplex->addColonne( string("production thermique centrale ")+j, H());
    m_cplex->addLigne( "unicité colonnes nucléaires",  I());


    // fonction objectif
    // coeff: coût de la production thermique unitaire par semaine
    // variables associées : énergie produite, continue (entre pmin et pmax)
    for (powerplants1_t j=(powerplants1_t)0; j<J(); ++j)
    {
        m_cplex->setColonne( string("production thermique centrale ")+j );
        for ( week_t h=(week_t) 0; h<H(); ++h)
            m_cplex->addToObj( h,
                               EMIN(j,m_s,h).v,
                               EMAX(j,m_s,h).v,
                               CPlexModel::Continuous,
                               C(j,m_s,h).v );
    }

    //  remplissage de Z
    //  satisfaction de la demande
    m_cplex->setLigne( "production=demande");

    // partie droite : demande, opérateur =
    for (week_t h=(week_t) 0; h<H(); ++h)
        m_cplex->addToRHS( h, CPlexModel::Equals, EDEM(m_s,h).v );

    // production des centrales thermiques par semaine (matrices identité)
    for (powerplants1_t j=(powerplants1_t)0; j<J(); ++j)
    {
        m_cplex->setColonne( string("production thermique centrale ")+j );
        for (week_t h=(week_t)0; h<H(); ++h)
            m_cplex->addToZ( h, h, 1 );
    }

    // unicité des colonnes nucléaires
    m_cplex->setLigne( "unicité colonnes nucléaires" );
    for (powerplants2_t i; i<I(); ++i)
    {
        m_cplex->addToRHS( i, CPlexModel::LowerThan, 1 );
    }
}

void CDualCplexScenario::ajoute_contraintes()
{
    CConstraint::prepare_contraintes_14_a_21(m_cplex);
}

void CDualCplexScenario::ajoute_deltas()
{
    // ajout d'un delta_date+ et d'un delta_date- pour chaque centrale nucléaire et chaque campagne
    vector<string> zones({string("delta_date_plus_i_" ),string("delta_date_moins_i_")});
    for (string zone: zones) {
        for (powerplants2_t i; i<I(); ++i) {
            // ajout des variables
            m_cplex->addColonne(zone+i+"_k", K());
            // fonction objectif : coûts et bornes
            m_cplex->setColonne(zone+i+"_k");
            for (campaign_t k; k<K(); ++k) {
                m_cplex->addToObj(k, 0, H().v, CPlexModel::Continuous,
                                  zone=="delta_date_plus_i_" ? type2(i).Cpost(k).v : type2(i).Cpre(k).v);
                //                 cout << "delta_date_plus_i_" << i << "_k_" << k << " = " << type2(i).Cpost(k).v << endl;
            }
            // ajout des contraintes : une pour chaque delta_date
            m_cplex->addLigne(zone+i+"_k", K());
            m_cplex->setLigne(zone+i+"_k");
            for (campaign_t k; k<K(); ++k) {
                m_cplex->addToZ(k, k, 1);
                m_cplex->addToRHS(k, CPlexModel::GreaterThan, 0);
            }
        }
    }
}