#include "cplex.h"
#include <algorithm>

#ifdef DEBUG_CPLEX
#define DEBUG_CPLEX_PRINT(a) std::cout<<a<<std::endl;
#else
#define DEBUG_CPLEX_PRINT(a)
#endif

/**
 * Constructeur utilisé à des fins de debug
 */
//Cplex::Cplex(int nbCol, int nbCentrales, int nbSem)
Cplex::Cplex(int nbCol, week_t nbSem) : nbColonnes(nbCol), nbSemaines(nbSem)
{
/*
  Traitement des attributs hors clique
    //Allocation dynamique
    nbColonnes = nbCol; // nombre de colonnes
    nbCentraleNucl = nbCentrales;
    nbSemaines = nbSem;
    cl = new double[nbColonnes]; //cout des colonnes. Taille = nb colonnes
    ct = new double[nbSemaines]; //cout unitaire prod thermique. Taille = nb semaines
    dt = new double[nbSemaines]; //Demande (vecteur b) ; partie production. Taille = nb semaines
    mint = new double[nbSemaines]; //Prod thermique min. Taille  = nb semaines
    maxt = new double[nbSemaines]; // prod thermique max. Taille = nb semaines
    affect = new int*[nbColonnes];
    dlt = new double*[nbColonnes]; //matrice A ; partie production. Taille = nbColonnes x nbSemaines

    //Initialisation
    for ( int i=0 ; i < nbColonnes ; i++ ){
        cl[i] = da.cost[i];
        for( week_t w = (week_t) 0; w<nbSemaines; w=(week_t) (w+1) )
        {
            ct[w] = CInstanceReduite::ThCout(w);
            dt[w] = da.b[w];
            mint[w] = CInstanceReduite::ThProdMin(w);
            maxt[w] = CInstanceReduite::ThProdMax(w);
            dlt[i][w] = da.a(i,w);
            affect[i][w] = da.a(i,w+I() );
        }
    }

    /* Traitement des cliques
    //On travaille sur des vector, puis on copiera dans des tableaux pour appeler Cplex
    vector<vector<int> > vclique(nbColonnes);
    vector<int> vbc;
    contrainte14 ( vclique, vbc);
//*/
}

Cplex::Cplex(const DualAscent& da)
{
    /* Traitement des attributs hors clique */
    //Allocation dynamique
    nbColonnes = da.cost.size(); // nombre de colonnes
    DEBUG_CPLEX_PRINT("nbColonnes : "<<nbColonnes);
    nbCentraleNucl = I();
    DEBUG_CPLEX_PRINT("nbCentraleNucl : "<<nbCentraleNucl);
    nbSemaines = H();
    DEBUG_CPLEX_PRINT("nbSemaines : "<<nbSemaines);
    cl = new double[nbColonnes]; //cout des colonnes. Taille = nb colonnes
    DEBUG_CPLEX_PRINT("cl alloué, taille : "<<nbColonnes);
    ct = new double[nbSemaines]; //cout unitaire prod thermique. Taille = nb semaines
    DEBUG_CPLEX_PRINT("ct alloué, taille : "<<nbSemaines);
    dt = new double[nbSemaines]; //Demande (vecteur b) ; partie production. Taille = nb semaines
    DEBUG_CPLEX_PRINT("dt alloué, taill : "<<nbSemaines);
    mint = new double[nbSemaines]; //Prod thermique min. Taille  = nb semaines
    DEBUG_CPLEX_PRINT("mint : "<<nbSemaines);
    maxt = new double[nbSemaines]; // prod thermique max. Taille = nb semaines
    DEBUG_CPLEX_PRINT("maxt : "<<nbSemaines);
    affect = new int*[nbColonnes];
    DEBUG_CPLEX_PRINT("affect : "<<nbColonnes);
    dlt = new double*[nbColonnes]; //matrice A ; partie production. Taille = nbColonnes x nbSemaines
    DEBUG_CPLEX_PRINT("dlt : "<<nbColonnes);

    //Initialisation
    for ( int i=0 ; i < nbColonnes ; i++ ){
        cl[i] = da.cost[i];
        for( week_t w = (week_t) 0; w<nbSemaines; w=(week_t) (w+1) )
        {
            ct[w] = CInstanceReduite::ThCout(w);
            dt[w] = da.b[w];
            mint[w] = CInstanceReduite::ThProdMin(w);
            maxt[w] = CInstanceReduite::ThProdMax(w);
            dlt[i][w] = da.a(i,w);
            affect[i][w] = da.a(i,w+I() );
        }
    }

    /* Traitement des cliques */
    //On travaille sur des vector, puis on copiera dans des tableaux pour appeler Cplex
    vector<vector<int> > vclique(nbColonnes);
    vector<int> vbc;
    contrainte14 ( vclique, vbc);


}

