#include <ildispat/ilodispatcher.h> 
#include <time.h> 

//running experiments with Dispatcher on the enlarged suite
//of problems (originally by Solomon).
//We have to feed in distmatrix explicitly.


ILOSTLBEGIN 

IloNum TimeLimit, MoveLimit; 
IloInt nbOfVisits;
IloInt nbOfTrucks;
IloInt capacity;

IloNum PenaltyFactor; 
IloInt TabuTenure; 
IloBool TypeOfMethod;//0-GLS,1-Tabu; 

/*const IloInt nbOfVisits = 100;
const IloInt nbOfTrucks = 25;
const IloNum capacity = 200; 
*/
IloNum** DistanceMatrix;
IloNum* durations;

class MyDistanceI: public IloDistanceI {
public:
	MyDistanceI(IloEnv env);
	virtual IloNum computeDistance (IloNode node1,
		                    IloNode node2,
							IloVehicle vehicle) const;
	IloEnv _env;
	void getDistanceMatrix(IloNum**& DistanceMatrix);
};

MyDistanceI::MyDistanceI(IloEnv env) : IloDistanceI(env) {
	_env = env;
}

void MyDistanceI::getDistanceMatrix(IloNum**& DistanceMatrix){
}


IloNum MyDistanceI::computeDistance(IloNode node1, IloNode node2, IloVehicle vehicle) const {

	IloInt index1 = 0, index2 = 0;
	char buffer1[28], buffer2[28], buffer[28];
	//cout<<node1<<" ";
	//cout<<node2<<endl;
	sprintf(buffer1,node1.getName());
	sprintf(buffer2,node2.getName());
	//cout<<buffer1<<" "<<buffer2<<endl;
	if (!strcmp(buffer1,buffer2)) return 0.0;
	for (int i=0;i<nbOfVisits+1;i++) {
		sprintf(buffer,"%d",i);
		if (!strcmp(buffer,buffer1)) index1 = i;
		if (!strcmp(buffer,buffer2)) index2 = i;
	}
	//cout<<"DistanceMatrix["<<index1<<"]["<<index2<<"] = "<<DistanceMatrix[index1][index2]<<endl;
	return DistanceMatrix[index1][index2];
}
  
void Info(IloDispatcher dispatcher, ofstream& fout) { 
  IloSolver solver = dispatcher.getSolver(); 
  fout<< "===============" << endl 
	       << "Cost         : " << dispatcher.getTotalCost() << endl  
	       << "Number of vehicles used : "  
	       << dispatcher.getNbOfVehiclesUsed() << endl 
	       << "Solution     : " << endl 
	       << dispatcher << endl; 
} 

void improveWithGLS_TimeLimitVersion(IloDispatcher dispatcher, 
                                     IloRoutingSolution solution, 
                                     IloNHood nhood, 
                                     ofstream& fout) { 
	IloNumVar cost = dispatcher.getCostVar(); 
	IloEnv env = dispatcher.getEnv(); 
	IloGoal instantiateCost = IloDichotomize(env, cost, IloFalse); 
	IloRoutingSolution rsol = solution.makeClone(env); 
	IloRoutingSolution best = solution.makeClone(env); 
	IloDispatcherGLS dgls(env, PenaltyFactor); 
	IloSearchSelector sel = IloMinimizeVar(env,dgls.getPenalizedCostVar()); 
	IloGoal move = IloSingleMove(env, rsol, nhood, dgls, sel, instantiateCost); 
	move = move && IloStoreBestSolution(env, best); 
	IloSolver solver = dispatcher.getSolver(); 
	IloCouple(nhood, dgls); 
	clock_t tStart = clock()/CLK_TCK, time = tStart;  
 
	while (time <= tStart + TimeLimit) { 
		if (solver.solve(move)) { 
			fout << "Cost = "<<solver.getMin(cost) <<endl; 
		} 
		else { 
			fout <<" ----- "<<endl; 
			if (dgls.complete()) { 
				cout<<"exiting by break"<<endl; 
				break; 
			} 
		} 
		time = clock()/CLK_TCK; 
	} 
	IloDecouple(nhood, dgls); 
	IloGoal restoreSolution = IloRestoreSolution(env, best) && 
							  instantiateCost; 
	solver.solve(restoreSolution); 
	rsol.end(); 
	best.end(); 
} 
 
