/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * Copyright (C) 2003-2008

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

#include <iostream>

#include <vector>

#include <lemon/lp_cplex.h>

extern "C" {

#include <ilcplex/cplex.h>

}

///\file

///\brief Implementation of the LEMON-CPLEX lp solver interface.

namespace lemon {

  LpCplex::LpCplex() {

    //    env = CPXopenCPLEXdevelop(&status);

    env = CPXopenCPLEX(&status);

    lp = CPXcreateprob(env, &status, "LP problem");

  }

  LpCplex::LpCplex(const LpCplex& cplex) : LpSolverBase() {

    env = CPXopenCPLEX(&status);

    lp = CPXcloneprob(env, cplex.lp, &status);

    rows = cplex.rows;

    cols = cplex.cols;

  }

  LpCplex::~LpCplex() {

    CPXfreeprob(env,&lp);

    CPXcloseCPLEX(&env);

  }

  LpSolverBase* LpCplex::_newLp()

  {

    //The first approach opens a new environment

    return new LpCplex();

  }

  LpSolverBase* LpCplex::_copyLp() {

    return new LpCplex(*this);

  }

  int LpCplex::_addCol()

  {

    int i = CPXgetnumcols(env, lp);

    Value lb[1],ub[1];

    lb[0]=-INF;

    ub[0]=INF;

    status = CPXnewcols(env, lp, 1, NULL, lb, ub, NULL, NULL);

    return i;

  }

  int LpCplex::_addRow()

  {

    //We want a row that is not constrained

    char sense[1];

    sense[0]='L';//<= constraint

    Value rhs[1];

    rhs[0]=INF;

    int i = CPXgetnumrows(env, lp);

    status = CPXnewrows(env, lp, 1, rhs, sense, NULL, NULL);

    return i;

  }

  void LpCplex::_eraseCol(int i) {

    CPXdelcols(env, lp, i, i);

  }

  void LpCplex::_eraseRow(int i) {

    CPXdelrows(env, lp, i, i);

  }

  void LpCplex::_getColName(int col, std::string &name) const

  {

    ///\bug Untested

    int storespace;

    CPXgetcolname(env, lp, 0, 0, 0, &storespace, col, col);

    if (storespace == 0) {

      name.clear();

      return;

    }

    storespace *= -1;

    std::vector<char> buf(storespace);

    char *names[1];

    int dontcare;

    ///\bug return code unchecked for error

    CPXgetcolname(env, lp, names, &*buf.begin(), storespace,

                  &dontcare, col, col);

    name = names[0];

  }

  void LpCplex::_setColName(int col, const std::string &name)

  {

    ///\bug Untested

    char *names[1];

    names[0] = const_cast<char*>(name.c_str());

    ///\bug return code unchecked for error

    CPXchgcolname(env, lp, 1, &col, names);

  }

  int LpCplex::_colByName(const std::string& name) const

  {

    int index;

    if (CPXgetcolindex(env, lp,

                       const_cast<char*>(name.c_str()), &index) == 0) {

      return index;

    }

    return -1;

  }

  ///\warning Data at index 0 is ignored in the arrays.

  void LpCplex::_setRowCoeffs(int i, ConstRowIterator b, ConstRowIterator e)

  {

    std::vector<int> indices;

    std::vector<int> rowlist;

    std::vector<Value> values;

    for(ConstRowIterator it=b; it!=e; ++it) {

      indices.push_back(it->first);

      values.push_back(it->second);

      rowlist.push_back(i);

    }

    status = CPXchgcoeflist(env, lp, values.size(),

                            &rowlist[0], &indices[0], &values[0]);

  }

  void LpCplex::_getRowCoeffs(int i, RowIterator b) const {

    int tmp1, tmp2, tmp3, length;

    CPXgetrows(env, lp, &tmp1, &tmp2, 0, 0, 0, &length, i, i);

    length = -length;

    std::vector<int> indices(length);

    std::vector<double> values(length);

    CPXgetrows(env, lp, &tmp1, &tmp2, &indices[0], &values[0],

               length, &tmp3, i, i);

    for (int i = 0; i < length; ++i) {

      *b = std::make_pair(indices[i], values[i]);

      ++b;

    }

    /// \todo implement

  }

  void LpCplex::_setColCoeffs(int i, ConstColIterator b, ConstColIterator e)

