#include "cplexmutable.h"
#include <iostream>
#include <fstream>
#include <sstream>
#include <limits>

// #define CPLEX_WITH_NAMES

#define INFINI (std::numeric_limits<double>::infinity())

using namespace std ;

inline std::string operator+ (const std::string & prefix, int n)
{
    std::ostringstream out;
    out << n ;
    return prefix + out.str();
}


CPlexMutable::CPlexMutable(std::string nom, ObjectiveSense obj_sense, ProblemType type,
                           bool internal_silent, bool silent,  bool writeToFile, bool with_names)
 : CPlexModel(nom,obj_sense,type,internal_silent,silent,writeToFile,with_names)
{
    init() ;
}

void CPlexMutable::init()
{
#ifndef NO_CPLEX
    int         status  = 0;

    /* If an error occurs, the status value indicates the reason for
    failure.  A call to CPXgeterrorstring will produce the text of
    the error message.  Note that CPXopenCPLEX produces no output,
    so the only way to see the cause of the error is to use
    CPXgeterrorstring.  For other CPLEX routines, the errors will
    be seen if the CPX_PARAM_SCRIND indicator is set to CPX_ON.  */

    /* Initialize the CPLEX environment */
    env = CPXopenCPLEX ( &status );
    if ( env == NULL )
        throw CPlexFailed("Could not open CPLEX environment.", env, status);

    /* Turn on/off output to stdout */
    status = CPXsetintparam ( env, CPX_PARAM_SCRIND, (cpx_internal_silent ? CPX_OFF : CPX_ON) );
    if ( status )
        throw CPlexFailed("Failure to set screen indicator.", env, status);


    /* Create the problem. */

    /* A returned pointer of NULL may mean that not enough memory
    was available or there was some other problem.  In the case of
    failure, an error message will have been written to the error
    channel from inside CPLEX.*/
    lp = CPXcreateprob ( env, &status, cpx_probname.c_str() );
    if ( lp == NULL )
        throw CPlexFailed("Failed to create LP.", env, status);

    status = CPXchgprobtype(env, lp, cpx_problemtype);
    if ( status )
        throw CPlexFailed("Failure to set problem type.", env, status);
#endif

    setOption( None );
}

void CPlexMutable::reinit()
{

    for (size_t i=0; i<m_noms_variables.size()  ; i++) delete [] m_noms_variables[i];
    for (size_t i=0; i<m_noms_contraintes.size(); i++) delete [] m_noms_contraintes[i];
    FreeCplex();
    cpx_numrows     = 0 ;
    cpx_numcols     = 0 ;
    cpx_solvedcols  = 0 ;
    m_debut_zoneH   = 0 ;
    m_debut_zoneV   = 0 ;
    m_zoneVerticale.clear()         ;
    m_zoneHorizontale.clear()       ;
    m_taille_zoneVerticale.clear()  ;
    m_taille_zoneHorizontale.clear();
    m_noms_variables.clear()        ;
    m_noms_contraintes.clear()      ;

    init();
}

CPlexMutable::~CPlexMutable()
{
}

/// option
void    CPlexMutable::setOption( CPlexModel::ParallelMode mode )
{
    int status = 0;
    switch ( mode ) {
        case Default :
            /* Set parallel mode to default */
            status = CPXsetintparam ( env, CPX_PARAM_THREADS, 0 );
            if ( status )
                throw CPlexFailed("Failure to set automatic thread count.", env, status);
            status = CPXsetintparam ( env, CPX_PARAM_PARALLELMODE, CPX_PARALLEL_AUTO ) ;
            if ( status )
                throw CPlexFailed("Failure to set parallel mode to automatic.", env, status);
            break;
        case None :
            status = CPXsetintparam ( env, CPX_PARAM_THREADS, 1);
            break ;
        case Opportunistic :
            /* Set parallel mode to opportunistic */
            status = CPXsetintparam ( env, CPX_PARAM_THREADS, 0 );
            if ( status )
                throw CPlexFailed("Failure to set automatic thread count.", env, status);
            status = CPXsetintparam ( env, CPX_PARAM_PARALLELMODE, CPX_PARALLEL_OPPORTUNISTIC ) ;
            if ( status )
                throw CPlexFailed("Failure to set parallel mode to opportunistic.", env, status);
            break ;
    }
}