void improveWithGLS_MoveLimitVersion(IloDispatcher dispatcher, 
				     IloRoutingSolution solution, 
				     IloNHood nhood, 
				     ofstream& fout) { 
	IloNumVar cost = dispatcher.getCostVar(); 
	IloEnv env = dispatcher.getEnv(); 
	IloGoal instantiateCost = IloDichotomize(env, cost, IloFalse); 
	IloRoutingSolution rsol = solution.makeClone(env); 
	IloRoutingSolution best = solution.makeClone(env); 
	IloDispatcherGLS dgls(env, PenaltyFactor); 
	IloSearchSelector sel = IloMinimizeVar(env,dgls.getPenalizedCostVar()); 
	IloGoal move = IloSingleMove(env, rsol, nhood, dgls, sel, instantiateCost); 
	move = move && IloStoreBestSolution(env, best); 
	IloSolver solver = dispatcher.getSolver(); 
	IloCouple(nhood, dgls); 
 
	IloNum NbMoves=0; 
 	while (NbMoves<=MoveLimit) { 
		if (solver.solve(move)) { 
			fout << "Cost = "<<solver.getMin(cost) <<endl; 
		} 
		else { 
			fout <<" ----- "<<endl; 
			if (dgls.complete()) { 
				cout<<"exiting by break"<<endl; 
				break; 
			} 
		} 
		NbMoves = dispatcher.getNbOfMoves(); 
	} 
 
	IloDecouple(nhood, dgls); 
	IloGoal restoreSolution = IloRestoreSolution(env, best) && 
				  instantiateCost; 
	solver.solve(restoreSolution); 
	rsol.end(); 
	best.end(); 
} 
 
void improveWithTabu_TimeLimitVersion(IloDispatcher dispatcher, 
				      IloRoutingSolution solution, 
				      IloNHood nhood, 
				      ofstream& fout) { 
 
	IloNumVar cost = dispatcher.getCostVar(); 
	IloEnv env = dispatcher.getEnv(); 
	IloGoal instantiateCost = IloDichotomize(env, cost, IloFalse); 
	IloRoutingSolution rsol = solution.makeClone(env); 
	IloRoutingSolution best = solution.makeClone(env); 
	IloDispatcherTabuSearch dts(env, TabuTenure); 
 
	IloGoal move  = IloSingleMove(env, 
		                      rsol, 
				      nhood, 
				      dts, 
				      IloMinimizeVar(env, cost), 
				      instantiateCost); 
	move = move && IloStoreBestSolution(env,best); 
	IloSolver solver = dispatcher.getSolver(); 
 
	IloCouple(nhood, dts); 
	clock_t tStart = clock()/CLK_TCK, time = tStart;  
 
	IloInt Counter = 0; 
	while (time <= tStart + TimeLimit) {
	        //outputting information after every 5000 moves 
		if (Counter==5e3) { 
			Info(dispatcher, fout); 
			Counter=0; 
		}  
		if (solver.solve(move)) { 
			fout << "Cost = "<<solver.getMin(cost) <<endl; 
			Counter++; 
		} 
		else { 
			fout <<" ----- "<<endl; 
			if (dts.complete()) { 
				cout<<"exiting by break"<<endl; 
				break; 
			} 
		} 
		time = clock()/CLK_TCK; 
	} 
	IloDecouple(nhood, dts); 
	IloGoal restoreSolution = IloRestoreSolution(env, best) && 
				  instantiateCost; 
	solver.solve(restoreSolution); 
	rsol.end(); 
	best.end(); 
 
} 
 
