#include "../tuning.h"

#include "cinstance.h"
#include "cinstancereduite.h"
#include "lecture.h"
using instanceNs::lire_valeur;
using instanceNs::lire_liste;

#include "../params/cparams.h"

#include <iostream>
#include <fstream>
#include <vector>
#include <sstream>
#include <cstdlib>
#include <algorithm>

using namespace std;


std::ifstream instanceNs::input_stream ;

CParams  CInstance::m_params                       ;

/* Main Information section */
timestep_t  CInstance::m_T                           ;   // number of timesteps
week_t      CInstance::m_H                           ;   // number of weeks
campaign_t  CInstance::m_K                           ;   // number of campaigns
scenario_t  CInstance::m_S                           ;   // number of scenarios
double CInstance::m_epsilon                          ;   // value_of_epsilon
powerplants1_t CInstance::m_J                        ;   // number of powerplants of type 1
powerplants2_t CInstance::m_I                        ;   // number of powerplants of type 2
std::vector<int> CInstance::m_M                    ;   // number of constraints of type i (13 <= i <= 21)
std::vector<int> CInstance::m_D                    ;   // durations : length of timesteps t (t <= T)
std::vector<std::vector<double> > CInstance::m_DEM ;   // power_demand[s][t]
std::vector<std::vector<double> > CInstance::m_EDEM ;  // energy_demand[s][t]

/* Power plants section */
std::vector<CType1> CInstance::m_types1            ;   // centrales de type 1
std::vector<CType2> CInstance::m_types2            ;   // centrales de type 1

/* Constraints section */
std::vector<CConstraint13> CInstance::m_constraints13 ;
std::vector<CConstraint14> CInstance::m_constraints14 ;
std::vector<CConstraint15> CInstance::m_constraints15 ;
std::vector<CConstraint16> CInstance::m_constraints16 ;
std::vector<CConstraint17> CInstance::m_constraints17 ;
std::vector<CConstraint18> CInstance::m_constraints18 ;
std::vector<CConstraint19> CInstance::m_constraints19 ;
std::vector<CConstraint20> CInstance::m_constraints20 ;
std::vector<CConstraint21> CInstance::m_constraints21 ;