  {

    std::vector<int> indices;

    std::vector<int> collist;

    std::vector<Value> values;

    for(ConstColIterator it=b; it!=e; ++it) {

      indices.push_back(it->first);

      values.push_back(it->second);

      collist.push_back(i);

    }

    status = CPXchgcoeflist(env, lp, values.size(),

                            &indices[0], &collist[0], &values[0]);

  }

  void LpCplex::_getColCoeffs(int i, ColIterator b) const {

    int tmp1, tmp2, tmp3, length;

    CPXgetcols(env, lp, &tmp1, &tmp2, 0, 0, 0, &length, i, i);

    length = -length;

    std::vector<int> indices(length);

    std::vector<double> values(length);

    CPXgetcols(env, lp, &tmp1, &tmp2, &indices[0], &values[0],

               length, &tmp3, i, i);

    for (int i = 0; i < length; ++i) {

      *b = std::make_pair(indices[i], values[i]);

      ++b;

    }

  }

  void LpCplex::_setCoeff(int row, int col, Value value)

  {

    CPXchgcoef(env, lp, row, col, value);

  }

  LpCplex::Value LpCplex::_getCoeff(int row, int col) const

  {

    LpCplex::Value value;

    CPXgetcoef(env, lp, row, col, &value);

    return value;

  }

  void LpCplex::_setColLowerBound(int i, Value value)

  {

    int indices[1];

    indices[0]=i;

    char lu[1];

    lu[0]='L';

    Value bd[1];

    bd[0]=value;

    status = CPXchgbds(env, lp, 1, indices, lu, bd);

  }

  LpCplex::Value LpCplex::_getColLowerBound(int i) const

  {

    LpCplex::Value x;

    CPXgetlb (env, lp, &x, i, i);

    if (x <= -CPX_INFBOUND) x = -INF;

    return x;

  }

  void LpCplex::_setColUpperBound(int i, Value value)

  {

    int indices[1];

    indices[0]=i;

    char lu[1];

    lu[0]='U';

    Value bd[1];

    bd[0]=value;

    status = CPXchgbds(env, lp, 1, indices, lu, bd);

  }

  LpCplex::Value LpCplex::_getColUpperBound(int i) const

  {

    LpCplex::Value x;

    CPXgetub (env, lp, &x, i, i);

    if (x >= CPX_INFBOUND) x = INF;

    return x;

  }

  //This will be easier to implement

  void LpCplex::_setRowBounds(int i, Value lb, Value ub)

  {

    //Bad parameter

    if (lb==INF || ub==-INF) {

      //FIXME error

    }

    int cnt=1;

    int indices[1];

    indices[0]=i;

    char sense[1];

    if (lb==-INF){

      sense[0]='L';

      CPXchgsense(env, lp, cnt, indices, sense);

      CPXchgcoef(env, lp, i, -1, ub);

    }

    else{

      if (ub==INF){

        sense[0]='G';

        CPXchgsense(env, lp, cnt, indices, sense);

        CPXchgcoef(env, lp, i, -1, lb);

      }

      else{

        if (lb == ub){

          sense[0]='E';

          CPXchgsense(env, lp, cnt, indices, sense);

          CPXchgcoef(env, lp, i, -1, lb);

        }

        else{

          sense[0]='R';

          CPXchgsense(env, lp, cnt, indices, sense);

          CPXchgcoef(env, lp, i, -1, lb);

          CPXchgcoef(env, lp, i, -2, ub-lb);

        }

      }

    }

  }

//   void LpCplex::_setRowLowerBound(int i, Value value)

//   {

//     //Not implemented, obsolete

//   }

//   void LpCplex::_setRowUpperBound(int i, Value value)

//   {

//     //Not implemented, obsolete

// //     //TODO Ezt kell meg megirni

// //     //type of the problem

// //     char sense[1];

// //     status = CPXgetsense(env, lp, sense, i, i);

// //     Value rhs[1];

// //     status = CPXgetrhs(env, lp, rhs, i, i);

// //     switch (sense[0]) {

// //     case 'L'://<= constraint

// //       break;

// //     case 'E'://= constraint

// //       break;

// //     case 'G'://>= constraint

// //       break;

// //     case 'R'://ranged constraint

// //       break;

// //     default: ;

// //       //FIXME error

// //     }

// //     status = CPXchgcoef(env, lp, i, -2, value_rng);

//   }

