#include "cplan.h"
#include "cgraphe.h"
#include <cinstance.h>
#include <cinstancereduite.h>
#include <tuning.h>
#include <fstream>
#include <iomanip>

using namespace std ;

int CPlan::id = 0 ;

CPlan::CArc::CArc(const CNoeud & depart, const CNoeud & fin,
                  double _recharge, double _reste,
                  double _cout_reduit, double _cout) : m_depart(&depart), m_fin(&fin)
{
    m_type          = depart.m_type     ;
    m_k             = depart.m_campaign ;
    m_date          = depart.m_date     ;
    m_date_fin      = fin   .m_date     ;
    m_recharge      = _recharge         ;
    m_cout          = _cout             ;
    m_cout_reduit   = _cout_reduit      ;
    m_reste         = _reste            ;
}

CPlan::CPlan( powerplants2_t i, size_t taille_prod, powerplants2_t nb_centrales) {
    m_colonne = std::vector<double>( taille_prod + nb_centrales, 0 );
    m_colonne[ taille_prod + i ] = 1 ;
    m_fuel              = vector<double>( taille_prod, 0 ) ;
    m_fuel_tp1          = vector<double>( taille_prod, 0 ) ;
    m_i = i ;
    for (week_t h=(week_t)0; h<(week_t)taille_prod; ++h)
        m_colonne[h] = EMAX(m_i, h);
    m_cout_reduit   = 0 ;
    m_cout          = 0 ;
    m_reste         = 0 ;
    m_id            = id++ ;
}

void CPlan::set_prod( size_t index, double prod ) {
    m_colonne[index] = prod ;
}

void CPlan::push_back( const CNoeud & dep, const CNoeud & fin,
                       double _recharge, double _reste,
                       double _cout_reduit, double _cout )
{
    m_arcs.push_back(CArc(dep, fin, _recharge, _reste, _cout_reduit, _cout ));
    m_cout_reduit   += _cout_reduit ;
    m_cout          += _cout        ;
    m_reste = _reste ;
    if (fin.m_type==TYPE_DERNIER)
    {
        m_cout -= (CiTp1(m_i)*_reste);
        m_cout_reduit -= CGraphe::V(m_i);
        // calcul des ha
        m_ha.resize(0);
        for (size_t a=0; a<m_arcs.size(); a++)
            if (m_arcs[a].m_type==TYPE_OUTAGE)
                m_ha.push_back( m_arcs[a].m_date ) ;
    }
    // calcul du fuel à chaque semaine
    m_fuel[dep.m_date] = dep.m_fuel;
    m_fuel_tp1[dep.m_date] = dep.m_fuel_avant_refuel + _recharge ;
    for (week_t h=dep.m_date + (wlen_t) 1; h<fin.m_date; ++h)
    {
            m_fuel[h] = m_fuel_tp1[h-1] - m_colonne[h-1] ;
            m_fuel_tp1[h] = m_fuel[h] ;
    }
}



void CPlan::remplis_BO(vector<double> & prod, vector<double> & stock, vector<double> & demande_restante)
{
    for (size_t arc_idx=0; arc_idx<m_arcs.size(); arc_idx++)
    {
        CArc & arc = m_arcs[arc_idx] ;
        if (arc.m_depart->m_type==TYPE_BO) {
            double fuel = arc.m_depart->m_fuel ;
            for (timestep_t t=week2timestep(arc.m_date); t<week2timestep(arc.m_fin->m_date); ++t)
            {
                stock[t] = fuel ;
                prod[t] = type2(m_i).PB(arc.m_depart->m_campaign, t, fuel);
                fuel -= prod[t] ;
                demande_restante[t] -= prod[t] ;
            }
        }
    }
}

