#include "cinstancereduite.h"
#include "cinstance.h"

using namespace std ;

vector<kW > CInstanceReduite::m_DEM ;
vector<kW > CInstanceReduite::m_DEM_min ;
vector<kWh> CInstanceReduite::m_EDEM ;
vector<kWh> CInstanceReduite::m_EDEM_min ;
std::vector<std::vector<kWh> > CInstanceReduite::m_EDEM_par_scenario ;

vector<std::vector<kWh> >   CInstanceReduite::m_EMAX ;
vector<std::vector<kW > >   CInstanceReduite::m_PMAX ;
std::vector<kWh>            CInstanceReduite::m_moyenne_EMAX ;
std::vector<std::vector<std::vector<kWh> > >            CInstanceReduite::m_EMIN_week ;
std::vector<std::vector<std::vector<kWh> > >            CInstanceReduite::m_EMAX_week ;
std::vector<std::vector<std::vector<euros_par_kWh> > >  CInstanceReduite::m_C_week ;
std::vector<std::vector<kWh> >                          CInstanceReduite::m_EMIN_moyen ;
std::vector<std::vector<kWh> >                          CInstanceReduite::m_EMAX_moyen ;
std::vector<std::vector<euros_par_kWh> >                CInstanceReduite::m_C_moyen ;

heure CInstanceReduite::m_week_duration = (heure)0 ;
// Ajout Daniel
vector<kWh> CInstanceReduite::m_ThProdMax ;
vector<kWh> CInstanceReduite::m_ThProdMin ;
vector<euros_par_kWh> CInstanceReduite::m_ThCout ;

std::vector<std::vector<kWh> > CInstanceReduite::m_ThMinS ;
std::vector<std::vector<kWh> > CInstanceReduite::m_ThMaxS ;
std::vector<std::vector<euros_par_kWh> > CInstanceReduite::m_ThCoutS ;






void CInstanceReduite::init()
{
    // supposition : D(t) est constant
    m_week_duration = (T()/H()) * ::D();

#ifdef RED_MOYENNE
    calculeMoyenneDemandeParSemaine();
    calculeThProdParSemaine();
//     calculeThCoutParSemaine();
#endif
    calculeEMAXParSemaine();
    calculeType1ParSemaine();
}

void CInstanceReduite::calculeMoyenneDemandeParSemaine()
{
    static tlen_t week_length = T()/H() ;
    m_DEM.resize( H(), (kW)0 ) ;
    m_DEM_min.resize( H(), (kW)INFINI);
    m_EDEM.resize( H(), (kWh)0 ) ;
    m_EDEM_min.resize( H(), (kWh)INFINI );
    m_EDEM_par_scenario.resize( S(), vector<kWh>(H(), (kWh) 0));
    for (week_t w=(week_t)0; w<H(); ++w)
    {
        for (scenario_t s=(scenario_t)0; s<S(); s=(scenario_t) (s+1))
        {
            kW demande_scenario = (kW) 0;
            kWh energy_scenario = (kWh) 0 ;
            for (timestep_t t = (timestep_t) (w * week_length);
                 t<(timestep_t)(w*week_length+week_length);
                 t=(timestep_t) (t+1))
            {
                demande_scenario += ::DEM(t,s) ;
                energy_scenario += ::EDEM(t,s) ;
            }
            m_DEM[w]     += demande_scenario ;
            m_DEM_min[w] = std::min(m_DEM_min[w], demande_scenario);
            m_EDEM[w]     += energy_scenario ;
            m_EDEM_min[w] = std::min(m_EDEM_min[w], energy_scenario);
            EDEM(s,w) = energy_scenario ;
        }
        m_DEM[w]  /= (coeff_t) (S()*week_length) ;
        m_EDEM[w] /= (coeff_t) S() ;
    }
}


/**
 * calcule EMAX pour toutes les centrales de type 2 et pour toutes les semaines
 */