void    CPlexMutable::setOption( OptionDouble option, double val)
{
    int status = 0;
    switch ( option ) {
        case Time :
            status = CPXsetdblparam( env, CPX_PARAM_TILIM, val );
            if ( status )
                throw CPlexFailed("Failure to set time limit.", env, status);
    }
}


/**
 * ajout de lignes (contraintes) à la matrice
 */

size_t CPlexMutable::addLigne  ( std::string nom, size_t taille )
{
    m_taille_zoneVerticale[nom] = taille ;
    m_zoneVerticale[nom] = cpx_numrows;
    cpx_numrows += taille ;
#ifndef NO_CPLEX
    int status = CPXnewrows(env, lp, taille, NULL, NULL, NULL, NULL);
    if ( status )
        throw CPlexFailed("Echec de l'ajout de lignes", env, status );

    if (m_with_names) {
        size_t lig = m_zoneVerticale[nom] ;
        for (size_t i=0; i<taille; i++,lig++) {
            string nomvarstr = nom + "_" + i;
            status = CPXchgname (env, lp, 'r', lig, nomvarstr.c_str());
            if ( status )
                throw CPlexFailed("Echec de nommage d'une contrainte", env, status );
        }
    }
#endif

    return m_zoneVerticale.size()-1;
}




/**
 * ajout de colonnes (variables) à la matrice
 */

size_t CPlexMutable::addColonne  ( std::string nom, size_t taille )
{
    m_taille_zoneHorizontale[nom] = taille ;
    m_zoneHorizontale[nom] = cpx_numcols ;
    cpx_numcols += taille ;


#ifndef NO_CPLEX
    int status = CPXnewcols(env, lp, taille, NULL, NULL, NULL, NULL, NULL);
    if ( status )
        throw CPlexFailed("Echec de l'ajout de colonnes", env, status );

    if (m_with_names) {
        size_t col = m_zoneHorizontale[nom] ;

        for (size_t i=0; i<taille; i++, col++) {
            string nomvarstr = nom + "_" + i;
            status = CPXchgname (env, lp, 'c', col, nomvarstr.c_str());
            if ( status )
                throw CPlexFailed("Echec de nommage d'une variable", env, status );
        }
    }
#endif

    return m_zoneHorizontale.size()-1;
}




/**
 * ajout de bornes/type/obj.coeff. à une variable
 */

void CPlexMutable::addToObj( size_t col, double min, double max, Type type, double coeff )
{
#ifndef NO_CPLEX
    int _id = m_debut_zoneH + col ;
    int status ;
    if (cpx_problemtype != Linear)
    {
        status = CPXchgctype(env, lp, 1, &_id, (char*)&type);
        if ( status )
            throw CPlexFailed("Echec de l'ajout du type d'une variable", env, status );
    }
    status = CPXchgbds(env, lp, 1, &_id, "L", &min);
    if ( status )
        throw CPlexFailed("Echec de l'ajout d'une borne inf. à une variable", env, status );
    status = CPXchgbds(env, lp, 1, &_id, "U", &max);
    if ( status )
        throw CPlexFailed("Echec de l'ajout d'une borne sup. à une variable", env, status );
    status = CPXchgobj(env, lp, 1, &_id, &coeff);
    if ( status )
        throw CPlexFailed("Echec de l'ajout du coeff. d'une variable dans la fonction objectif", env, status );
#endif
}


/**
 * ajout de la partie droite d'une contrainte
 */

void CPlexMutable::addToRHS( size_t row, Sense comp, double val, double range )
{
#ifndef NO_CPLEX
    int _id = m_debut_zoneV + row ;
    int status = CPXchgsense(env, lp, 1, &_id, (char*)&comp);
    if ( status )
        throw CPlexFailed("Echec de l'ajout du sens d'une contrainte", env, status );

    status = CPXchgrhs(env, lp, 1, &_id, &val);
    if ( status )
        throw CPlexFailed("Echec de l'ajout de la partie droite d'une contrainte", env, status );

    if (comp == Range) {
        status = CPXchgrngval(env, lp, 1, &_id, &range);
        if ( status )
            throw CPlexFailed("Echec de l'ajout de la seconde borne d'une contrainte", env, status );
    }
#endif
}



