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

using namespace std ;

int CPlan::id = 0 ;

/// liste des plans retenus
std::vector<CPlan *>   CPlan::s_plans;

/// plans_centrale[i] = ensemble des idx des colonnes relatives à la centrale i
vector<vector<size_t> > CPlan::s_plans_centrale;

/// plan déjà existant trouvé dans retiens_plan
size_t CPlan::s_plan_existant = (size_t) -1;

/**
 * ENREGISTRE UN PLAN
 */
bool CPlan::retiens_plan(CPlan * nouveau_plan, bool meme_si_deja_present)
{
    if (s_plans_centrale.size()==0)
        s_plans_centrale.resize(I(), vector<size_t>(0));

    vector<size_t> & plans_centrale = s_plans_centrale[nouveau_plan->m_i];
    if (not meme_si_deja_present) {
        for (size_t ip=0; ip<plans_centrale.size(); ip++) {
            if (*(s_plans[plans_centrale[ip]])==*nouveau_plan) {
                s_plan_existant = plans_centrale[ip] ;
                return false;
            }
        }
    }
    plans_centrale.push_back(s_plans.size());
    s_plans.push_back(nouveau_plan);
    return true;
}

size_t CPlan::plan_existant()
{
    return s_plan_existant ;
}

void CPlan::libere_plan(CPlan * plan)
{
    // recherche de l'index du plan dans s_plans et suppression
    vector<CPlan *>::iterator itp = std::find(s_plans.begin(), s_plans.end(), plan);
    size_t index = itp - s_plans.begin();
    s_plans.erase(itp);

    // recherche et suppression de l'index trouvé dans les plans associés à la centrale plan->m_i
    vector<size_t> & idx_plans = s_plans_centrale[plan->m_i];
    vector<size_t>::iterator it = std::find(idx_plans.begin(), idx_plans.end(), index);
    idx_plans.erase(it);

    // décrémentation des index supérieurs
    for (powerplants2_t i; i<I(); ++i)
    {
        for (it=s_plans_centrale[i].begin(); it!=s_plans_centrale[i].end(); it++)
        {
            if (*it>index) (*it)--;
        }
    }

    // libération du plan
    delete plan;
}

/**
 * libération
 */

void CPlan::libere_plans()
{
    for (std::vector<CPlan*>::iterator it=s_plans.begin(); it!=s_plans.end(); it++)
        if (*it) delete *it;
    s_plans.clear();
}

size_t CPlan::findIndex(const CPlan * plan)
{
    return std::find(s_plans.begin(), s_plans.end(), plan) - s_plans.begin();
}


/**
 * égalité de deux plans
 */
bool CPlan::operator==(const CPlan & o) const
{
   return m_i == o.m_i
           and m_colonne    == o.m_colonne
           and m_fuel       == o.m_fuel
           and m_fuel_tp1   == o.m_fuel_tp1
           and m_arcs       == o.m_arcs
           and m_reste      == o.m_reste;
}

bool CPlan::CArc::operator==(const CPlan::CArc & o) const
{
    return
            m_type          == o.m_type
            and m_k         == o.m_k
            and m_recharge  == o.m_recharge
            and m_depart    == o.m_depart
            and m_fin       == o.m_fin;
}

CPlan::CArc::CArc(const CNoeud & depart, const CNoeud & fin,
                  kWh _recharge, kWh _reste,
                  euros ui_prod, euros _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_ui_prod       = ui_prod           ;
    m_reste         = _reste            ;
}