  void LpCplex::_getRowBounds(int i, Value &lb, Value &ub) const

  {

    char sense;

    CPXgetsense(env, lp, &sense,i,i);

    lb=-INF;

    ub=INF;

    switch (sense)

      {

      case 'L':

        CPXgetcoef(env, lp, i, -1, &ub);

        break;

      case 'G':

        CPXgetcoef(env, lp, i, -1, &lb);

        break;

      case 'E':

        CPXgetcoef(env, lp, i, -1, &lb);

        ub=lb;

        break;

      case 'R':

        CPXgetcoef(env, lp, i, -1, &lb);

        Value x;

        CPXgetcoef(env, lp, i, -2, &x);

        ub=lb+x;

        break;

      }

  }

  void LpCplex::_setObjCoeff(int i, Value obj_coef)

  {

    CPXchgcoef(env, lp, -1, i, obj_coef);

  }

  LpCplex::Value LpCplex::_getObjCoeff(int i) const

  {

    Value x;

    CPXgetcoef(env, lp, -1, i, &x);

    return x;

  }

  void LpCplex::_clearObj()

  {

    for (int i=0;i< CPXgetnumcols(env, lp);++i){

      CPXchgcoef(env, lp, -1, i, 0);

    }

  }

  // The routine returns zero unless an error occurred during the

  // optimization. Examples of errors include exhausting available

  // memory (CPXERR_NO_MEMORY) or encountering invalid data in the

  // CPLEX problem object (CPXERR_NO_PROBLEM). Exceeding a

  // user-specified CPLEX limit, or proving the model infeasible or

  // unbounded, are not considered errors. Note that a zero return

  // value does not necessarily mean that a solution exists. Use query

  // routines CPXsolninfo, CPXgetstat, and CPXsolution to obtain

  // further information about the status of the optimization.

  LpCplex::SolveExitStatus LpCplex::_solve()

  {

    //CPX_PARAM_LPMETHOD

    status = CPXlpopt(env, lp);

    //status = CPXprimopt(env, lp);

#if CPX_VERSION >= 800

    if (status)

    {

      return UNSOLVED;

    }

    else

    {

      switch (CPXgetstat(env, lp))

      {

        case CPX_STAT_OPTIMAL:

        case CPX_STAT_INFEASIBLE:

        case CPX_STAT_UNBOUNDED:

          return SOLVED;

        default:

          return UNSOLVED;

      }

    }

#else

    if (status == 0){

      //We want to exclude some cases

      switch (CPXgetstat(env, lp)){

      case CPX_OBJ_LIM:

      case CPX_IT_LIM_FEAS:

      case CPX_IT_LIM_INFEAS:

      case CPX_TIME_LIM_FEAS:

      case CPX_TIME_LIM_INFEAS:

        return UNSOLVED;

      default:

        return SOLVED;

      }

    }

    else{

      return UNSOLVED;

    }

#endif

  }

  LpCplex::Value LpCplex::_getPrimal(int i) const

  {

    Value x;

    CPXgetx(env, lp, &x, i, i);

    return x;

  }

  LpCplex::Value LpCplex::_getDual(int i) const

  {

    Value y;

    CPXgetpi(env, lp, &y, i, i);

    return y;

  }

  LpCplex::Value LpCplex::_getPrimalValue() const

  {

    Value objval;

    //method = CPXgetmethod (env, lp);

    //printf("CPXgetprobtype %d \n",CPXgetprobtype(env,lp));

    CPXgetobjval(env, lp, &objval);

    //printf("Objective value: %g \n",objval);

    return objval;

  }

  bool LpCplex::_isBasicCol(int i) const