void CInstance::lire( const CParams & params )
{
    m_params    = params ;
    instanceNs::input_stream.open((string("../../data/")+m_params.getInstanceName()).c_str());
    if (instanceNs::input_stream.fail())
        throw string("ouverture impossible de ") + getenv("PWD") + "/../../data/" +m_params.getInstanceName();

    /* lecture de la section main */

    if (lire_valeur<string>("begin")!="main")
        throw string("section main manquante");

    m_T = (timestep_t)    lire_valeur<int>("timesteps");
    m_H = (week_t)        lire_valeur<int>("weeks");
    m_K = (campaign_t)    lire_valeur<int>("campaigns");
    m_S = (scenario_t)    lire_valeur<int>("scenario");
    m_epsilon = lire_valeur<double>("epsilon");
    m_J = (powerplants1_t) lire_valeur<int>("powerplant1");
    m_I = (powerplants2_t) lire_valeur<int>("powerplant2");
    m_M.resize(22);
    for (size_t c=13 ; c<=21; c++)
    {
        std::ostringstream nom;
        nom << "constraint" << c ;
        M((constraint_t)c) = lire_valeur<int>(nom.str());
    }
    m_D.resize(m_T); lire_liste("durations", m_D);
    vector<double> proto;       // curieusement, le constructeur vector<double>(T) ne réserve pas d'espace si l'on compile en optimisé
    proto.resize(m_T);            // sinon, on devrait faire : m_DEM=vector<vector<double> >(S, vector<double> T);
    m_DEM.resize(m_S, proto);     // qui fonctionne sans option d'optimisation
    m_EDEM.resize(m_S, proto);
    for (vector<vector<double> >::iterator it=m_DEM.begin(); it!=m_DEM.end(); it++)
    {
        lire_liste("demand", *it);
    }
    for (vector<vector<double> >::iterator itd=m_DEM.begin(), ite=m_EDEM.begin(); itd!=m_DEM.end(); itd++,ite++)
    {
        std::transform(itd->begin(),itd->end(),ite->begin(),bind1st(multiplies<double>(),::D()));
    }

    if (lire_valeur<string>("end")!="main")
        throw string("end main manquant");

    /* lecture des sections powerplant de type 1 */
    m_types1.resize(m_J) ;
    for (size_t j=0; (signed)j<m_J; j++)
    {
        CType1 & powerplant = type1( (powerplants1_t) j );
        // la méthode lire() de CType1 lit instanceNs::input_stream
        powerplant.lire();

        /* vérifications */
        if (powerplant.j != (powerplants1_t) j)
            throw string("Index d'une centrale de Type 1 mal placé");
        if (powerplant.S != m_S)
            throw string("Centrale de Type 1 avec un nombre de scénarios différent");
        if (powerplant.T != m_T)
            throw string("Centrale de Type 1 avec un nombre de pas de temps différent");
    }

    /* lecture des sections powerplant de type 2 */
    m_types2.resize(m_I) ;
    for (size_t i=0; (signed)i<m_I; i++)
    {
        CType2 & powerplant = type2( (powerplants2_t) i );
        // la méthode lire() de CType2 lit instanceNs::input_stream
        powerplant.lire(m_T);

        /* vérifications */
        if (powerplant.i != (powerplants2_t) i)
            throw string("Index d'une centrale de Type 2 mal placé");
    }

    /* lecture des sections constraint */
    m_constraints13.resize( M((constraint_t)13) );
    for ( size_t m=0; (signed)m<M((constraint_t)13); m++ )
    {
        m_constraints13[m].lire(m);
    }
    m_constraints14.resize( M((constraint_t)14) );
    for ( size_t m=0; (signed)m<M((constraint_t)14); m++ )
    {
        m_constraints14[m].lire(m);
    }
    m_constraints15.resize( M((constraint_t)15) );
    for ( size_t m=0; (signed)m<M((constraint_t)15); m++ )
    {
        m_constraints15[m].lire(m);
    }
    m_constraints16.resize( M((constraint_t)16) );
    for ( size_t m=0; (signed)m<M((constraint_t)16); m++ )
    {
        m_constraints16[m].lire(m);
    }
    m_constraints17.resize( M((constraint_t)17) );
    for ( size_t m=0; (signed)m<M((constraint_t)17); m++ )
    {
        m_constraints17[m].lire(m);
    }
    m_constraints18.resize( M((constraint_t)18) );
    for ( size_t m=0; (signed)m<M((constraint_t)18); m++ )
    {
        m_constraints18[m].lire(m);
    }
    m_constraints19.resize( M((constraint_t)19) );
    for ( size_t m=0; (signed)m<M((constraint_t)19); m++ )
    {
        m_constraints19[m].lire(m);
    }
    m_constraints20.resize( M((constraint_t)20) );
    for ( size_t m=0; (signed)m<M((constraint_t)20); m++ )
    {
        m_constraints20[m].lire(m);
    }
    m_constraints21.resize( M((constraint_t)21) );
    for ( size_t m=0; (signed)m<M((constraint_t)21); m++ )
    {
        m_constraints21[m].lire(m);
    }

    /* correction des TO pour les centrales de type 2 */
    for (powerplants2_t i=(powerplants2_t) 0; i<m_I; i = (powerplants2_t) (i+1))
    {
        type2( i ) . corrigeTO();
    }
}



void CInstance::analyse()
{
#ifdef TEST_MOYENNE_PAR_SCENARIO
    for (week_t w=(week_t)0; w<H(); ++w)
    {
        std::cout << "semaine " << w << " : demande " << ::DEM(w) << "\n" ;
    }
#endif
}