#ifndef DA_H_INCLUDED
#define DA_H_INCLUDED

#include <iostream>
#include <vector>
#include <string>

#include <stdio.h>
#include <cmath>

#include <algorithm>

#include <stdlib.h>
#include <fstream>
#include "../instance/indices.h"
#include "../instance/cinstance.h"
#include "../instance/cinstancereduite.h"
#include "cgraphe.h"
#include "cplan.h"
#include "clique.h"
#include "../cplx/cplex.h"

using namespace std;
class Cplex;

class DualAscent {
    public :

    // Matrice A de taille 260 + 51 X nombre de colonnes
    vector< vector<double> * > A ;
    vector<vector<double> > recharge; //recharge[col][k] = quantité refuelée à la k-ème campagne, sur la col-ième colonne
    double a(int i, int j) const { return (*A[i])[j];}

    // vecteur de cout des colonnes
    vector<double> cost ;

    // fuel remaining
    vector<double> reste; // reste[col] = fuel restant en fin de scénar

    // vecteur de demande de production + affectation des colonnes
    vector<double> b ;

    // fonction
    DualAscent(vector<double>  dem, powerplants2_t nb_centrales)
    {
        b = dem ;
        b.resize( dem.size() + nb_centrales , 1 );

        double coutTherm = 0;

        for (week_t i=(week_t) 0;i<H();i=(week_t) (i+1) )
        {
            coutTherm += b[i]*CInstanceReduite::ThCout(i);
        }
        std::vector<CPlan::CArc> vide;
        ajoutcolonne(&b, coutTherm, vide, 0);
    }

    // destructeur
    ~DualAscent() {}

    protected:
    void ajoutcolonne( vector<double> * colonne, double cou, std::vector<CPlan::CArc>& arcs, double resteCol )
    {
        A.push_back(colonne);
        cost.push_back(cou);
        vector<double> quantiteRefuelee;
        for ( int i=0 ; i < arcs.size() ; i++ )
        {
            if ( arcs[i].m_type == TYPE_OUTAGE )
            {
                quantiteRefuelee.push_back(arcs[i].m_recharge);
            }
        }
        recharge.push_back(quantiteRefuelee);
        reste.push_back(resteCol);
    }

   public:
    void ajoutcolonne(CPlan* cplan){
        Clique::ajoutcolonne(cplan, A.size());
        ajoutcolonne(&cplan->m_colonne, cplan->m_cout, cplan->m_arcs, cplan->m_reste);
    }

//    void print();

    void boucle(vector<double>& u, vector <double> & lambda, bool& BorneSup, const char*x=NULL)  const;// Fonction à appeler calcul des Ui Vi

    private:

        vector<double> calculePoids() const;

        vector<double> DAcalc (const vector<double> & ,vector<double> &, const vector<double> &) const;

//        vector <int> EcritureCplex(const vector <double> &, const char *) const;

//        double updateLambda(const vector<double> &, vector<double> &,const vector <double> &, double ) const;

        vector<double> sousgrad(vector<double> &, const vector<double> &,const vector<double> &,
                                const vector<double> &,const vector<double> &) const;

        // operateur binaire
//        bool epsiqual( const double &, const double &) const;

        // Recherche de borne sup upper bound
        bool testUB () const ;
        double recherche_UB () const ;

        /**
         * Supprime la colonne correspondant à la centrale thermique.
         * À n'appeler qu'une unique fois, juste après la génération de colonne,
         * et juste avant la préparation des données pour CPlex
         *
         * Appelé par la classe CPlex
         */
         public:
        void vireColonneThermique();
        //friend Cplex::Cplex(DualAscent& ); //TODO : faire que ça marche, pour pouvoir privater la méthode précédente
        
        //temp : méthode de debug
        void testL(const vector<double>& L, const string& mes) const
        {
        	for ( int i=0 ; i < L.size() ; i++ )
        	{
        		if ( !isfinite(L[i]) || L[i]!=L[i] )
        		{
        			cerr<<mes<<endl;
        			cerr<<"L["<<i<<"] = "<<L[i]<<endl;
        			exit(-1);
        		}
        	}
        }

};

#endif // DA_H_INCLUDED