#include <cassert>
#include <iostream>

#include "CoinError.hpp"
#include "OsiCuts.hpp"
#include "OsiClpSolverInterface.hpp"

#include "CglCutGenerator.hpp"
#include "CglGomory.hpp"
#include "CglProbing.hpp"
#include "CglKnapsackCover.hpp"
#include "CglOddHole.hpp"
#include "CglClique.hpp"
#include "CglFlowCover.hpp"
#include "CglMixedIntegerRounding.hpp"
#include "CglTwomir.hpp"

#include "CbcModel.hpp"
#include "CbcHeuristic.hpp"

using std::cerr;
using std::cout;
using std::endl;

/* problem status */
#define LpStatusNotSolved 0
#define LpStatusOptimal 1
#define LpStatusInfeasible -1
#define LpStatusUnbounded -2
#define LpStatusUndefined -3

int main(int argc, const char *argv[])
{
	int pulp_status;
	int presolve = 0, dual = 0, scale = 1, crash = 0, mip = 1,
		strong = 5, cuts = 1, integerPresolve = 1, rounding = 0;
		
  try
  {
		OsiClpSolverInterface solver1;
		CbcModel model(solver1);

    model.solver()->readMps("test.mps.gz","mps");

		model.solver()->messageHandler()->setLogLevel(1);
		model.messageHandler()->setLogLevel(1);

		if (presolve)
			model.solver()->setHintParam(OsiDoPresolveInInitial,true,OsiHintTry);
		if (dual)
			model.solver()->setHintParam(OsiDoDualInInitial,true,OsiHintTry);
		if (!scale)
			model.solver()->setHintParam(OsiDoScale,false,OsiHintTry);
		if (crash)
			model.solver()->setHintParam(OsiDoCrash,true,OsiHintTry);

		model.initialSolve();

		if (model.solver()->isProvenOptimal())
			pulp_status = LpStatusOptimal;
		else if (model.solver()->isProvenPrimalInfeasible())
			pulp_status = LpStatusInfeasible;
		else if (model.solver()->isProvenDualInfeasible())
			pulp_status = LpStatusUnbounded;
		else
			pulp_status = LpStatusUndefined;

		if (pulp_status == LpStatusOptimal && mip)
		{
			model.solver()->messageHandler()->setLogLevel(-1);

			model.setNumberStrong(strong);

			/* Cuts */
			CglGomory gomory;
			CglProbing probing;
			probing.setUsingObjective(true);
			probing.setMaxPass(3);
			probing.setMaxProbe(100);
			probing.setMaxLook(50);
			probing.setRowCuts(3);
			CglKnapsackCover knapsackCover;
			CglOddHole oddHole;
			oddHole.setMinimumViolation(0.005);
			oddHole.setMinimumViolationPer(0.0002);
			oddHole.setMaximumEntries(100);

			if (cuts)
			{
				model.addCutGenerator(&gomory,-1,"Gomory");
				model.addCutGenerator(&probing,-1,"Probing");
				model.addCutGenerator(&knapsackCover,-1,"Knapsack");
				model.addCutGenerator(&oddHole,-1,"OddHole");
			}

			if (integerPresolve)
			{
				CbcModel *model2 = model.integerPresolve();

				if (model2)
				{
					/* Rounding */
 		   		CbcRounding heuristic(*model2);
					if (rounding)
						model2->addHeuristic(&heuristic);
					model2->branchAndBound();
		    	model.originalModel(model2,false);
				}
				else
					pulp_status = LpStatusInfeasible;
			}
			else
			{
				/* Rounding */
				CbcRounding heuristic(model);
				if (rounding)
					model.addHeuristic(&heuristic);

				model.branchAndBound();
			}
		}
  }
  catch ( CoinError e )
  {
    cout <<e.className() <<"::" <<e.methodName() <<" - " <<e.message() <<endl;
  }

  return 0;
}