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