/**
 * ajout d'un coefficient à la matrice des contraintes
 */

void CPlexMutable::addToZ( size_t row, size_t col, double val )
{
    m_taille_Z ++ ;
#ifndef NO_CPLEX
    int status = CPXchgcoef(env, lp, m_debut_zoneV + row, m_debut_zoneH + col, val);
    if ( status )
        throw CPlexFailed("Echec de l'ajout d'un coefficient à la matrice", env, status );
#endif
}




/**
 * suppression d'une ou plusieurs colonnes (zone horizontale)
 */

void CPlexMutable::removeZoneHorizontale ( std::string nom )
{
    size_t colonne = m_zoneHorizontale[nom] ;
    size_t taille = m_taille_zoneHorizontale[nom] ;
    m_zoneHorizontale.erase(nom);
    m_taille_zoneHorizontale.erase(nom);
    cpx_numcols -= taille ;
    for (map<string,size_t>::iterator it=m_zoneHorizontale.begin(); it!=m_zoneHorizontale.end(); it++)
    {
        if (it->second > colonne) it->second -= taille ;
    }
#ifndef NO_CPLEX
    int status = CPXdelcols(env, lp, colonne, colonne + taille - 1);
    if ( status )
        throw CPlexFailed("Failed to remove a column.", env, status );
#endif
}



/**
 * récupération des valeurs trouvées pour les variables d'une zone horizontale
 * @param zoneH index de la zone
 * @return vecteur des valeurs des variables
 */
std::vector<double> CPlexMutable::getResult(std::string zoneH)
{
    // contrôle de l'index de zone
    if (m_zoneHorizontale.find(zoneH)==m_zoneHorizontale.end()) throw std::string("zone inexistante");

    // calcul de la taille de la zone
    size_t taille = m_taille_zoneHorizontale[zoneH] ;

    // copie des résultats dans le vecteur de retour
    std::vector<double> vars(taille);
#ifndef NO_CPLEX
    int status = CPXgetx ( env, lp, &(vars[0]), m_zoneHorizontale[zoneH], m_zoneHorizontale[zoneH] + taille - 1 );
    if ( status )
        throw CPlexFailed("Failed to get optimal integer x_cplex.", env, status );
#endif
    return vars;
}

/**
 * récupération des valeurs trouvées pour les variables d'une zone horizontale
 * pour une solution faisant partie du bassin de solutions (après appel à populate)
 * @param zoneH index de la zone
 * @return vecteur des valeurs des variables
 */
std::vector<double> CPlexMutable::getResult(int sol_id, std::string zoneH)
{
    // contrôle de l'index de zone
    if (m_zoneHorizontale.find(zoneH)==m_zoneHorizontale.end()) throw std::string("zone inexistante");

    // calcul de la taille de la zone
    size_t taille = m_taille_zoneHorizontale[zoneH] ;

    // copie des résultats dans le vecteur de retour
    std::vector<double> vars(taille);
#ifndef NO_CPLEX
    int status = CPXgetsolnpoolx ( env, lp, sol_id, &(vars[0]), m_zoneHorizontale[zoneH], m_zoneHorizontale[zoneH] + taille - 1 );
    if ( status )
        throw CPlexFailed("Failed to get optimal integer x_cplex.", env, status );
#endif
    return vars;
}


/**
 * récupèration de la valeur des coûts réduits d'une zone horizontale
 * @param zoneH index de la zone
 * @return vecteur des valeurs des coûts réduits
 */

std::vector<double> CPlexMutable::getReducedCosts(std::string zoneH)
{
    // contrôle de l'index de zone
    if (m_zoneHorizontale.find(zoneH)==m_zoneHorizontale.end()) throw string("zone inexistante");

    // calcul de la taille de la zone
    size_t taille = m_taille_zoneHorizontale[zoneH] ;

    // copie des résultats dans le vecteur de retour
    std::vector<double> cr(taille);
#ifndef NO_CPLEX
    int status = CPXgetdj ( env, lp, &(cr[0]), m_zoneHorizontale[zoneH], m_zoneHorizontale[zoneH] + taille - 1 );
    if ( status )
        throw CPlexFailed("Failed to get reduced costs.", env, status );
#endif
    return cr;
}


