/* -*- 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