void CInstanceReduite::calculeEMAXParSemaine()
{
    static tlen_t week_length = T()/H() ;
    m_EMAX = vector< vector<kWh> >( I(), vector<kWh>(H(), (kWh)0) );
    m_PMAX = vector< vector<kW > >( I(), vector<kW >(H(), (kW )0) );
    m_moyenne_EMAX = vector<kWh>  ( I(), (kWh)0 );
    for (powerplants2_t i=(powerplants2_t)0; i<I(); i=(powerplants2_t)(i+1))
    {
        for (week_t w=(week_t)0; w<H(); w=(week_t) (w+1))
        {
            for (timestep_t t = (timestep_t) (w * week_length);
                 t<(timestep_t)(w*week_length+week_length);
                 t=(timestep_t) (t+1))
            {
                EMAX(i,w) += ::EMAX(i,t);
                PMAX(i,w) += ::PMAX(i,t);
            }
            PMAX(i,w) /= (coeff_t) week_length ;
            EMAX(i) += EMAX(i,w);
        }
        EMAX(i) /= (coeff_t) H();
    }
}

void CInstanceReduite::calculeType1ParSemaine()
{
    static tlen_t week_length = T()/H() ;

    m_EMIN_week = vector< vector< vector<kWh> > >( J(),
            vector< vector<kWh> >( S(),
                                   vector<kWh>( H(), (kWh)0 )));
    m_EMAX_week = vector< vector< vector<kWh> > >( J(),
            vector< vector<kWh> >( S(),
                                   vector<kWh>( H(), (kWh)0 )));
    m_C_week = vector< vector< vector<euros_par_kWh> > >( J(),
            vector< vector<euros_par_kWh> >( S(),
                                             vector<euros_par_kWh>( H(), (euros_par_kWh)0 )));
    m_EMIN_moyen    = vector<vector<kWh> >( J(), vector<kWh>( H() ));
    m_EMAX_moyen    = vector<vector<kWh> >( J(), vector<kWh>( H() ));
    m_C_moyen       = vector< vector<euros_par_kWh> >( J(), vector<euros_par_kWh>( H() ));

    for (powerplants1_t j=(powerplants1_t)0; j<J(); ++j)
    {
        for (scenario_t s=(scenario_t)0; s<S(); ++s)
        {
            for (week_t w=(week_t)0; w<H(); ++w)
            {
                for (timestep_t t = w * week_length;
                    t<w*week_length+week_length;
                    ++t)
                {
                    EMIN(j,s,w) += ::EMIN(j,t,s);
                    EMAX(j,s,w) += ::EMAX(j,t,s);
                    C   (j,s,w) += ::C(j,t,s);
                }
                C(j,s,w) /= week_length ;
                EMIN(j,w) += EMIN(j,s,w);
                EMAX(j,w) += EMAX(j,s,w);
                C   (j,w) += C(j,s,w);
            }
        }
        for (week_t w=(week_t)0; w<H(); ++w)
        {
            EMIN(j,w) /= S();
            EMAX(j,w) /= S();
            C   (j,w) /= S();
//             cout << "min, max, cout (" << j << "," << w <<") :\t" << EMIN(j,w) << "\t" << EMAX(j,w) << "\t" << C   (j,w) << endl;
        }
    }
}


/**
 * calcule ThProdMin et ThProdMax pour toutes les centrales de type 1 et pour toutes les semaines
 */
// void CInstanceReduite::calculeThProdParSemaine()
// {
//     static timestep_t week_length = (timestep_t)( T()/H() ) ;
//     m_ThProdMax.resize( H(), (kWh) 0 );
//     m_ThProdMin.resize( H(), (kWh) 0 );
// 
//     for (week_t w=(week_t)0; w<H(); w=(week_t) (w+1))
//     {
//         kWh som_max = (kWh)0;
//         kWh som_min = (kWh)0;
//         for (powerplants1_t j=(powerplants1_t)0; j<J(); j=(powerplants1_t)(j+1))
//         {
//             for (timestep_t t = (timestep_t) (w * week_length);
//                  t<(timestep_t)(w*week_length+week_length);
//                  t=(timestep_t) (t+1))
//             {
//                 for (scenario_t s = (scenario_t) 0; s < S();s=(scenario_t)(s+1))
//                 {
//                     som_max += ::EMAX(j,t,s);
//                     som_min += ::EMIN(j,t,s);
//                 }
//             }
//         }
//         som_max/=(coeff_t)S();
//         som_min/=(coeff_t)S();
//         m_ThProdMax[w] = som_max;
//         m_ThProdMin[w] = som_min;
//     }
// 
// #ifdef TEST_PMAX
//     for (week_t w=(week_t)0; w<H(); w=(week_t) (w+1))
//     {
//         printf( "%f ",::ThProdMax(w));
//     }
//     printf( "\n");
// #endif
// 
// }

