#include <ildispat/ilodispatcher.h>

ILOSTLBEGIN

IloInt TimeLimit;
IloInt MoveLimit;
const IloInt MaxSize = 400;
IloNum PenaltyFactor;
IloInt TabuTenure;
IloBool TypeOfMethod;//0-LS,1-GLS;

IloInt nbOfVisits, nbOfTrucks, nbOfJobs;
IloNum* durations;
IloInt* resourceNumbers;
IloNum** DistanceMatrix;

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

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

void MyDistanceI::getDistanceMatrix(IloNum**& _distanceMatrix, 
									IloNum*& durations,
									IloInt nbOfTrucks,
									IloInt nbOfJobs) {
/*	IloInt size = nbOfVisits+1;
	//cout<<"size = "<<size<<endl;
	_distanceMatrix = new (_env) IloNum * [size];
	for (int i=0;i<size;i++) {
		_distanceMatrix[i] = new (_env) IloNum [size];
	}
	for (i=0;i<size;i++) {
		for (int j=0;j<size;j++) {
			_distanceMatrix[i][j]=0.0;
		}
	}
*/
/*	_distanceMatrix[0][0] = 0;
	_distanceMatrix[0][1] = sqrt(2);
	_distanceMatrix[0][2] = sqrt(2);
	_distanceMatrix[0][3] = sqrt(2);

	_distanceMatrix[1][0] = sqrt(2);
	_distanceMatrix[1][1] = 0;
	_distanceMatrix[1][2] = 2.0;
	_distanceMatrix[1][3] = 2*sqrt(2);

	_distanceMatrix[2][0] = sqrt(2);
	_distanceMatrix[2][1] = 2.0;
	_distanceMatrix[2][2] = 0;
	_distanceMatrix[2][3] = 2.0;

	_distanceMatrix[3][0] = sqrt(2);
	_distanceMatrix[3][1] = 2.0*sqrt(2);
	_distanceMatrix[3][2] = 2.0;
	_distanceMatrix[3][3] = 0;
*/

	
	IloInt i, j, nbOfVisits = nbOfTrucks*nbOfJobs;
	cout<<"nbOfTrucks = "<<nbOfTrucks<<endl;
	cout<<"nbOfJobs = "<<nbOfJobs<<endl;
	cout<<"nbOfVisits = "<<nbOfVisits<<endl;

  IloBool flag = IloFalse;;
	for (i=1;i<nbOfVisits+1;i++) {
		//if (durations[i-1]>1) {
			//durations[i-1] = IloCeil(0.5*durations[i-1]);
//			durations[i-1] = 0.5*durations[i-1];
			//flag = IloTrue;
		//}
		for (j=1;j<nbOfVisits+1;j++) {
			if (i==j) continue;
			//if (flag) {
				DistanceMatrix[i][j] += 0.5*durations[i-1];
				DistanceMatrix[j][i] += 0.5*durations[i-1];
			//}
		}
	}

	cout<<"Distance Matrix after transformation"<<endl;
	for (i=0;i<nbOfVisits+1;i++) {
		for (j=0;j<nbOfVisits+1;j++) {
			cout<<"Dist["<<i<<"]["<<j<<"] = "<<DistanceMatrix[i][j]<<" ";
		}
		cout<<endl;
	}
//	for (i=0;i<nbOfVisits;i++) {
//		durations[i] = 0.25*durations[i];
//	}

}


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

//	MyDistanceI* dist = new (_env) MyDistanceI(_env);
//	dist->getDistanceMatrix(dist->_distanceMatrix,durations,nbOfTrucks,nbOfJobs);


//	return 20;
	IloInt index1 = 0, index2 = 0;
	char buffer1[28], buffer2[28], buffer[28];
//	cout<<node1<<endl;
//	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 //dist->
		DistanceMatrix[index1][index2];
}