void Cplex::contrainte14 (std::vector<std::vector<int> >& vclique, std::vector<int>& vbc)
{
    #ifdef TEST_CC14
    for ( int subset=0 ; subset < 1 ; subset++ )
    #else
    for ( int subset=0 ; subset < CInstance::M((constraint_t) 14) ; subset++ )
    #endif
    {
        #ifdef TEST_CC14
        vector<powerplants2_t> test; test.push_back((powerplants2_t) 0);
        test.push_back((powerplants2_t) 1);test.push_back((powerplants2_t) 2);
        vector<powerplants2_t> centralesDuSubset = test;
        wlen_t Se = (wlen_t) 1;
        #else
        vector<powerplants2_t> centralesDuSubset = CInstance::m_constraints14[subset].C();
        wlen_t Se = CInstance::m_constraints14[subset].Se() ;
        #endif
        int nbCentralesDuSubset = centralesDuSubset.size();

        for ( powerplants2_t i=(powerplants2_t) 0 ; i < nbCentralesDuSubset ; i = (powerplants2_t) (i+1) )
        {
            DEBUG_CPLEX_PRINT("powerplant i "<<i<<"/"<<nbCentralesDuSubset);
            int idx_i = centralesDuSubset[i];
            for ( powerplants2_t iprime= (powerplants2_t) 0 ; iprime < nbCentralesDuSubset ; iprime = (powerplants2_t) (iprime+1) )
            {
                DEBUG_CPLEX_PRINT("\tpowerplant iprime "<<iprime<<"/"<<nbCentralesDuSubset);
                if ( i == iprime ){
                    continue;
                }
                int idx_iprime = centralesDuSubset[iprime];

                for (  int i_colonne=0 ; i_colonne < (int) Clique::annuaire[idx_i].size() ; i_colonne++ )
                {
                    DEBUG_CPLEX_PRINT("\t\tcolonne i "<<i_colonne<<"/"<<Clique::annuaire[idx_i].size());
                    int idx_colonne = Clique::annuaire[idx_i][i_colonne];
                    for (  int i_colonneprime=0 ; i_colonneprime < (int) Clique::annuaire[idx_iprime].size() ; i_colonneprime++ )
                    {
                        DEBUG_CPLEX_PRINT("\t\t\tcolonne iprime "<<i_colonneprime<<"/"<<Clique::annuaire[idx_iprime].size());
                        int idx_colonneprime = Clique::annuaire[idx_iprime][i_colonneprime];
                        DEBUG_CPLEX_PRINT("\t\t\tidx_colonneprime "<<idx_colonneprime<<"/"<<nbColonnes);
                        for ( int k=0 ; k <(int) Clique::dateDebutOutageCampagneK[idx_colonne].size() ; k++ )
                        {
                            DEBUG_CPLEX_PRINT("\t\t\t\tk "<<k<<"/"<<Clique::dateDebutOutageCampagneK[idx_colonne].size());
                            for ( int kprime=0 ; kprime < (int) Clique::dateDebutOutageCampagneK[idx_colonneprime].size() ; kprime++ )
                            {
                                DEBUG_CPLEX_PRINT("\t\t\t\t\tkprime "<<kprime<<"/"<<Clique::dateDebutOutageCampagneK[idx_colonneprime].size());
                                if ( (Clique::dateDebutOutageCampagneK[idx_colonne][k] - Clique::dateFinOutageCampagneK[idx_colonneprime][kprime] < Se)
                                    && (Clique::dateDebutOutageCampagneK[idx_colonneprime][kprime] - Clique::dateFinOutageCampagneK[idx_colonne][k] < Se) )
                                {
                                    DEBUG_CPLEX_PRINT("\t\t\t\t\t Ajout d'une contrainte");
                                    vector<int> contrainte(nbColonnes, 0);
                                    contrainte[idx_colonne] = contrainte[idx_colonneprime] = 1;
                                    vclique.push_back(contrainte);
                                    vbc.push_back(1);
                                    DEBUG_CPLEX_PRINT("\t\t\t\t\t Fin de l'ajout de la contrainte");
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

void Cplex::contrainte15(vector<vector<int> >& vclique, vector<int>& vbc)
{
    for ( int subset=0 ; subset < CInstance::M((constraint_t) 15) ; subset++ )
    {
        vector<powerplants2_t> centralesDuSubset = CInstance::m_constraints15[subset].C();
        wlen_t Se = CInstance::m_constraints15[subset].Se() ;
        week_t IDm = CInstance::m_constraints15[subset].ID() ;
        week_t IFm = CInstance::m_constraints15[subset].IF() ;

        int nbCentralesDuSubset = centralesDuSubset.size();

        for ( powerplants2_t i=(powerplants2_t) 0 ; i < nbCentralesDuSubset ; i = (powerplants2_t) (i+1) )
        {
            int idx_i = centralesDuSubset[i];
            for ( powerplants2_t iprime= (powerplants2_t) 0 ; iprime < nbCentralesDuSubset ; iprime = (powerplants2_t) (iprime+1) )
            {
                if ( i == iprime ){
                    continue;
                }
                int idx_iprime = centralesDuSubset[iprime];

                for (  int i_colonne=0 ; i_colonne < Clique::annuaire[idx_i].size() ; i_colonne++ )
                {
                    int idx_colonne = Clique::annuaire[idx_i][i_colonne];
                    for (  int i_colonneprime=0 ; i_colonneprime < Clique::annuaire[idx_iprime].size() ; i_colonneprime++ )
                    {
                        int idx_colonneprime = Clique::annuaire[idx_iprime][i_colonneprime];
                        for ( int k=0 ; k < Clique::dateDebutOutageCampagneK[idx_colonne].size() ; k++ )
                        {
                            for ( int kprime=0 ; kprime < Clique::dateDebutOutageCampagneK[idx_colonneprime].size() ; kprime++ )
                            {
                                int DAk = CInstance::type2((powerplants2_t) idx_i).DA((campaign_t) k);
                                int DAkprime = CInstance::type2((powerplants2_t) idx_iprime).DA((campaign_t) kprime);
                                // Ajout du test pour valider la contrainte
                                if (    (IDm - DAk+1 <=Clique::dateDebutOutageCampagneK[idx_colonne][k])
                                        &&( Clique::dateDebutOutageCampagneK[idx_colonne][k]<= IFm )
                                        &&(IDm - DAkprime+1 <=Clique::dateDebutOutageCampagneK[idx_colonneprime][kprime])
                                        &&( Clique::dateDebutOutageCampagneK[idx_colonneprime][kprime]<= IFm ) )
                                {
                                    if ( (Clique::dateDebutOutageCampagneK[idx_colonne][k] - Clique::dateFinOutageCampagneK[idx_colonneprime][kprime] < Se)
                                        && (Clique::dateDebutOutageCampagneK[idx_colonneprime][kprime] - Clique::dateFinOutageCampagneK[idx_colonne][k] < Se) )
                                    {
                                        vector<int> contrainte(nbColonnes, 0);
                                        contrainte[idx_colonne] = contrainte[idx_colonneprime] = 1;
                                        vclique.push_back(contrainte);
                                        vbc.push_back(1);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

void Cplex::contrainte16(vector<vector<int> >& vclique, vector<int>& vbc)
{
    for ( int subset=0 ; subset < CInstance::M((constraint_t) 16) ; subset++ )
    {
        vector<powerplants2_t> centralesDuSubset = CInstance::m_constraints16[subset].C();
        wlen_t Se = CInstance::m_constraints16[subset].Se() ;
        int nbCentralesDuSubset = centralesDuSubset.size();

        for ( powerplants2_t i=(powerplants2_t) 0 ; i < nbCentralesDuSubset ; i = (powerplants2_t) (i+1) )
        {
            int idx_i = centralesDuSubset[i];
            for ( powerplants2_t iprime= (powerplants2_t) 0 ; iprime < nbCentralesDuSubset ; iprime = (powerplants2_t) (iprime+1) )
            {
                if ( i == iprime ){
                    continue;
                }
                int idx_iprime = centralesDuSubset[iprime];

                for (  int i_colonne=0 ; i_colonne < Clique::annuaire[idx_i].size() ; i_colonne++ )
                {
                    int idx_colonne = Clique::annuaire[idx_i][i_colonne];
                    for (  int i_colonneprime=0 ; i_colonneprime < Clique::annuaire[idx_iprime].size() ; i_colonneprime++ )
                    {
                        int idx_colonneprime = Clique::annuaire[idx_iprime][i_colonneprime];
                        for ( int k=0 ; k < Clique::dateDebutOutageCampagneK[idx_colonne].size() ; k++ )
                        {
                            for ( int kprime=0 ; kprime < Clique::dateDebutOutageCampagneK[idx_colonneprime].size() ; kprime++ )
                            {
                                if ( abs(Clique::dateDebutOutageCampagneK[idx_colonne][k] - Clique::dateDebutOutageCampagneK[idx_colonneprime][kprime]) < Se)
                                {
                                    vector<int> contrainte(nbColonnes, 0);
                                    contrainte[idx_colonne] = contrainte[idx_colonneprime] = 1;
                                    vclique.push_back(contrainte);
                                    vbc.push_back(1);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

void Cplex::contrainte17(vector<vector<int> >& vclique, vector<int>& vbc)
{
    for ( int subset=0 ; subset < CInstance::M((constraint_t) 17) ; subset++ )
    {
        vector<powerplants2_t> centralesDuSubset = CInstance::m_constraints17[subset].C();
        wlen_t Se = CInstance::m_constraints17[subset].Se() ;
        int nbCentralesDuSubset = centralesDuSubset.size();

        for ( powerplants2_t i=(powerplants2_t) 0 ; i < nbCentralesDuSubset ; i = (powerplants2_t) (i+1) )
        {
            int idx_i = centralesDuSubset[i];
            for ( powerplants2_t iprime= (powerplants2_t) 0 ; iprime < nbCentralesDuSubset ; iprime = (powerplants2_t) (iprime+1) )
            {
                if ( i == iprime ){
                    continue;
                }
                int idx_iprime = centralesDuSubset[iprime];

                for (  int i_colonne=0 ; i_colonne < Clique::annuaire[idx_i].size() ; i_colonne++ )
                {
                    int idx_colonne = Clique::annuaire[idx_i][i_colonne];
                    for (  int i_colonneprime=0 ; i_colonneprime < Clique::annuaire[idx_iprime].size() ; i_colonneprime++ )
                    {
                        int idx_colonneprime = Clique::annuaire[idx_iprime][i_colonneprime];
                        for ( int k=0 ; k < Clique::dateDebutOutageCampagneK[idx_colonne].size() ; k++ )
                        {
                            for ( int kprime=0 ; kprime < Clique::dateDebutOutageCampagneK[idx_colonneprime].size() ; kprime++ )
                            {
                                if ( abs(Clique::dateFinOutageCampagneK[idx_colonne][k] - Clique::dateFinOutageCampagneK[idx_colonneprime][kprime]) < Se)
                                {
                                    vector<int> contrainte(nbColonnes, 0);
                                    contrainte[idx_colonne] = contrainte[idx_colonneprime] = 1;
                                    vclique.push_back(contrainte);
                                    vbc.push_back(1);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}


void Cplex::contrainte18(vector<vector<int> >& vclique, vector<int>& vbc)
{
    for ( int subset=0 ; subset < CInstance::M((constraint_t) 18) ; subset++ )
    {
        vector<powerplants2_t> centralesDuSubset = CInstance::m_constraints18[subset].C();
        wlen_t Se = CInstance::m_constraints18[subset].Se() ;
        int nbCentralesDuSubset = centralesDuSubset.size();

        for ( powerplants2_t i=(powerplants2_t) 0 ; i < nbCentralesDuSubset ; i = (powerplants2_t) (i+1) )
        {
            int idx_i = centralesDuSubset[i];
            for ( powerplants2_t iprime= (powerplants2_t) 0 ; iprime < nbCentralesDuSubset ; iprime = (powerplants2_t) (iprime+1) )
            {
                if ( i == iprime ){
                    continue;
                }
                int idx_iprime = centralesDuSubset[iprime];

                for (  int i_colonne=0 ; i_colonne < Clique::annuaire[idx_i].size() ; i_colonne++ )
                {
                    int idx_colonne = Clique::annuaire[idx_i][i_colonne];
                    for (  int i_colonneprime=0 ; i_colonneprime < Clique::annuaire[idx_iprime].size() ; i_colonneprime++ )
                    {
                        int idx_colonneprime = Clique::annuaire[idx_iprime][i_colonneprime];
                        for ( int k=0 ; k < Clique::dateDebutOutageCampagneK[idx_colonne].size() ; k++ )
                        {
                            for ( int kprime=0 ; kprime < Clique::dateDebutOutageCampagneK[idx_colonneprime].size() ; kprime++ )
                            {
                                if ( abs(Clique::dateFinOutageCampagneK[idx_colonne][k] - Clique::dateDebutOutageCampagneK[idx_colonneprime][kprime]) < Se)
                                {
                                    vector<int> contrainte(nbColonnes, 0);
                                    contrainte[idx_colonne] = contrainte[idx_colonneprime] = 1;
                                    vclique.push_back(contrainte);
                                    vbc.push_back(1);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

void Cplex::contrainte19(vector<vector<int> >& vclique, vector<int>& vbc)
{
    for ( int c19=0 ; c19 < 1 /*CInstance::M((constraint_t) 19)*/ ; c19++ )
    {
        #ifdef TEST_CC19
        vector<powerplants2_t> test; test.push_back((powerplants2_t) 0);
        test.push_back((powerplants2_t) 1);test.push_back((powerplants2_t) 2);
        vector<powerplants2_t> centralesDuSubset = test;
        vector<vector<int> > utilisationRessource (10, vector<int> (Cplex::nbColonnes, 0) ) ;// utilisationRessource[w][c] si la colonne c utilise la ressource
        int nbCentralesDuSubset = centralesDuSubset.size();
        int nbRessources = 2;
        #else
        vector<powerplants2_t> centralesDuSubset = CInstance::m_constraints19[c19].C();
        vector<vector<int> > utilisationRessource (CInstance::H(), vector<int> (Cplex::nbColonnes, 0) ) ;// utilisationRessource[w][c] si la colonne c utilise la ressource
        int nbCentralesDuSubset = centralesDuSubset.size();
        int nbRessources = CInstance::m_constraints19[c19].Q();
        #endif

        for ( int i= 0 ; i < nbCentralesDuSubset ; i++ )
        {
            powerplants2_t idx_i = centralesDuSubset[i];
            for (  int i_colonne=0 ; i_colonne < Clique::annuaire[(int) idx_i].size() ; i_colonne++ )
            {
                int idx_colonne = Clique::annuaire[idx_i][i_colonne];
                for ( campaign_t k=(campaign_t) 0 ; k < Clique::dateDebutOutageCampagneK[idx_colonne].size() ; k=(campaign_t) (k+1) )
                {
                    #ifdef TEST_CC19
                    int start = 0;
                    int duree = 2;
                    #else
                    int start = CInstance::m_constraints19[c19].L(idx_i,k);
                    int duree = CInstance::m_constraints19[c19].TU(idx_i,k);
                    #endif
                    for ( int w=0 ; (w<duree )&& ((w+start+Clique::dateDebutOutageCampagneK[idx_colonne][k])<nbSemaines) ; w++ )
                    {
                        utilisationRessource[w+start+Clique::dateDebutOutageCampagneK[idx_colonne][k]][idx_colonne] = 1;
                    }
                }
            }
        }

#ifdef TEST_CC19
        for ( week_t w=(week_t) 0 ; w < 10 ; w = (week_t) (w+1) )
#else
        for ( week_t w=(week_t) 0 ; w < CInstance::H() ; w = (week_t) (w+1) )
#endif
        {
            int compteur = 0;
            for ( int col=0 ; col < nbColonnes ; col++ )
            {
                compteur += utilisationRessource[w][col];
            }

            //S'il y a une limite à ce pas de temps, ajouter la contrainte à vclique
            if ( compteur > nbRessources )
            {
                vclique.push_back(utilisationRessource[w]);
                vbc.push_back(nbRessources);
            }
        }
    }
}

Cplex::~Cplex()
{
#ifndef TEST_CC14
#ifndef TEST_CC19
    DEBUG_CPLEX_PRINT("deletage de cl");
    delete[] cl;
    DEBUG_CPLEX_PRINT("deletage de ct");
    delete[] ct;
    DEBUG_CPLEX_PRINT("deletage du contenu de dlt, affect et clique");
    for ( int i=0 ; i < nbColonnes ; i++ ){
        delete[] dlt[i];
        delete[] affect[i];
        delete[] clique[i];
    }
    DEBUG_CPLEX_PRINT("deletage de dlt");
    delete[] dlt;
    DEBUG_CPLEX_PRINT("deletage de affect");
    delete[] affect;
    DEBUG_CPLEX_PRINT("deletage de clique");
    delete[] clique;
    DEBUG_CPLEX_PRINT("deletage de dt");
    delete[] dt;
    DEBUG_CPLEX_PRINT("deletage de mint");
    delete[] mint;
    DEBUG_CPLEX_PRINT("deletage de maxt");
    delete[] maxt;
    DEBUG_CPLEX_PRINT("deletage de bc");
    delete[] bc;
#endif
#endif
}