/**
 * récupération des valeurs trouvées pour les variables duales d'une zone verticale
 * @param zoneV index de la zone
 * @return vecteur des valeurs des variables
 */
std::vector<double> CPlexMutable::getDuals(std::string zoneV)
{
    // contrôle de l'index de zone
    if (m_zoneVerticale.find(zoneV)==m_zoneVerticale.end()) throw string("zone inexistante");

    // calcul de la taille de la zone
    size_t taille = m_taille_zoneVerticale[zoneV] ;

    // copie des résultats dans le vecteur de retour
    vector<double> duals(taille);
#ifndef NO_CPLEX
    int status = CPXgetpi ( env, lp, &(duals[0]), m_zoneVerticale[zoneV], m_zoneVerticale[zoneV] + taille - 1 );
    if ( status )
        throw CPlexFailed("Failed to get duals.", env, status );
#endif
    return duals;
}

/**
 * récupération des valeurs trouvées pour l'infaisabilité d'une zone verticale
 * @param zoneV index de la zone
 * @return vecteur des valeurs des variables
 */
std::vector< double > CPlexMutable::getInfeasibilities(string zoneV)
{
    // contrôle de l'index de zone
    if (m_zoneVerticale.find(zoneV)==m_zoneVerticale.end()) throw string("zone inexistante");
    
    // calcul de la taille de la zone
    size_t taille = m_taille_zoneVerticale[zoneV] ;
    
    // copie des résultats dans le vecteur de retour
    vector<double> valeurs(taille);
    #ifndef NO_CPLEX
    int status = CPXgetrowinfeas ( env, lp, NULL, &(valeurs[0]), m_zoneVerticale[zoneV], m_zoneVerticale[zoneV] + taille - 1 );
    if ( status )
        throw CPlexFailed("Failed to get infeasibilities.", env, status );
    #endif
        return valeurs;
}

/**
 * la solution est-elle "infeasible"
 */

bool CPlexMutable::getInfeasible()
{
    return CPXgetstat ( env, lp ) == 3 ;
}


/**
 * résolution du problème par appel à cplex
 * @return valeur de la fonction objectif
 */
double CPlexMutable::resolution()
{
#ifndef NO_CPLEX
    int         status  = 0;

    /* Write a copy of the problem to a file. */
    if (m_writeToFile) write_pb() ;

    /* Optimize the problem and obtain solution. */
    switch (cpx_problemtype) {
        case MixedInteger :
/*            status = CPXsetintparam( env, CPX_PARAM_NODEFILEIND, 3);
            if ( status )
            throw CPlexFailed("Failure to turn on writing nodes to file.", env, status);*/
            status = CPXsetintparam( env, CPX_PARAM_NODESEL, 0);
            if ( status )
                throw CPlexFailed("Failure to set node selection to depth first.", env, status);
            status = CPXmipopt ( env, lp );
            break;
        case Linear :
            status = CPXlpopt ( env, lp );
//             status = CPXsetintparam( env, CPX_PARAM_FEASOPTMODE, CPX_FEASOPT_MIN_SUM);
//             status = CPXfeasopt( env, lp, NULL,NULL,NULL,NULL);
    }
    if ( status )
        throw CPlexFailed("Failed to optimize LP.", env, status );
    if (!cpx_silent) {
        cout << "\nSolution status = " << CPXgetstat ( env, lp ) << " : " << statusstring(env,CPXgetstat ( env, lp )) << endl;
    }

    /* Get the objective value. */

    status = CPXgetobjval ( env, lp, &cpx_objval );
    if ( status )
        throw CPlexFailed("No MIP objective value available.", env, status);
    if (!cpx_silent)
        cout << "Solution value  = " << cpx_objval << endl << endl;

    /* écriture de la solution sur disque */
    if (m_writeToFile) write_sol();

#endif

    return cpx_objval;
}

/**
 * résolution du problème par appel à cplex
 * et remplissage du bassin de solutions
 * @return valeur de la fonction objectif
 */