void improveWithTabu_MoveLimitVersion(IloDispatcher dispatcher, 
				      IloRoutingSolution solution, 
				      IloNHood nhood, 
				      ofstream& fout) { 
 
	IloNumVar cost = dispatcher.getCostVar(); 
	IloEnv env = dispatcher.getEnv(); 
	IloGoal instantiateCost = IloDichotomize(env, cost, IloFalse); 
	IloRoutingSolution rsol = solution.makeClone(env); 
	IloRoutingSolution best = solution.makeClone(env); 
	IloDispatcherTabuSearch dts(env, TabuTenure); 
 
	IloGoal move  = IloSingleMove(env, 
		                      rsol, 
				      nhood, 
				      dts, 
				      IloMinimizeVar(env, cost), 
				      instantiateCost); 
	move = move && IloStoreBestSolution(env,best); 
	IloSolver solver = dispatcher.getSolver(); 
 
	IloNum NbMoves=0; 
 	while (NbMoves<=MoveLimit) { 
		if (solver.solve(move)) { 
			fout << "Cost = "<<solver.getMin(cost) <<endl; 
		} 
		else { 
			fout <<" ----- "<<endl; 
			if (dts.complete()) { 
				cout<<"exiting by break"<<endl; 
				break; 
			} 
		} 
		NbMoves = dispatcher.getNbOfMoves(); 
	} 
 
	IloGoal restoreSolution = IloRestoreSolution(env,best) && 
		                  instantiateCost; 
	solver.solve(restoreSolution); 
	rsol.end(); 
	best.end(); 
 
} 

 
int main(int argc, char* argv[]) { 
  IloEnv env; 
  try {

///////////////////////////////////////////////////////////////////////
//
// Reading in data
//
///////////////////////////////////////////////////////////////////////

	int i,j;
	ifstream infile; 
	ofstream outfile, outfile1; 
	TimeLimit = 0; 
	MoveLimit = 0; 
	IloBool StartFlag;
	IloInt OriginalDropTime, OriginalDepotDropTime;
    char * problem; 
	char * output; 
	char * output1; 
    if (argc == 14) { 
		problem = argv[1]; 
		output  = argv[2]; 
		output1  = argv[3]; 
		nbOfTrucks = atoi(argv[4]);
		nbOfVisits = atoi(argv[5]);
		capacity = atoi(argv[6]);
		TypeOfMethod = atoi(argv[7]); 
		if (TypeOfMethod==0) PenaltyFactor = atof(argv[8]); 
		else TabuTenure = atoi(argv[8]); 
		if (atoi(argv[9])==1)  
		{ 
			TimeLimit=atoi(argv[10]); 
		} 
		else  
		{ 
			MoveLimit=atoi(argv[10]); 
		} 

		OriginalDropTime = atoi(argv[11]);
		OriginalDepotDropTime = atoi(argv[12]);
		StartFlag = atoi(argv[13]);
	} 
    else { 
		env.out() <<"Usage: <file_name>.exe <datafile> <resfile> <stat_file>\n"; 
		env.out() <<"       NbTrucks NbVisits Capacity\n";
		env.out() <<"       TypeOfMethod <0-GLS,1-TS> SearchParam <penalty for GLS, tenure for TS>\n"; 
		env.out() <<"       Limit <0-move, 1-time> LimitValue <integer>\n";
		env.out() <<"       DropTime DepotDropTime <start_flag>\n"; 
		return 0; 
	} 

	infile.open(problem, ios::in); 
	outfile.open(output, ios::out); 
	if (StartFlag) {
		outfile1.open(output1, ios::out); 
	} else {
		outfile1.open(output1, ios::app); 
	}

 
    if (!infile) {  
      env.out() << "File not found or not specified: " << problem << endl; 
      env.end(); 
      return 0; 
    } 
    if (!outfile) {  
      env.out() << "Cannot open file for output: " << output << endl; 
      env.end(); 
      return 0; 
    } 

//////////////////////////////////////////////////////////////////////////////////////////////////////////////
	IloInt size = nbOfVisits+1;
	DistanceMatrix = new (env) IloNum * [size];
	for (i=0;i<size;i++) {
		DistanceMatrix[i] = new IloNum [size];
	}
	for (i=0;i<size;i++) {
		for (j=0;j<size;j++) {
			DistanceMatrix[i][j]=0;
		}
	}

	for (int ctr = 0;ctr<size*size; ctr++) {
		div_t n = div(ctr,size);
		infile >> DistanceMatrix[n.quot][n.rem];
	}
	for (i=0;i<size;i++) {
		for (j=0;j<size;j++) {
			outfile<<DistanceMatrix[i][j]<<"\t";
		}
		outfile<<endl;
	}

    //////////////////////////////////////////////////////////////////////
    //
    // Creating a model 
    //
    //////////////////////////////////////////////////////////////////////
    IloModel mdl(env); 

	//creating an instance (an object) of my subclass:
	MyDistanceI* DistanceByMatrixObj = new (env) MyDistanceI(env);

    IloDimension2 time(env, DistanceByMatrixObj, IloTrue, "Time"); 
	// IloDimension2 time(env, IloEuclidean, IloTrue, "Time"); 
	// IloTrue, because we post ctrnts on time and time
	// is not in the cost function
	mdl.add(time);

	IloDimension2 length(env, DistanceByMatrixObj, IloFalse, "Length");
	//Be it IloTrue or IloFalse, since this dimension acts in the cost
	//function, constraints on distance will be posted correctly
	//we post IloTrue, which means that in the output file we'll
	//be able to see how distance alone changes from customer to customer
	//even though it is more CPU-time consuming.
	mdl.add(length);

    IloDimension1 weight(env, "Weight"); 
	mdl.add(weight);
 
	char str[9]; 
	//cout <<"Problem "<<problem<<" has been solved since "<<_strtime(str)<<endl; 
 
    /////////////////////////////////////////////////////////////////
    //
    // Setting the number of customers (i.e. visits) and trucks
    // as well as the capacity of a truck; and then reading data in
    //
    /////////////////////////////////////////////////////////////////

    IloNum depotX, depotY, openTime, closeTime, rubbish, depotDropTime; 
    infile >> rubbish >> depotX  >> depotY >> rubbish >> openTime >> closeTime >> depotDropTime; 
	//distmatrfile >> rubbish >> depotX  >> depotY >> rubbish >> openTime >> closeTime >> rubbish; 
 
	outfile<<"Solutions to "<<problem<<endl; 
	if (TypeOfMethod==0)  
		outfile<<"GLS penalty factor = "<<PenaltyFactor<<endl; 
	else  
		outfile<<"Tabu tenure = "<<TabuTenure<<endl; 
	outfile<<endl; 
	outfile<<"nbOfVisits = "<<nbOfVisits<<endl; 
	outfile<<"nbOfTrucks = "<<nbOfTrucks<<endl; 
	outfile<<"capacity = "<<capacity<<endl; 
	outfile<<"depotX = "<<depotX<<endl; 
	outfile<<"depotY = "<<depotY<<endl; 
	outfile<<"openTime = "<<openTime<<endl; 
	outfile<<"closeTime = "<<closeTime<<endl; 

	IloInt SummedDuration = 0;
 
    IloNode depot(env, depotX, depotY, 0, "0");
    for (j = 0; j < nbOfTrucks; j++) { 
      IloVisit first(depot, "Depot"); 
      mdl.add(first.getCumulVar(time) >= openTime); 
      mdl.add(first.getDelayVar(time) == depotDropTime); //may be non-zero (after transformation)
	  SummedDuration +=depotDropTime;
      IloVisit last(depot, "Depot"); 
      mdl.add(last.getCumulVar(time) <= closeTime); 
      mdl.add(last.getDelayVar(time) == depotDropTime); //may be non-zero (after transformation)
	  SummedDuration +=depotDropTime;
      char name[16]; 
      sprintf(name, "Vehicle %d", j); 
      IloVehicle vehicle(first, last, name); 
      vehicle.setCost(length, 1.0); 
      vehicle.setCapacity(weight, capacity); 
      mdl.add(vehicle); 
    } 
    for (i = 0; i < nbOfVisits; i++) { 
      IloInt id; // visit identifier 
      IloNum x, y, quantity, minTime, maxTime, dropTime; 
      infile >> id >> x >> y >> quantity >> minTime >> maxTime >> dropTime; 
      char name[16]; 
      sprintf(name, "%d", id); 
	  //cout<<"name = "<<name<<" id = "<<id<<endl;
	  IloNode customer(env, x, y, 0, name);
      IloVisit visit(customer, name); 
      mdl.add(visit.getDelayVar(time) == dropTime); 
      mdl.add(visit.getTransitVar(weight) == quantity); 
      mdl.add(minTime <= visit.getCumulVar(time) <= maxTime); 
      mdl.add(visit);  
  	  SummedDuration +=dropTime;
    } 
    infile.close(); 
    IloSolver solver(mdl); 
    IloDispatcher dispatcher(solver); 
    IloRoutingSolution solution(mdl); 


    ////////////////////////////////////////////////
    //
    // constructing the 1st solution with savings
    //
    ////////////////////////////////////////////////
  
    IloGoal instantiateCost = IloDichotomize(env,  
		                                     dispatcher.getCostVar(), 
											 IloFalse); 
    IloGoal restoreSolution = IloRestoreSolution(env, solution); 
    IloGoal goal = IloSavingsGenerate(env) && instantiateCost; 
    if (!solver.solve(goal)) { 
      solver.out() << "A first solution can't be constructed. Try to add more vehicles." << endl; 
      return 0; 
    } 
 
    ///////////////////////////////////////////
    //
    // outputting the first solution 
    //
    ///////////////////////////////////////////

    Info(dispatcher,outfile);

	IloNum trueCost = dispatcher.getTotalCost();

	trueCost += SummedDuration + (dispatcher.getNbOfVehiclesUsed() - 1)*2*depotDropTime
		        - OriginalDropTime*nbOfVisits 
				- (dispatcher.getNbOfVehiclesUsed() - 1)*2*OriginalDepotDropTime;

	outfile1<<dispatcher.getNbOfVehiclesUsed()<<" "//<<dispatcher.getTotalCost()<<"/"
		    <<trueCost<<"   ";
//	exit(1); 
    solution.store(solver); 

    ////////////////////////////////////////////////
    //
    // constructing the neighbourhood of a solution
    //
    ////////////////////////////////////////////////

    IloNHood nhood = IloTwoOpt(env) 
		   + IloOrOpt(env) 
		   + IloRelocate(env) 
		   + IloExchange(env) 
		   + IloCross(env); 

	IloGoal improve = IloSingleMove(env,
		                            solution,
									nhood,
									IloImprove(env),
									IloFirstSolution(env),
									instantiateCost);
 
    ////////////////////////////////////////////////
    //
    // improving the first solution
    //
    ////////////////////////////////////////////////

    if (TypeOfMethod==0)  
    { 
      if (TimeLimit>0)  
      { 
	improveWithGLS_TimeLimitVersion(dispatcher,solution,nhood,outfile); 
      } 
      else  
      { 
	improveWithGLS_MoveLimitVersion(dispatcher,solution,nhood,outfile); 
      } 
    } 
    else  
    { 
      if (TimeLimit>0)  
      { 
        improveWithTabu_TimeLimitVersion(dispatcher,solution,nhood,outfile); 
      } 
      else 
      { 
		improveWithTabu_MoveLimitVersion(dispatcher,solution,nhood,outfile); 
      } 
    }

    ///////////////////////////////////////////
    //
    // outputting the improved solution 
    //
    ///////////////////////////////////////////

    Info(dispatcher,outfile); 
	trueCost = dispatcher.getTotalCost();
	trueCost += SummedDuration + (dispatcher.getNbOfVehiclesUsed() - 1)*2*depotDropTime
		        - OriginalDropTime*nbOfVisits 
				- (dispatcher.getNbOfVehiclesUsed() - 1)*2*OriginalDepotDropTime;
	outfile1<<dispatcher.getNbOfVehiclesUsed()<<" "//<<dispatcher.getTotalCost()<<"/"
		<<trueCost<<endl;


  } catch(IloException& ex) { 
    cerr << "Error: " << ex << endl; 
  }  
  env.end(); 
  return 0; 
}