void Info(IloDispatcher dispatcher, ofstream& outfile) {
  IloSolver solver = dispatcher.getSolver();
  outfile<< "===============" << endl
	       << "Cost         : " << dispatcher.getTotalCost() << endl 
	       << "Number of vehicles used : " 
	       << dispatcher.getNbOfVehiclesUsed() << endl
	       << "Solution     : " << endl
	       << IloVerbose(dispatcher) << endl;
}


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

    ///////////////////////////////////////////////////////////////////////////////////
	//
	// INPUT/OUTPUT
	//
    ///////////////////////////////////////////////////////////////////////////////////


    ifstream infile;
	ofstream outfile;
    char * problem;
	char * output;
	IloInt UserTime,Step;
	IloBool firstAccept;

    if (argc == 7) {
		problem = argv[1];
		output  = argv[2];
		TypeOfMethod = atoi(argv[3]);
		if (TypeOfMethod!=0) {
			cout<<"For GLS you have to input 8 parameters!"<<endl;
			return 0;
		}
		firstAccept = atoi(argv[4]);
		UserTime = atoi(argv[5]);
		Step = atoi(argv[6]);
	}

    if (argc == 9) {
		problem = argv[1];
		output  = argv[2];
		TypeOfMethod = atoi(argv[3]);
		if (TypeOfMethod!=1) {
			cout<<"For LS you have to input 6 parameters!"<<endl;
			return 0;
		}
		firstAccept = atoi(argv[4]);;
		PenaltyFactor = atof(argv[5]);
		MoveLimit=atoi(argv[6]);
		UserTime = atoi(argv[7]);
		Step = atoi(argv[8]);
	}

    if (argc!=7 && argc!=9) {
		env.out() << endl;
		env.out() <<"Usage: <filename>.exe <datafile_name> <resfile_name>\n";
		env.out() <<"       TypeOfMethod <0-LS,1-GLS>\n";
		env.out() <<"       Strategy <1-first accept, 0 - best accept>\n";
		env.out() <<"       Penalty <for GLS only>\n";
		env.out() <<"       MoveLimitValue <for GLS only, int>\n";
		env.out() <<"       Deadline <int> DeadlineStep <int>\n";
		return 0;
	}

	infile.open(problem);
	outfile.open(output, ios::out);

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

	infile>>nbOfJobs;
	infile>>nbOfTrucks;
	nbOfVisits = nbOfJobs*nbOfTrucks;

//	IloInt* resourceNumbers;
	resourceNumbers = new IloInt[MaxSize];