  {

    std::vector<int> cstat(CPXgetnumcols(env, lp));

    CPXgetbase(env, lp, &*cstat.begin(), NULL);

    return (cstat[i]==CPX_BASIC);

  }

//7.5-os cplex statusai (Vigyazat: a 9.0-asei masok!)

// This table lists the statuses, returned by the CPXgetstat()

// routine, for solutions to LP problems or mixed integer problems. If

// no solution exists, the return value is zero.

// For Simplex, Barrier

// 1          CPX_OPTIMAL

//          Optimal solution found

// 2          CPX_INFEASIBLE

//          Problem infeasible

// 3    CPX_UNBOUNDED

//          Problem unbounded

// 4          CPX_OBJ_LIM

//          Objective limit exceeded in Phase II

// 5          CPX_IT_LIM_FEAS

//          Iteration limit exceeded in Phase II

// 6          CPX_IT_LIM_INFEAS

//          Iteration limit exceeded in Phase I

// 7          CPX_TIME_LIM_FEAS

//          Time limit exceeded in Phase II

// 8          CPX_TIME_LIM_INFEAS

//          Time limit exceeded in Phase I

// 9          CPX_NUM_BEST_FEAS

//          Problem non-optimal, singularities in Phase II

// 10         CPX_NUM_BEST_INFEAS

//          Problem non-optimal, singularities in Phase I

// 11         CPX_OPTIMAL_INFEAS

//          Optimal solution found, unscaled infeasibilities

// 12         CPX_ABORT_FEAS

//          Aborted in Phase II

// 13         CPX_ABORT_INFEAS

//          Aborted in Phase I

// 14          CPX_ABORT_DUAL_INFEAS

//          Aborted in barrier, dual infeasible

// 15          CPX_ABORT_PRIM_INFEAS

//          Aborted in barrier, primal infeasible

// 16          CPX_ABORT_PRIM_DUAL_INFEAS

//          Aborted in barrier, primal and dual infeasible

// 17          CPX_ABORT_PRIM_DUAL_FEAS

//          Aborted in barrier, primal and dual feasible

// 18          CPX_ABORT_CROSSOVER

//          Aborted in crossover

// 19          CPX_INForUNBD

//          Infeasible or unbounded

// 20   CPX_PIVOT

//       User pivot used

//

//     Ezeket hova tegyem:

// ??case CPX_ABORT_DUAL_INFEAS

// ??case CPX_ABORT_CROSSOVER

// ??case CPX_INForUNBD

// ??case CPX_PIVOT

//Some more interesting stuff:

// CPX_PARAM_LPMETHOD  1062  int  LPMETHOD

// 0 Automatic

// 1 Primal Simplex

// 2 Dual Simplex

// 3 Network Simplex

// 4 Standard Barrier

// Default: 0

// Description: Method for linear optimization.

// Determines which algorithm is used when CPXlpopt() (or "optimize"

// in the Interactive Optimizer) is called. Currently the behavior of

// the "Automatic" setting is that CPLEX simply invokes the dual

// simplex method, but this capability may be expanded in the future

// so that CPLEX chooses the method based on problem characteristics

#if CPX_VERSION < 900

  void statusSwitch(CPXENVptr env,int& stat){

    int lpmethod;

    CPXgetintparam (env,CPX_PARAM_LPMETHOD,&lpmethod);

    if (lpmethod==2){

      if (stat==CPX_UNBOUNDED){

        stat=CPX_INFEASIBLE;

      }

      else{

        if (stat==CPX_INFEASIBLE)

          stat=CPX_UNBOUNDED;

      }

    }

  }

#else

  void statusSwitch(CPXENVptr,int&){}

#endif

  LpCplex::SolutionStatus LpCplex::_getPrimalStatus() const