void CPlan::remplis_BO_en_visant_bien(vector<double> & prod, vector<double> & stock, vector<double> & demande_restante)
{
    for (size_t arc_idx=0; arc_idx<m_arcs.size(); arc_idx++)
    {
        CArc & arc = m_arcs[arc_idx] ;
        const CNoeud & depart = *m_arcs[arc_idx].m_depart ;
        const CNoeud & fin    = *m_arcs[arc_idx].m_fin    ;
        if (depart.m_type==TYPE_BO) {

            list<double> ideal ;
            timestep_t tdeb=week2timestep(depart.m_date);
            timestep_t tfin=week2timestep(fin.m_date);
            cout << "\nPowerplant " << m_i.v << " k:" << depart.m_campaign.v << " h:" << depart.m_date.v << endl ;
            if (fin.m_type!=TYPE_DERNIER)
            {
                // pour bien viser, on encadre le stock sur chaque t
                list<CIntervallesBO> liste_limits ;
                liste_limits.push_back( CIntervallesBO(-1,depart.m_fuel,depart.m_fuel) );
                for (timestep_t t=tdeb; t<tfin; ++t)
                {
                    cout << fixed << setprecision(10) << "(t=" << t << ",f0=" << liste_limits.back().f0
                            << ", f1=" << liste_limits.back().f1
                            << ", f2=" << liste_limits.back().f2
                            << std::endl ;
                    CIntervallesBO nouvelles_limites = type2(m_i).PBlimits(depart.m_campaign, t, liste_limits.back());
                    liste_limits.push_back( nouvelles_limites );
                }
                cout << endl;

                // il faut maintenant viser le début de l'arc suivant
                double ffin = fin.m_fuel;
                liste_limits.pop_back() ;

                // construisons une courbe de fuel la plus médiane possible,
                // qui atteindrait ce niveau final en restant entre les limites.
                // On la construit depuis la fin.
                ideal.push_front(ffin);
                for (timestep_t t=tfin-(tlen_t)1; t>tdeb; --t) {
                    double x = type2(m_i).back_level(depart.m_campaign, t, ideal.front(), liste_limits.back()) ;
                    liste_limits.pop_back();
                    ideal.push_front( x );
                }
            }
            else // fin.type==TYPE_DERNIER
            {
                ideal.push_back( depart.m_fuel );
                for (timestep_t t=tdeb; t<tfin; ++t)
                {
                    cout << fixed << setprecision(10) << "(t=" << t << ",f=" << ideal.back();
                    double prod = type2(m_i).PB(arc.m_depart->m_campaign, t, ideal.back());
                    ideal.push_back(ideal.back()-prod) ;
                    cout << ",prod=" << prod << ", pow="<< prod/D() << ")\n";
                }
                cout << endl;
                ideal.pop_front();
            }
            // on repart en avant
            double fuel = depart.m_fuel ;
            for (timestep_t t=tdeb; t<tfin; ++t)
            {
                stock[t] = fuel ;
                double p_ideal = fuel - ideal.front(); ideal.pop_front();
                prod[t] = p_ideal ;
                fuel -= prod[t] ;
                demande_restante[t] -= prod[t] ;
            }
        }
    }
}




void CPlan::remplis_campagnes_non_BO( vector<double> & prod, vector<double> & stock, vector<double> & demande_restante)
{
    for (size_t arc_idx=0; arc_idx<m_arcs.size(); arc_idx++)
    {
        CArc & arc = m_arcs[arc_idx] ;
        // remplissage des outages proprement dits (0 partout)
        if (arc.m_depart->m_type==TYPE_OUTAGE) {
            timestep_t t = week2timestep(arc.m_date) ;
            stock[t] = arc.m_depart->m_fuel ;
            prod [t] = 0 ;
            for (++t; t<week2timestep(arc.m_fin->m_date_campaign); ++t) {
                stock[t] = arc.m_depart->m_fuel_avant_refuel + arc.m_recharge ;
                prod[t]  = 0 ;
            }
        }
        // remplissage des campagnes de production non BO
        if (arc.m_depart->m_type != TYPE_BO) {
            double fuel = arc.m_depart->m_fuel_avant_refuel + arc.m_recharge ;
            // parcours des semaines
            for (week_t h = arc.m_depart->m_date_campaign; h<arc.m_fin->m_date; ++h) {
                for (timestep_t t=week2timestep(h); t<week2timestep(h+(wlen_t)1); ++t) {
                    // correction du stock pour que les erreurs d'arrondi ne fassent pas
                    // croire au checker que l'on est passé sous le seuil BO
                    stock[t] = std::max(fuel,BO(m_i,arc.m_depart->m_campaign)) ;
                    prod [t] = m_colonne[h] * (EMAX(m_i,t)==0 ? 1 : EMAX(m_i,t) / EMAX(m_i,h));
                    fuel    -= prod[t] ;
                    demande_restante[t] -= prod[t] ;
                }
            }
        }
    }
}