vector<double> CPlexMutable::populate()
{
    vector<double> obj ;

#ifndef NO_CPLEX
    int         status  = 0;

    /* Optimize the problem and obtain solution. */
    switch (cpx_problemtype) {
        case MixedInteger :
            status = CPXpopulate ( env, lp );
            break;
        case Linear :
            return obj;
    }
    if ( status )
        throw CPlexFailed("Failed to populate solution pool.", env, status );
    if (!cpx_silent) {
        cout << "\nSolution status = " << CPXgetstat ( env, lp ) << " : " << statusstring(env,CPXgetstat ( env, lp )) << endl;
    }

    /* Get the objective values */

    int nb_sol = CPXgetsolnpoolnumsolns(env, lp) ;
    obj.resize(nb_sol, INFINI);
    for (int i=0; i<nb_sol; i++) {
        status = CPXgetsolnpoolobjval( env, lp, i, &obj[i] );
        if ( status )
            throw CPlexFailed("No MIP objective value available.", env, status);
        if (!cpx_silent)
            cout << "Solution " << i << " value  = " << cpx_objval << endl;
    }

#endif

    return obj;
}



double CPlexMutable::feasopt()
{
#ifndef NO_CPLEX
    size_t cur_numrows = CPXgetnumrows ( env, lp );

    /* Optimize the problem and obtain solution. */
    CPXsetintparam( env, CPX_PARAM_FEASOPTMODE, CPX_FEASOPT_OPT_INF );
//     vector<double> pref_x( cur_numcols, 0 );
    vector<double> pref_y( cur_numrows, 1 );
    CPXfeasopt ( env, lp, &pref_y[0], NULL, NULL, NULL );
    if (!cpx_silent) {
        cout << "\nSolution status = " << CPXgetstat ( env, lp ) << " : " << statusstring(env,CPXgetstat ( env, lp )) << endl;
    }
#endif

    return cpx_objval;
}

void CPlexMutable::write_pb()
{
    int status = CPXwriteprob ( env, lp, (cpx_probname+".lp").c_str(), NULL );
    if ( status )
        throw CPlexFailed("Failed to write LP to disk.", env, status );
}

void CPlexMutable::write_names()
{
    ofstream ofs( (cpx_probname+".names").c_str() );
    for ( map<string, size_t>::const_iterator it=m_zoneHorizontale.begin(); it!=m_zoneHorizontale.end(); it++)
    {
        ofs << "Variables : " << it->first << "\tDébut : " << it->second << "\tNombre de variables : " << m_taille_zoneHorizontale[it->first]
                << "\tFin : " << m_taille_zoneHorizontale[it->first] + it->second << endl ;
        for ( size_t i=0; i<m_taille_zoneHorizontale[it->first]; i++)
        {
            ofs << "x" << it->second + i + 1 << "\t : " << it->first << "_" << i << std::endl ;
        }
    }
    for ( map<string, size_t>::const_iterator it=m_zoneVerticale.begin(); it!=m_zoneVerticale.end(); it++)
    {
        ofs << "Contraintes : " << it->first << "\tDébut : " << it->second << "\tNombre de variables : " << m_taille_zoneVerticale[it->first]
                << "\tFin : " << m_taille_zoneVerticale[it->first] + it->second << endl ;
        for ( size_t i=0; i<m_taille_zoneVerticale[it->first]; i++)
        {
            ofs << "c" << it->second + i + 1 << "\t : " << it->first << "_" << i << std::endl ;
        }
    }
}

void CPlexMutable::write_sol()
{
    int status ;

    /* Get variables values. */
        /* The size of the problem should be obtained by asking CPLEX what
    the actual size is, rather than using what was passed to CPXcopylp.
    cur_numrows and cur_numcols store the current number of rows and
    columns, respectively.  */

    size_t cur_numcols = CPXgetnumcols ( env, lp );
    ofstream ofs((cpx_probname+".sol").c_str());

    for (size_t c=0; c<cur_numcols; c++) {
        double val ;
        status = CPXgetx ( env, lp, &val, c, c );
        if ( status )
            throw CPlexFailed("Failed to get optimal integer x_cplex.", env, status );
        char nom[1024] ;
        char * adresse_nom ;
        int surplus ;
        status = CPXgetcolname(env, lp, &adresse_nom, nom, 1024, &surplus, c, c);
        ofs << nom << " = " << val << endl;
    }
    ofs.close();
}