void CInstanceReduite::calculeThProdParSemaine()
{
    static timestep_t week_length = (timestep_t)( T()/H() ) ;

    m_ThProdMax.resize( H() );
    m_ThProdMin.resize( H() );
    m_ThCout.resize( H() );

    m_ThMinS.resize( S(), std::vector<kWh>(H()) );
    m_ThMaxS.resize( S(), std::vector<kWh>(H()) );
    m_ThCoutS.resize(S(), std::vector<euros_par_kWh>(H()) );

    for (week_t w=(week_t)0; w<H(); w=(week_t) (w+1))
    {
        euros   som_cout    ;

        for (scenario_t s = (scenario_t) 0; s < S();s=(scenario_t)(s+1))
        {
            euros   coutS   ;

            for (timestep_t t = (timestep_t) (w * week_length);
                 t<(timestep_t)(w*week_length+week_length);
                 t=(timestep_t) (t+1))
            {
                kWh prodMaxT    ;
                kWh prodMinT    ;
                euros coutT     ;

                // calcul de la demande - prod. min
                kWh demandeComp = ::EDEM(t,s);
                for (powerplants1_t j=(powerplants1_t)0; j<J(); j=(powerplants1_t)(j+1))
                {
                    demandeComp -= ::EMIN(j,t,s) ;
                }
                // examen des centrales par coût croissant
                map<euros_par_kWh, powerplants1_t> cout_centrale ;
                for (powerplants1_t j=(powerplants1_t)0; j<J(); j=(powerplants1_t)(j+1))
                {
                    cout_centrale[::C(j,t,s)] = j ;
                }
                for (map<euros_par_kWh, powerplants1_t>::iterator itPp = cout_centrale.begin(); itPp!=cout_centrale.end(); itPp++)
                {
                    powerplants1_t j = itPp->second ;
                    kWh prodComp = std::min( demandeComp, ::EMAX(j,t,s) - ::EMIN(j,t,s) );
                    demandeComp -= prodComp ;
                    prodMaxT    += ::EMIN(j,t,s) + prodComp;
                    prodMinT    += ::EMIN(j,t,s);
                    coutT       += ::C(j,t,s) * (::EMIN(j,t,s) + prodComp) ;
                }
                m_ThMaxS[s][w] += prodMaxT ;
                m_ThMinS[s][w] += prodMinT ;
                coutS += coutT    ;
            }
            m_ThCoutS[s][w] = coutS / m_ThMaxS[s][w] ;
            m_ThProdMax[w]  += m_ThMaxS[s][w] ;
            m_ThProdMin[w]  += m_ThMinS[s][w] ;
            m_ThCout[w]     += m_ThCoutS[s][w] ;
        }
        m_ThProdMax[w]  /=(coeff_t)S();
        m_ThProdMin[w]  /=(coeff_t)S();
        m_ThCout[w]     /= S();
    }

    #ifdef TEST_PMAX
    for (week_t w=(week_t)0; w<H(); w=(week_t) (w+1))
    {
        printf( "%f ",::ThProdMax(w));
    }
    printf( "\n");
    #endif

}

// void CInstanceReduite::calculeThCoutParSemaine()
// {
//     static tlen_t week_length = T()/H() ;
//     m_ThCout.resize( H(), (euros_par_kWh)0 );
//
//     for (week_t w=(week_t)0; w<H(); w=(week_t) (w+1))
//     {
//         euros num = (euros) 0;
//         for (powerplants1_t j=(powerplants1_t)0; j<J(); j=(powerplants1_t)(j+1))
//         {
//             for (timestep_t t = (timestep_t) (w * week_length);
//                  t<(timestep_t)(w*week_length+week_length);
//                  t=(timestep_t) (t+1))
//             {
//                 for (scenario_t s = (scenario_t) 0; s < S();s=(scenario_t)(s+1))
//                 {
//                     num += ::C(j,t,s) * ::EMAX(j,t,s) ;
//                 }
//             }
//         }
//         num /= S() ;
//         m_ThCout[w] = num / m_ThProdMax[w];
// #ifdef VERBOSE_COUT_THERMIQUES
//         std::cout << num << " " << std::endl ;
// #endif
//     }//*/
//
// }