CPlan::CPlan( powerplants2_t i, size_t taille_prod, powerplants2_t nb_centrales) {
    m_colonne = std::vector<kWh>( taille_prod + nb_centrales, (kWh)0 );
    m_colonne[ taille_prod + i ] = (kWh)1 ;
    m_fuel              = vector<kWh>( taille_prod, (kWh)0 ) ;
    m_fuel_tp1          = vector<kWh>( taille_prod, (kWh)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   = (euros)0 ;
    m_cout          = (euros)0 ;
    m_reste         = (kWh)0 ;
    m_id            = id++ ;
}

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


euros CPlan::recalcule_cout_reduit() const
{
    euros _ui_prod = CGraphe::V(m_i) * (kWh)1;
    for (week_t h; h!=H(); ++h)
        _ui_prod += CGraphe::u(h) * m_colonne[h];
    m_cout_reduit = m_cout - _ui_prod ;
    return m_cout_reduit ;
}

void CPlan::push_back( const CNoeud & dep, const CNoeud & fin,
                       kWh _recharge, kWh _reste,
                       euros _ui_prod, euros _cout )
{
    m_arcs.push_back(CArc(dep, fin, _recharge, _reste, _ui_prod, _cout ));
    m_ui_prod       += _ui_prod     ;
    m_cout          += _cout        ;
//     cout << "plan " << m_id << " : cout + " << _cout << endl ;
    m_reste = _reste ;
    if (fin.m_type==TYPE_DERNIER)
    {
        m_cout -= (CiTp1(m_i)*_reste);
//         cout << "plan " << m_id << " : cout - " << (CiTp1(m_i)*_reste) << endl ;
        // on fait comme si les V correspondaient à une production d'un kWh sur la semaine H+i
        m_cout_reduit = m_cout - m_ui_prod - CGraphe::V(m_i) * (kWh)1;
        // 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<kWh> & prod, vector<kWh> & stock, vector<kWh> & 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) {
            kWh 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<kWh> & prod, vector<kWh> & stock, vector<kWh> & demande_restante) const
{
    for (size_t arc_idx=0; arc_idx<m_arcs.size(); arc_idx++)
    {
        const 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<kWh> ideal ;
            timestep_t tdeb=week2timestep(depart.m_date);
            timestep_t tfin=week2timestep(fin.m_date);
#ifdef _DEBUG_BO_
            cout << "\nPowerplant " << m_i.v << " k:" << depart.m_campaign.v << " h:" << depart.m_date.v << endl ;
#endif
            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((kWh)-1,depart.m_fuel,depart.m_fuel) );
                for (timestep_t t=tdeb; t<tfin; ++t)
                {
#ifdef _DEBUG_BO_
                    cout << fixed << setprecision(10) << "(t=" << t << ",f0=" << liste_limits.back().f0
                            << ", f1=" << liste_limits.back().f1
                            << ", f2=" << liste_limits.back().f2
                            << std::endl ;
#endif
                    CIntervallesBO nouvelles_limites = type2(m_i).PBlimits(depart.m_campaign, t, liste_limits.back());
                    liste_limits.push_back( nouvelles_limites );
                }

                // il faut maintenant viser le début de l'arc suivant
                kWh 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) {
                    kWh 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)
                {
#ifdef _DEBUG_BO_
                    cout << fixed << setprecision(10) << "(t=" << t << ",f=" << ideal.back();
#endif
                    kWh prod = type2(m_i).PB(arc.m_depart->m_campaign, t, ideal.back());
                    ideal.push_back(ideal.back()-prod) ;
#ifdef _DEBUG_BO_
                    cout << ",prod=" << prod << ", pow="<< prod/D() << ")\n";
#endif
                }
#ifdef _DEBUG_BO_
                cout << endl;
#endif
                ideal.pop_front();
            }
            // on repart en avant
            kWh fuel = depart.m_fuel ;
            for (timestep_t t=tdeb; t<tfin; ++t)
            {
                stock[t] = fuel ;
                kWh p_ideal = fuel - ideal.front(); ideal.pop_front();
                prod[t] = p_ideal ;
                fuel -= prod[t] ;
                demande_restante[t] -= prod[t] ;
            }
        }
    }
}

void CPlan::remplis_min_max( std::vector<kWh> & min, std::vector<kWh> & max) const
{
    // remplissage des outages (prod=0)
    min = vector<kWh>(T(), (kWh)0);
    // remplissage des BO (max=min)
    vector<kWh> stock(T()), reste(T());
    remplis_BO_en_visant_bien(min, stock, reste);
    max = min ;
    // remplissage hors BO et outages (min=0, max=EMAX)
    for (size_t arc_idx=0; arc_idx<m_arcs.size(); arc_idx++)
    {
        const CPlan::CArc & arc = m_arcs[arc_idx] ;
        if (arc.m_depart->m_type != TYPE_BO)
            for (timestep_t t=week2timestep(arc.m_depart->m_date_campaign);
                 t<week2timestep(arc.m_fin->m_date);
                 ++t)
            {
                max[t] = EMAX(m_i,t);
            }
    }
}

