#ifndef CPLAN_H
#define CPLAN_H

#include <map>
#include <indices.h>

struct CNoeud ;
struct CGraphe;

// types de campagne de production
enum noeud_t { TYPE_PREMIER, TYPE_OUTAGE, TYPE_BO, TYPE_DERNIER } ;
#define TYPE(X) (X==TYPE_PREMIER ? "PREMIER" : X==TYPE_OUTAGE ? "OUTAGE" : X==TYPE_BO ? "BO" : X==TYPE_DERNIER ? "DERNIER" : "ERREUR")


/**
	@author Antoine Rozenknop <antoine.rozenknop@lipn.univ-paris13.fr>
*/
struct CPlan {
    friend std::ostream & operator <<(std::ostream & out, CPlan & plan) ;
    static int id ;

    struct CArc {
        CArc(const CNoeud & depart, const CNoeud & fin,
             kWh _recharge, kWh _reste,
             euros _cout_reduit, euros _cout);
        noeud_t     m_type          ;
        campaign_t  m_k             ;
        week_t      m_date          ;
        week_t      m_date_fin      ;
        kWh         m_recharge      ;
        euros       m_cout          ;
//         euros       m_cout_reduit   ;
        euros       m_ui_prod       ;
        kWh         m_reste         ;
        const CNoeud *    m_depart        ;
        const CNoeud *    m_fin           ;
        /// opérateur d'égalité pour vérifier si un plan est déjà présent
        bool operator==(const CArc & o) const;
    };

    CPlan( powerplants2_t i, size_t taille_prod, powerplants2_t nb_centrales);

    void set_prod( size_t index, kWh prod ) ;

    void push_back( size_t arc_idx, const CNoeud & dep, const CNoeud & fin,
                    kWh _recharge, kWh _reste,
                    euros _cout_reduit, euros _cout );

    static void libere_plan(CPlan * plan);
    static void libere_plan(size_t plan) {libere_plan(s_plans[plan]);}

    euros recalcule_cout_reduit() const;

    week_t ha(campaign_t k) const { return m_ha[k] ; }
    kWh    recharge(campaign_t k) const { return m_recharges[k]; }
    campaign_t K() const { return campaign_t(m_ha.size()); }


    // création des plans finaux
    void remplis_BO(std::vector<kWh> & prod, std::vector<kWh> & stock, std::vector<kWh> & demande_restante);
    void remplis_BO_en_visant_bien(std::vector<kWh> & prod, std::vector<kWh> & stock, std::vector<kWh> & demande_restante) const;
    void remplis_campagnes_non_BO( std::vector<kWh> & prod, std::vector<kWh> & stock, std::vector<kWh> & demande_restante) const;
    void remplis_dates_outages( std::vector<week_t> & dates ) const;
    void remplis_recharges( std::vector<kWh> & recharges ) const;
    void remplis_min_max( std::vector<kWh> & min, std::vector<kWh> & max) const;
    std::vector<kWh> remplis_stock( const std::vector<kWh> & prod, const std::vector<kWh> & recharges ) const ;
    std::vector<const CArc *> arcs_non_BO() const;

    // affichage des coûts des arcs plan
    std::string str_couts_arcs(const CGraphe * graphe) const  ;

    powerplants2_t      m_i             ;
    std::vector<kWh>    m_colonne       ;
    std::vector<kWh>    m_fuel          ;
    std::vector<kWh>    m_fuel_tp1      ;
    std::vector<CArc>   m_arcs          ;
    std::vector<size_t> m_arcs_idx      ;
    euros               m_cout          ;
    euros               m_ui_prod       ;
    mutable euros       m_cout_reduit   ;
    kWh                 m_reste         ;
    std::vector<week_t> m_ha            ;
    std::vector<kWh>    m_recharges     ;
    int                 m_id            ;

private:
    /// table des plans retenus
    static std::vector<CPlan *> s_plans;
    /// plans_centrale[i] = ensemble des index dans s_plans des plans relatifs à la centrale i
    static std::vector<std::vector<size_t> > s_plans_centrale;
    /// plan déjà existant trouvé dans retiens_plan
    static size_t s_plan_existant ;

public:
    /// retiens un plan
    static bool retiens_plan(CPlan * p, bool meme_si_deja_present=true);
    /// plan existant trouvé dans retiens_plan
    static size_t plan_existant();
    /// opérateur d'égalité pour vérifier si un plan est déjà présent
    bool operator==(const CPlan & o) const;
    /// liste des index dans s_plans des plans retenus pour une centrale
    static const std::vector<size_t> & plans_centrale(powerplants2_t i) {return s_plans_centrale[i];}
    /// renvoie un plan
    static const CPlan * getPlan(size_t index) {return s_plans[index];}
    static size_t findIndex(const CPlan *);

    /// nombre de plans retenus
    static size_t getNbPlans() { return s_plans.size(); }
    /// libération
    static void libere_plans();
};

std::ostream & operator <<(std::ostream & out, CPlan & plan) ;

#endif