#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
coeff_t     CInstance::m_epsilon(0)                  ;   // 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<size_t> CInstance::m_M                   ;   // number of constraints of type i (13 <= i <= 21)
std::vector<heure> CInstance::m_D                    ;   // durations : length of timesteps t (t <= T)
std::vector<std::vector<kW> >   CInstance::m_DEM     ;   // power_demand[s][t]
std::vector<std::vector<kWh> >  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 ;

CConstraint * CInstance::constraint(constraint_t type, size_t index)
{
    switch (type) {
        case 14 : return &m_constraints14[index];
        case 15 : return &m_constraints15[index];
        case 16 : return &m_constraints16[index];
        case 17 : return &m_constraints17[index];
        case 18 : return &m_constraints18[index];
        case 19 : return &m_constraints19[index];
        case 20 : return &m_constraints20[index];
        case 21 : return &m_constraints21[index];
        default :
            throw string("Type de contrainte inconnu");
    }
}

void CInstance::lire( const CParams & params )
{
    m_params    = params ;
    instanceNs::input_stream.open((string("./")+m_params.getInstanceName()).c_str());
    if (instanceNs::input_stream.fail())
        throw string("ouverture impossible de ") + getenv("PWD") + "/" +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<coeff_t>("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);*/
    m_DEM   =   vector< vector<kW> >  (m_S, vector<kW> (m_T, (kW) 0));
    m_EDEM  =   vector< vector<kWh> > (m_S, vector<kWh>(m_T, (kWh)0));

    for (vector<vector<kW> >::iterator it=m_DEM.begin(); it!=m_DEM.end(); it++)
    {
        lire_liste("demand", *it);
    }
    {
        vector<vector<kW> > ::iterator itd ;
        vector<vector<kWh> >::iterator ite ;
        for (itd=m_DEM.begin(), ite=m_EDEM.begin(); itd!=m_DEM.end(); itd++,ite++)
        {
            for (timestep_t t=(timestep_t)0; t<m_T; ++t)
            {
                (*ite)[t] = (*itd)[t] * D(t) ;
            }
        }
    }
    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 */
    // Des contraintes 13 interpolées sont créées dans corrigeTO
    // De plus, CType2 contient des itérateurs vers m_constraints13
    // Pour éviter les réallocations, et préserver la validité de ces itérateurs,
    // il faut réserver autant de contraintes 13 que possible
    m_constraints13.resize( M((constraint_t)13) );
    m_constraints13.reserve( m_I * m_K );
    for ( size_t m=0; m<M((constraint_t)13); m++ )
    {
        m_constraints13[m].lire(m);
    }
    m_constraints14.resize( M((constraint_t)14) );
    for ( size_t m=0; m<M((constraint_t)14); m++ )
    {
        m_constraints14[m].lire(m);
    }
    m_constraints15.resize( M((constraint_t)15) );
    for ( size_t m=0; m<M((constraint_t)15); m++ )
    {
        m_constraints15[m].lire(m);
    }
    m_constraints16.resize( M((constraint_t)16) );
    for ( size_t m=0; m<M((constraint_t)16); m++ )
    {
        m_constraints16[m].lire(m);
    }
    m_constraints17.resize( M((constraint_t)17) );
    for ( size_t m=0; m<M((constraint_t)17); m++ )
    {
        m_constraints17[m].lire(m);
    }
    m_constraints18.resize( M((constraint_t)18) );
    for ( size_t m=0; m<M((constraint_t)18); m++ )
    {
        m_constraints18[m].lire(m);
    }
    m_constraints19.resize( M((constraint_t)19) );
    for ( size_t m=0; m<M((constraint_t)19); m++ )
    {
        m_constraints19[m].lire(m);
    }
    m_constraints20.resize( M((constraint_t)20) );
    for ( size_t m=0; m<M((constraint_t)20); m++ )
    {
        m_constraints20[m].lire(m);
    }
    m_constraints21.resize( M((constraint_t)21) );
    for ( size_t m=0; 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( m_constraints13 );
    }
}



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
}