void CPlan::remplis_dates_outages( std::vector<week_t> & dates )
{
    for (size_t arc_idx=0; arc_idx<m_arcs.size(); arc_idx++)
    {
        CArc & arc = m_arcs[arc_idx] ;
        // remplissage des outages proprement dits (0 partout)
        if (arc.m_depart->m_type==TYPE_OUTAGE)
            dates[arc.m_depart->m_campaign] = arc.m_depart->m_date ;
    }
}

void CPlan::remplis_recharges( std::vector<double> & recharges )
{
    for (size_t arc_idx=0; arc_idx<m_arcs.size(); arc_idx++)
    {
        CArc & arc = m_arcs[arc_idx] ;
        // remplissage des outages proprement dits (0 partout)
        if (arc.m_depart->m_type==TYPE_OUTAGE)
            recharges[arc.m_depart->m_campaign] = arc.m_recharge ;
    }
}

ostream & operator <<(ostream & out, CPlan & plan)
{
#ifdef FICHIER_PLAN
    ofstream fichier ;
    char nom[100];
    sprintf(nom, "centrale_%02d", (int)plan.m_i);
    fichier.open(nom, ios_base::app);
    //fichier.seekp( 0, ios_base::end );
    for (size_t h=0; h<(unsigned)H(); h++) {
        fichier << fixed << setprecision(10) << plan.m_colonne[h];
        if (h==(unsigned) (H()-1))
            fichier << endl ;
        else
            fichier << '\t';
    }
    fichier.close();
#endif
    out << "***** Plan de production de la centrale " << (int) plan.m_i << " *****" << endl ;
    for (size_t i = 0; i<plan.m_arcs.size(); i++)
    {
        CPlan::CArc & a = plan.m_arcs[i] ;
        out << "Campagne " << a.m_k << "\t" << TYPE(a.m_type) << "\tdébut : " << a.m_date << " fin : " << a.m_date_fin
                << "\trecharge : " << a.m_recharge << "\treste : " << a.m_reste << "\tcoût réduit : " << a.m_cout_reduit << "\tcoût : " << a.m_cout << endl;
        out << "   fuel :";
        for (week_t h=a.m_date; h<a.m_date_fin; ++h)
            out << " " << plan.m_fuel[h] ;
        out << endl ;
        out << "   prod :";
        for (week_t h=a.m_date; h<a.m_date_fin; ++h)
            out << " " << plan.m_colonne[h] ;
        out << endl ;
        out << "  modul :";
        for (week_t h=a.m_date; h<a.m_date_fin; ++h)
            out << " " << 1-(plan.m_colonne[h]==0 ? 0 : plan.m_colonne[h]/EMAX(plan.m_i,h)) ;
        out << endl ;
        out << "    u_i :";
        for (week_t h=a.m_date; h<a.m_date_fin; ++h)
            out << " " << CGraphe::m_u->at(h) ;
        out << endl ;
    }
    out << "   revente : " << plan.m_reste << "\tprix : " << CiTp1(plan.m_i)*plan.m_reste << endl;
    out << "   coût total du plan : " << plan.m_cout << endl ;
    out << "   coût réduit de la colonne : " << plan.m_cout_reduit << endl ;
    return out ;
}