  {

    //Unboundedness not treated well: the following is from cplex 9.0 doc

    // About Unboundedness

    // The treatment of models that are unbounded involves a few

    // subtleties. Specifically, a declaration of unboundedness means that

    // ILOG CPLEX has determined that the model has an unbounded

    // ray. Given any feasible solution x with objective z, a multiple of

    // the unbounded ray can be added to x to give a feasible solution

    // with objective z-1 (or z+1 for maximization models). Thus, if a

    // feasible solution exists, then the optimal objective is

    // unbounded. Note that ILOG CPLEX has not necessarily concluded that

    // a feasible solution exists. Users can call the routine CPXsolninfo

    // to determine whether ILOG CPLEX has also concluded that the model

    // has a feasible solution.

    int stat = CPXgetstat(env, lp);

#if CPX_VERSION >= 800

    switch (stat)

    {

      case CPX_STAT_OPTIMAL:

        return OPTIMAL;

      case CPX_STAT_UNBOUNDED:

        return INFINITE;

      case CPX_STAT_INFEASIBLE:

        return INFEASIBLE;

      default:

        return UNDEFINED;

    }

#else

    statusSwitch(env,stat);

    //CPXgetstat(env, lp);

    //printf("A primal status: %d, CPX_OPTIMAL=%d \n",stat,CPX_OPTIMAL);

    switch (stat) {

    case 0:

      return UNDEFINED; //Undefined

    case CPX_OPTIMAL://Optimal

      return OPTIMAL;

    case CPX_UNBOUNDED://Unbounded

      return INFEASIBLE;//In case of dual simplex

      //return INFINITE;

    case CPX_INFEASIBLE://Infeasible

 //    case CPX_IT_LIM_INFEAS:

//     case CPX_TIME_LIM_INFEAS:

//     case CPX_NUM_BEST_INFEAS:

//     case CPX_OPTIMAL_INFEAS:

//     case CPX_ABORT_INFEAS:

//     case CPX_ABORT_PRIM_INFEAS:

//     case CPX_ABORT_PRIM_DUAL_INFEAS:

      return INFINITE;//In case of dual simplex

      //return INFEASIBLE;

//     case CPX_OBJ_LIM:

//     case CPX_IT_LIM_FEAS:

//     case CPX_TIME_LIM_FEAS:

//     case CPX_NUM_BEST_FEAS:

//     case CPX_ABORT_FEAS:

//     case CPX_ABORT_PRIM_DUAL_FEAS:

//       return FEASIBLE;

    default:

      return UNDEFINED; //Everything else comes here

      //FIXME error

    }

#endif

  }

//9.0-as cplex verzio statusai

// CPX_STAT_ABORT_DUAL_OBJ_LIM

// CPX_STAT_ABORT_IT_LIM

// CPX_STAT_ABORT_OBJ_LIM

// CPX_STAT_ABORT_PRIM_OBJ_LIM

// CPX_STAT_ABORT_TIME_LIM

// CPX_STAT_ABORT_USER

// CPX_STAT_FEASIBLE_RELAXED

// CPX_STAT_INFEASIBLE

// CPX_STAT_INForUNBD

// CPX_STAT_NUM_BEST

// CPX_STAT_OPTIMAL

// CPX_STAT_OPTIMAL_FACE_UNBOUNDED

// CPX_STAT_OPTIMAL_INFEAS

// CPX_STAT_OPTIMAL_RELAXED

// CPX_STAT_UNBOUNDED

  LpCplex::SolutionStatus LpCplex::_getDualStatus() const

  {

    int stat = CPXgetstat(env, lp);

#if CPX_VERSION >= 800

    switch (stat)

    {

      case CPX_STAT_OPTIMAL:

        return OPTIMAL;

      case CPX_STAT_UNBOUNDED:

        return INFEASIBLE;

      default:

        return UNDEFINED;

    }

#else

    statusSwitch(env,stat);

    switch (stat) {

    case 0:

      return UNDEFINED; //Undefined

    case CPX_OPTIMAL://Optimal

      return OPTIMAL;

    case CPX_UNBOUNDED:

     return INFEASIBLE;

    default:

      return UNDEFINED; //Everything else comes here

      //FIXME error

    }

#endif

  }

  LpCplex::ProblemTypes LpCplex::_getProblemType() const

  {

    int stat = CPXgetstat(env, lp);

#if CPX_VERSION >= 800

    switch (stat)

    {

      case CPX_STAT_OPTIMAL:

        return PRIMAL_DUAL_FEASIBLE;

      case CPX_STAT_UNBOUNDED:

         return PRIMAL_FEASIBLE_DUAL_INFEASIBLE;

      default:

        return UNKNOWN;

    }

#else

    switch (stat) {

    case CPX_OPTIMAL://Optimal

        return PRIMAL_DUAL_FEASIBLE;

    case CPX_UNBOUNDED:

         return PRIMAL_FEASIBLE_DUAL_INFEASIBLE;

//         return PRIMAL_INFEASIBLE_DUAL_FEASIBLE;

//         return PRIMAL_DUAL_INFEASIBLE;

//Seems to be that this is all we can say for sure

    default:

        //In all other cases

        return UNKNOWN;

      //FIXME error

    }

#endif

  }

  void LpCplex::_setMax()

  {

    CPXchgobjsen(env, lp, CPX_MAX);

   }

  void LpCplex::_setMin()

  {

    CPXchgobjsen(env, lp, CPX_MIN);

   }

  bool LpCplex::_isMax() const

  {

    if (CPXgetobjsen(env, lp)==CPX_MAX)

      return true;

    else

      return false;

  }

} //namespace lemon