//	IloNum* durations;
	durations = new IloNum[MaxSize];
	for (int i=0;i<MaxSize;i++) {
		resourceNumbers[i] = 0;
		durations[i] = 0;
	}

    IloInt index=0;
	for (i=0;i<nbOfJobs;i++) {
		for (int j=0;j<nbOfTrucks;j++) {
			infile>>resourceNumbers[index];
			infile>>durations[index];
			index++;
		}
	}

	outfile<<endl;
	outfile<<"resourceNumbers:"<<endl;
	index = 0;
	for (i=0;i<nbOfTrucks*nbOfJobs;i++) {
		outfile<<resourceNumbers[i]<<" ";
		index++;
		if (index==nbOfTrucks) {
			outfile<<endl;
			index=0;
		}
	}
	outfile<<endl;
	outfile<<"durations:"<<endl;
	for (i=0;i<nbOfTrucks*nbOfJobs;i++) {
		outfile<<durations[i]<<" ";
		index++;
		if (index==nbOfTrucks) {
			outfile<<endl;
			index=0;
		}
	}

    infile.close();
	outfile<<"Solutions to "<<problem<<endl;
	if (TypeOfMethod==0) {
		outfile<<"Strategy = ";
		if (firstAccept) outfile<<"First Accept"<<endl;
		else outfile<<"Best Accept"<<endl;
		outfile<<"DeadlineStep = "<<Step<<endl;
	}
	if (TypeOfMethod==1) {
		outfile<<"GLS penalty factor = "<<PenaltyFactor<<endl;
		outfile<<"MoveLimitValue = "<<MoveLimit<<endl;
		outfile<<"Strategy = ";
		if (firstAccept) outfile<<"First Accept"<<endl;
		else outfile<<"Best Accept"<<endl;
		outfile<<"DeadlineStep = "<<Step<<endl;
	}
	outfile<<endl;


    ///////////////////////////////////////////////////////////////////////////////////
	//
	// MODEL
	//
    ///////////////////////////////////////////////////////////////////////////////////

	//performing transformations of the original problem
	//to produce transition times = distances between activities = customers.
	//Hopefully, this is going to help the routing technique
	IloBool noTransformation = IloFalse;

	if (noTransformation) {
		outfile<<"NO TRANSFORMATION OF THE DATA"<<endl;
	} else {
		outfile<<"THE DATA WILL BE TRANSFORMED"<<endl;
	}

	//introducing a Concert technology model
    IloModel mdl(env);

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

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

	if (!noTransformation) {
		DistanceByMatrixObj->getDistanceMatrix(DistanceMatrix,
			                                   durations,
											   nbOfTrucks,
											   nbOfJobs);

		outfile<<endl;
		outfile<<"durations after transformations:"<<endl;
		for (i=0;i<nbOfTrucks*nbOfJobs;i++) {
			outfile<<durations[i]<<" ";
			index++;
			if (index==nbOfTrucks) {
				outfile<<endl;
				index=0;
			}
		}
	}


	//setting parameters of our model

	//dimensions

    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, IloTrue, "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 tardiness(env, IloFalse, "Tardiness");
	mdl.add(tardiness);

	//ccordinates of depot (all zero)
    IloNum depotX=0, depotY=0, openTime=0;

	//arrays of vehicles and visits
	IloVehicleArray vehicles(env,nbOfTrucks);
	IloVisitArray visits(env,nbOfTrucks*nbOfJobs);

	//nodes: depot
    IloNode depot(env, depotX, depotY, 0, "0");

	//deadline variable
    IloNumVar closeTime(env,0,IloInfinity,ILOINT);
	mdl.add(closeTime);

	//creating vehicles with first and last visits on them
	//introducing tardiness as cost
    for (IloInt j = 0; j < nbOfTrucks; j++) {
  	  
	  IloVisit first(depot, "Depot");
      
	  mdl.add(first.getCumulVar(time) >= openTime);
	  
	  mdl.add(first.getTransitVar(tardiness) == 0);
      
	  IloVisit last(depot, "Depot");
      
	  IloNumVar tard(env,0,IloInfinity,ILOINT);
	  
	  mdl.add(tard >= last.getCumulVar(time) - closeTime);
	  
	  mdl.add(last.getTransitVar(tardiness) == tard);
      
	  char name[16];
      
	  sprintf(name, "Vehicle %d", j);
      
	  IloVehicle vehicle(first, last, name);
      
	  vehicles[j]=vehicle;
      
	  vehicle.setCost(tardiness, 1.0);

	  vehicle.setCost(length,0.001);

	  mdl.add(vehicle);
    }


	char buffer[28];
	//creating customer visits
	for (i = 0; i < nbOfTrucks*nbOfJobs; i++) {

		IloInt id=i+1; 

		//coordinates of customers (all zero)
		IloNum x=0, y=0;

		sprintf(buffer,"%d",i+1);

		IloNode customer(env, x, y, 0, buffer);

		char name[16];

		sprintf(name, "%d", id);

		IloVisit visit(customer, name);

		if (noTransformation) {
			mdl.add(visit.getDelayVar(time) == durations[i]);
		} else {
			mdl.add(visit.getDelayVar(time) == 0);
		}

		mdl.add(visit.getTransitVar(tardiness) == 0);

	    mdl.add(visit.getCumulVar(time) >= openTime);

	    mdl.add(visit.getCumulVar(time) <= closeTime);

  		visits[i] = visit;

		mdl.add(visit); 
	}
    
	//Imposing vehicle-visit constraints (from job shop
	//we know all vehicle assignments
	for (i=0;i<nbOfTrucks*nbOfJobs; i++) {
		mdl.add(visits[i].getVehicleVar()==vehicles[resourceNumbers[i]]);
	}


	//Imposing precedence constraints (from job shop
	//we know precedences within jobs
	if (noTransformation) {
		for (i=0;i<nbOfJobs;i++) {
			for (j=0;j<nbOfTrucks-1; j++) {
				IloInt index = i*nbOfTrucks+j;
				mdl.add(visits[index].getCumulVar(time)+durations[index]<=
					    visits[index+1].getCumulVar(time));
			}
		}
	} else {
		for (i=0;i<nbOfJobs;i++) {
			for (j=0;j<nbOfTrucks-1; j++) {
				IloInt index = i*nbOfTrucks+j;
				mdl.add(visits[index].getCumulVar(time)+durations[index]<=
					    visits[index+1].getCumulVar(time));
			}
		}
	}

	//constraining our deadline to be less than or equal to
	//our first guess
	mdl.add(closeTime <= UserTime);

    ///////////////////////////////////////////////////////////////////////////////////
	//
	// PARAMETERS OF SOLVING TECHNIQUE
	//
    ///////////////////////////////////////////////////////////////////////////////////

	//extracting the model into solver
    IloSolver solver(mdl);
	//introducing a dispatcher object
    IloDispatcher dispatcher(solver);
	//introducing a solution object that stores the routing plan
    IloRoutingSolution solution(mdl);

	IloBool SimpleLocalSearch,
		    GuidedLocalSearch;

	if (TypeOfMethod==0) {
		SimpleLocalSearch = IloTrue;
		GuidedLocalSearch = IloFalse;
	} else {
		SimpleLocalSearch = IloFalse;
		GuidedLocalSearch = IloTrue;
	}


	////////////////////////////////////////////////////
	//
	// Getting the first solution
	//
	////////////////////////////////////////////////////

	IloNumVar cost = dispatcher.getCostVar();

	//our search goal: get the value of cost
    IloGoal instantiateCost = IloDichotomize(env, cost, IloFalse);
	//restoring solutions will be necessary in local search
    IloGoal restoreSolution = IloRestoreSolution(env, solution);
	//this goal is to get a first solution by savings and its cost
    IloGoal goal = IloInsertionGenerate(env) && instantiateCost;
    //IloGoal goal = AdditionGenerate(env,time) && instantiateCost;

	//if we can't get a first solution -> quit
    if (!solver.solve(goal)) {
		solver.out() << "Couldn't generate first solution! Try and change your deadline value";
	    return 0;
    }

	//outputting the first solution
	outfile<<"Deadline: "<<UserTime<<"\tCost: "<<dispatcher.getTotalCost()<<endl;
	cout<<"Deadline: "<<UserTime<<"\tCost: "<<dispatcher.getTotalCost()<<endl;
    Info(dispatcher,outfile);


