/* -*- C++ -*-

 * src/lemon/lp_cplex.cc

 * - Part of LEMON, a generic C++ optimization library

 *

 * Copyright (C) 2005 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"lp_cplex.h"

///\file

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

namespace lemon {

  LpCplex::LpCplex() : LpSolverBase() {

    env = NULL;

    lp = NULL;

    env = CPXopenCPLEXdevelop(&status);     

//     if (Env == NULL)

//     {

//          fprintf(stderr,"A CPLEX környezet megnyitása sikertelen.\n");

// 	 CPXgeterrorstring(Env, Status, ErrorMsg);

// 	 fprintf(stderr,"%s",ErrorMsg);

// 	 goto Terminate;

//     }

    // *** A problema létrehozása ***

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

    //    if (Problem == NULL)

//     {

// 	fprintf(stderr,"Az LP létrehozása sikertelen");

// 	goto Terminate;

//     }

  }

  LpCplex::~LpCplex() {

    status = CPXfreeprob(env,&lp); 

    //       if (Status != 0)

    // 	{

// 	  fprintf(stderr,"A CPLEX feladat törlése sikertelen.\n");

// 	  CPXgeterrorstring(Env, Status, ErrorMsg);

// 	  fprintf(stderr,"%s",ErrorMsg);

// 	  goto Terminate;

// 	}

    status = CPXcloseCPLEX(&env); 

    //       if (Status != 0)

    // 	{

    // 	  fprintf(stderr,"A CPLEX környezet bezárása sikertelen.\n");

// 	  CPXgeterrorstring(Env, Status, ErrorMsg);

// 	  fprintf(stderr,"%s",ErrorMsg);

// 	  goto Terminate;

// 	}

  }

  LpSolverBase &LpCplex::_newLp() {return *(LpSolverBase*)0;}

  LpSolverBase &LpCplex::_copyLp() {return *(LpSolverBase*)0;}

  int LpCplex::_addCol()

  {

    int i = CPXgetnumcols (env, lp);

    Value lb[1],ub[1];

    lb[0]=-INF;//-CPX_INFBOUND;

    ub[0]=INF;//CPX_INFBOUND;

    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;

  }

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

  void LpCplex::_setRowCoeffs(int i, 

			      int length,

			      int  const * indices, 

			      Value  const * values )

  {

    int rowlist[length+1];

    int* p=rowlist;

    for (int k=1;k<=length;++k){

      rowlist[k]=i;

    }

    status = CPXchgcoeflist(env, lp, 

			    length, 

			    p+1, 

			    const_cast<int * >(indices+1), 

			    const_cast<Value * >(values+1));

  }

  void LpCplex::_setColCoeffs(int i, 

			      int length,

			      int  const * indices, 

			      Value  const * values)

  {

    int collist[length+1];

    int* p=collist;

    for (int k=1;k<=length;++k){

      collist[k]=i;

    }

    status = CPXchgcoeflist(env, lp, 

			    length, 

			    const_cast<int * >(indices+1), 

			    p+1, 

			    const_cast<Value * >(values+1));

  }

  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);

  }

  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);

  }

  //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::_setObjCoeff(int i, Value obj_coef)

  {

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

  }

  void LpCplex::_clearObj()

  {

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

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

    }

  }

  LpCplex::SolveExitStatus LpCplex::_solve()

  {

    status = CPXlpopt (env, lp);

    if (status == 0){

      return SOLVED;

    }

    else{

      return UNSOLVED;

    }

//     int i=  lpx_simplex(lp);

//     switch (i) {

//     case LPX_E_OK: 

//       return SOLVED;

//       break;

//     default:

//       return UNSOLVED;

//     }

  }

  LpCplex::SolutionStatus LpCplex::_getPrimalStatus()

  {

    //Unimplemented

    return OPTIMAL;

//     int stat=  lpx_get_status(lp);

//     switch (stat) {

//     case LPX_UNDEF://Undefined (no solve has been run yet)

//       return UNDEFINED;

//       break;

//     case LPX_NOFEAS://There is no feasible solution (primal, I guess)

//     case LPX_INFEAS://Infeasible 

//       return INFEASIBLE;

//       break;

//     case LPX_UNBND://Unbounded

//       return INFINITE;

//       break;

//     case LPX_FEAS://Feasible

//       return FEASIBLE;

//       break;

//     case LPX_OPT://Feasible

//       return OPTIMAL;

//       break;

//     default:

//       return UNDEFINED; //to avoid gcc warning

//       //FIXME error

//     }

  }

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

  {

    Value x;

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

    return x;

  }

  LpCplex::Value LpCplex::_getPrimalValue()

  {

    //Unimplemented

    return 0;

  }

  void LpCplex::_setMax()

  {

    CPXchgobjsen (env, lp, CPX_MAX);

   }

  void LpCplex::_setMin()

  {

    CPXchgobjsen (env, lp, CPX_MIN);

   }

} //namespace lemon