vector<const CPlan::CArc *> CPlan::arcs_non_BO() const
{
    vector<const CPlan::CArc *> retour ;
    for (size_t arc_idx=0; arc_idx<m_arcs.size(); arc_idx++)
    {
        const CPlan::CArc & arc = m_arcs[arc_idx] ;
        if (arc.m_depart->m_type != TYPE_BO)
            retour.push_back(&arc);
    }
    return retour;
}



void CPlan::remplis_campagnes_non_BO( vector<kWh> & prod, vector<kWh> & stock, vector<kWh> & demande_restante) const
{
    for (size_t arc_idx=0; arc_idx<m_arcs.size(); arc_idx++)
    {
        const 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] = (kWh) 0 ;

            for (++t; t<week2timestep(arc.m_depart->m_date_campaign) and t<week2timestep(arc.m_fin->m_date); ++t) {
                stock[t] = arc.m_depart->m_fuel_avant_refuel + arc.m_recharge ;
                prod[t]  = (kWh) 0 ;
            }
        }
        // remplissage des campagnes de production non BO
        if (arc.m_depart->m_type != TYPE_BO) {
            kWh 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)==(kWh)0 ? (coeff_t)1 : EMAX(m_i,t) / EMAX(m_i,h));
                    fuel    -= prod[t] ;
                    demande_restante[t] -= prod[t] ;
                }
            }
        }
    }
}

/**
 * perte de fuel lors d'un refuel
 * @param i index de la centrale
 * @param kmoins1 campagne en cours avant l'outage
 * @param k campagne de l'outage
 * @param x niveau de fuel avant l'outage
 * @return
 */
inline kWh perte_refuel( powerplants2_t i, campaign_t k, kWh x )
{
    return BO(i,(campaign_t)(k-1)) * ((Q(i,k)-(coeff_t)1)/Q(i,k)) - BO(i,k) + x / Q(i,k) ;
}

vector<kWh> CPlan::remplis_stock( const vector<kWh> & prod, const vector<kWh> & recharges ) const
{
    vector<kWh> stock(T()+(tlen_t)1);

    // stock de départ
    stock[0] = m_arcs[0].m_depart->m_fuel;
    // parcours des arcs
    for (size_t arc_idx=0; arc_idx<m_arcs.size(); arc_idx++)
    {
        const CArc & arc = m_arcs[arc_idx] ;
        timestep_t t = week2timestep(arc.m_depart->m_date)+(tlen_t)1 ;
        if (arc.m_depart->m_type==TYPE_OUTAGE) {
            stock[t] = stock[t-(tlen_t)1]
                    - perte_refuel(m_i, arc.m_depart->m_campaign, stock[t-(tlen_t)1])
                    + recharges[arc.m_depart->m_campaign] ;
        } else {
            stock[t]  = stock[t-(tlen_t)1] - prod[t-(tlen_t)1];
        }
        for (; t<week2timestep(arc.m_fin->m_date); ++t) {
            stock[t+(tlen_t)1] =  stock[t] - prod[t];
	    //cout << "(" << m_i << "," << t << " : " << stock[t] << "," << prod[t] << "->" << stock[t+(tlen_t)1] << " ";
        }
	//cout << endl;
    }

    return stock;
}

void CPlan::remplis_dates_outages( std::vector<week_t> & dates ) const
{
    for (size_t arc_idx=0; arc_idx<m_arcs.size(); arc_idx++)
    {
        const 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<kWh> & recharges ) const
{
    for (size_t arc_idx=0; arc_idx<m_arcs.size(); arc_idx++)
    {
        const 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 - a.m_ui_prod << "\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 << " " << (coeff_t)1-(plan.m_colonne[h]==(kWh)0 ? (coeff_t)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 ;
}