//	return 0;



	//creating a neighbourhood
	IloNHood nhood = IloTwoOpt(env)
	  	           + IloOrOpt(env)
				   + IloRelocate(env)
				   + IloCross(env)
				   + IloExchange(env);

	//goal to locally improve the solution, first accept

	IloGoal move, moveGLS;

	IloDispatcherGLS dgls(env,PenaltyFactor);
	
	IloSearchSelector selGLS = IloMinimizeVar(env, dgls.getPenalizedCostVar()),
		              firstGLS = IloFirstSolution(env),
		              sel    = IloMinimizeVar(env, cost);
	

    //improving solutions, moving around in their neighbourhoods

	//////////////////////////////////////////////////////
	//
	// LOOP: Local Search
	//
	//////////////////////////////////////////////////////

	if (SimpleLocalSearch) {

		if (firstAccept) {
			move = IloSingleMove(env,
				                 solution,
								 nhood,
								 IloImprove(env),
								 IloFirstSolution(env),
								 instantiateCost);
		} else {
			//i.e. the best-accept strategy
			move = IloSingleMove(env,
								 solution,
								 nhood,
								 IloImprove(env),
								 sel,
								 instantiateCost);
		}

		IloInt ctr = 0; IloNum prevCost=0, storeCost = 0;

		while (true) {

			//resetting the neighbourhood;
			nhood.reset();

			//storing the solution
			solution.store(solver);

			while (solver.solve(move)) {
				//cout<<"ctr = "<<ctr<<endl;
				cout<<"ctr = "<<ctr<<"\tDeadline: "<<UserTime<<"\tCost: "<<dispatcher.getTotalCost()<<endl;
			}

			//restoring the untouched variables by local search 
			solver.solve(IloRestoreSolution(env, solution));
			//outputting the modified solution
			outfile<<"Deadline: "<<UserTime<<"\tCost: "<<dispatcher.getTotalCost()<<endl;
			cout<<"ctr = "<<ctr<<"\tDeadline: "<<UserTime<<"\tCost: "<<dispatcher.getTotalCost()<<endl;
			Info(dispatcher,outfile);
			outfile<<endl;
			outfile<<endl;
			outfile<<endl;
			outfile<<endl;
			prevCost=dispatcher.getTotalCost();
			if (storeCost<prevCost && storeCost!=0) {
				cout<<"point0: break"<<endl;
				break;
			}

			//if (dispatcher.getTotalCost()!=0) break;
			if (dispatcher.getTotalCost()>=1.0) {
//				cout<<"point0"<<endl;
//				cout<<"prevCost = "<<prevCost<<endl;
				if (abs(dispatcher.getTotalCost()-prevCost)==0) {
					//In the hope that we can improve this solution	
					//resetting the neighbourhood;
					nhood.reset();
					solution.store(solver);
					IloBool failure = IloTrue;
					cout<<"point1"<<endl;
					while (solver.solve(move)) {
						//cout<<"ctr = "<<ctr<<endl;
						failure = IloFalse;
//						cout<<"*******"<<endl;
//						cout<<"ctr = "<<ctr<<"\tDeadline: "<<UserTime<<"\tCost: "<<dispatcher.getTotalCost()<<endl;
					}
					if (failure) {
						cout<<"point 1: break"<<endl;
						break;
					}
				}
			}

			prevCost=dispatcher.getTotalCost();
			storeCost = prevCost;

			//reducing the deadline and recalculating cost
			mdl.remove(closeTime <= UserTime);

			UserTime=UserTime-Step;
			
			mdl.add(closeTime <= UserTime);
			
			solver.extract(mdl);

			if (!solver.solve(IloRestoreSolution(env,solution)&&instantiateCost)) {
				solver.out() << "Couldn't generate a subsequent solution!";
				return 0;
			}
			outfile<<"Deadline: "<<UserTime<<"\tCost: "<<dispatcher.getTotalCost()<<endl;
			cout<<"ctr = "<<ctr<<"\tDeadline: "<<UserTime<<"\tCost: "<<dispatcher.getTotalCost()<<endl;
			Info(dispatcher,outfile);
			ctr++;
		}
	}

	if (GuidedLocalSearch) {

		IloInt ctr = 0;

		while (true) {

			//resetting the neighbourhood;
			nhood.reset();
			dgls.reset();

			solution.store(solver);

			IloRoutingSolution rsol = solution.makeClone(env),
			                   best = solution.makeClone(env);

			if (firstAccept) {
				moveGLS = IloSingleMove(env,
									 rsol,
									 nhood,
									 dgls,
									 firstGLS,
									 instantiateCost) 
						  && IloStoreBestSolution(env, best);
			} else {
				//i.e. the best-accept strategy
				moveGLS = IloSingleMove(env, 
									rsol, 
									nhood, 
									dgls, 
									sel, 
									instantiateCost) 
			  			  && IloStoreBestSolution(env, best);
			}

			IloCouple(nhood, dgls);

			IloNum NbMoves=0;
 			while (NbMoves<=MoveLimit) {
				if (solver.solve(moveGLS)) {
					cout << "Cost = "<<solver.getMin(cost) <<endl;
				}
				else {
					cout <<" ----- "<<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);
				
			cout<<"ctr = "<<ctr<<"\tDeadline: "<<UserTime<<"\tCost: "<<dispatcher.getTotalCost()<<endl;
			outfile<<"Deadline: "<<UserTime<<"\tCost: "<<dispatcher.getTotalCost()<<endl;
			Info(dispatcher,outfile);
			outfile<<endl;
			outfile<<endl;
			outfile<<endl;
			outfile<<endl;

			if (dispatcher.getTotalCost()!=0) break;

			//reducing the deadline and recalculating cost
			mdl.remove(closeTime <= UserTime);

			UserTime=UserTime-Step;
			
			mdl.add(closeTime <= UserTime);
			
			solver.extract(mdl);

			if (!solver.solve(IloRestoreSolution(env,best)&&instantiateCost)) {
				solver.out() << "Couldn't generate a subsequent solution!";
				return 0;
			}
			outfile<<"Deadline: "<<UserTime<<"\tCost: "<<dispatcher.getTotalCost()<<endl;
			cout<<"ctr = "<<ctr<<"\tDeadline: "<<UserTime<<"\tCost: "<<dispatcher.getTotalCost()<<endl;
			Info(dispatcher,outfile);
			rsol.end();
			best.end();
			ctr++;
		}
	}

  } catch(IloException& ex) {
    cerr << "Error: " << ex << endl;
  } 

  env.end();
  return 0;
}