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

// 5 December 2002

// corrected a bug in Dispatcher encoding of JSP: time windows for a visit!

//Keep it in case. This version is
//okay for working with VRPs etc up until pure JSPs (inclusive).

//In subsequent versions we will be updating
//the VRP opt criterion to work with pure JSPs
//and a VRP-like criterion (needed for symmetric experiments
//with swapped optim criteria in the area of pure JSPs.

ILOSTLBEGIN 

const IloInt MaxSize = 400;
const IloNum VehicleUsagePenalty = 0.0; 
const IloInt StartUserTime = 10000;

IloInt MoveLimit;
IloBool TypeOfMethod;//0-LS,1-GLS;
IloInt nbOfJobs;
IloNum TimeLimit; 
IloInt nbOfVisits;
IloInt nbOfTrucks;
IloInt capacity;
IloInt UserTime;
IloInt Step;
IloBool firstAccept;
IloNum Speed;
IloBool Redo;
//char TypeOfProblem[3];

bool activateAltVRPCriterion = false;

IloNum PenaltyFactor; 
IloInt TabuTenure; 
IloInt DiffNb,SameNb, PrecedenceNb;

IloBool VRPFlag = IloFalse;

IloNum openTime;
IloNum closeTime;

IloNum** DistMatr;
IloNum** VrpData;
IloNum* durations;
IloInt* resourceNumbers;
IloInt* DiffArr;
IloInt* SameArr;
IloInt* PrecedenceArr;

IloVisit ChooseCheapestVisit(IloDispatcher dispatcher,
							 IloVehicle vehicle,
							 IloVisit visit) {
	IloInt vehIndex = dispatcher.getIndex(vehicle);
	IlcIntVar nextVar = dispatcher.getNextVar(visit);
	IloVisit bestVisit;
	IloNum bestCost = IloInfinity;
	for (IlcIntExpIterator iter(nextVar); iter.ok();++iter) {
		IloVisit v = dispatcher.getVisit(*iter);
		IloNum cost = dispatcher.getCost(visit,v,vehicle);
		IlcIntVar vehicleVar = dispatcher.getVehicleVar(v);
		if (cost < bestCost 
			&& !v.isFirstVisit()
			&& !v.isLastVisit()
			&& vehicleVar.isInDomain(vehIndex)) {
			bestVisit = v;
			bestCost = cost;
			break;
		}
	}
	return bestVisit;
}

ILCGOAL3 (AddArcTestGoal,
		  IloVisit&, visit1,
		  IloVisit&, visit2,
		  IloVehicle&, vehicle) {
	IloSolver solver = getSolver();
	IloDispatcher dispatcher(solver);
	dispatcher.setNext(visit1,visit2);
	return IloLimitSearch(solver,
		                  IloGenerateRoute(solver,vehicle),
						  IloFailLimit(solver,100));
}

ILCGOAL1(VehicleAdditionGenerate,IloVehicle,vehicle) {
	IloSolver solver = getSolver();
	IloDispatcher dispatcher(solver);
	IloVisit visit1 = vehicle.getFirstVisit();
	IloVisit visit2 = ChooseCheapestVisit(dispatcher, vehicle, visit1);
	IlcGoal testGoal = AddArcTestGoal(solver,visit1, visit2, vehicle);
	while (visit2.getImpl() != 0) {
		if (solver.solve(testGoal,IloTrue)) {
			dispatcher.setNext(visit1,visit2);
			visit1 = visit2;
		} else {
			solver.add(dispatcher.getNextVar(visit1) != dispatcher.getIndex(visit2));
		}
		visit2 = ChooseCheapestVisit(dispatcher,vehicle,visit1);
	}
	solver.solve(IloGenerateRoute(solver,vehicle));
	return 0;
}

IloVehicle ChooseCheapestVehicle(IloDispatcher dispatcher,
								 IloDimension dim) {
	IloEnv env = dispatcher.getEnv();
	IloVehicle bestVehicle;
	IloNum bestCostCoef = IloInfinity;
	for (IloIterator<IloVehicle> vehIter(env);vehIter.ok();++vehIter) {
		IloVehicle vehicle = *vehIter;
		IloNum coef = vehicle.getCost(dim);
		if (coef < bestCostCoef && 
			!dispatcher.isRouteComplete(vehicle)) {
			bestVehicle = vehicle;
			bestCostCoef = coef;
			break;
		}
	}
	return bestVehicle;
}

ILCGOAL0 (UnperformVisits) {
	IloSolver solver = getSolver();
	IloDispatcher dispatcher(solver);
	IloEnv env = dispatcher.getEnv();
	for (IloIterator<IloVisit> visIter(env);visIter.ok();++visIter) {
		IloVisit visit = *visIter;
		if (!dispatcher.getVehicleVar(visit).isBound())
			solver.add(dispatcher.unperformed(visit));
	}
	return 0;
}

ILCGOAL1(AdditionGenerate, IloDimension, dim) {
	IloSolver solver = getSolver();
	IloDispatcher dispatcher(solver);
	dispatcher.setFilterLevel(IlcBasic);
	IloVehicle vehicle = ChooseCheapestVehicle(dispatcher,dim);
	if (vehicle.getImpl() == 0) return UnperformVisits(solver);
	return IlcAnd(VehicleAdditionGenerate(solver,vehicle), this);
}

ILOCPGOALWRAPPER1(MyAdditionGenerate,solver,IloDimension,dim) {
	return AdditionGenerate(solver,dim);
}

inline int myRound(double x) {
	return (int) (x+0.5);
}

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

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

void MyDistanceI::getDistanceMatrix(IloNum** DistanceMatrixExternal){
	int i,j;

	_distanceMatrix = new IloNum* [nbOfVisits+1];
	for (i=0;i<nbOfVisits+1;i++) {
		_distanceMatrix[i] = new IloNum [nbOfVisits+1];
	}

	for (i=0;i<nbOfVisits+1;i++) {
		for (j=0;j<nbOfVisits+1;j++) {
			_distanceMatrix[i][j] = DistanceMatrixExternal[i][j]; 
		}
	}
}


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

	IloInt index1 = 0, index2 = 0;
	char buffer1[28], buffer2[28], buffer[28];
	sprintf(buffer1,node1.getName());
	sprintf(buffer2,node2.getName());
	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;
	}
	return _distanceMatrix[index1][index2];
}

void GetMakespan(IloSolver solver, IloNumVarArray DepotTimeArr, IloInt& makespan) {
  makespan = 0;
  for (int i=0;i<nbOfTrucks;i++) {
	  if (solver.getFloatVar(DepotTimeArr[i]).getMin()>makespan) {
		  makespan = solver.getFloatVar(DepotTimeArr[i]).getMin();
	  }
  }

}

void Info(IloDispatcher dispatcher, 
		  char*& problem,
		  ofstream& fout,
		  ofstream& fout1,
		  ofstream& fout2, 
		  IloDimension time,
		  IloNumVarArray DepotTimeArr,
		  IloInt nbOfTrucks,
		  IloInt depotDropTime,
		  IloBool statisticsFlag) {
  IloSolver solver = dispatcher.getSolver();
  IloEnv env = solver.getEnv();

  IloInt makespan;
  GetMakespan(solver,DepotTimeArr,makespan);
  fout<< "===============" << endl
		   << "Makespan     : "<<makespan-depotDropTime<<endl
		   << "Cost         : "<<dispatcher.getTotalCost()<<endl
	       << "Number of vehicles used : " 
	       << dispatcher.getNbOfVehiclesUsed() << endl
	       << "Solution     : " << endl
//	       << IloVerbose(dispatcher) << endl;
           << dispatcher << endl;

  if (statisticsFlag) fout1<<dispatcher.getNbOfVehiclesUsed()<<" "<<makespan-depotDropTime<<" ";

  fout2<<problem<<endl;
  fout2<<makespan-depotDropTime<< endl;
  fout2<<dispatcher.getNbOfVehiclesUsed()<< endl;


  for (IloIterator<IloVehicle> wi(env); wi.ok(); ++wi) {
		IloVehicle vehicle  = *wi;
		if (dispatcher.getRouteSize(vehicle) != 0) {
			fout2<<vehicle.getName();
			for (IloDispatcher::RouteIterator ri(dispatcher,vehicle);
			                                  ri.ok();
											  ++ri) {
				IloVisit visit = *ri;
				if (!visit.isFirstVisit() && !visit.isLastVisit())
					fout2<<" "<<visit.getName();
			}
			fout2<<" -1"<<endl;
		}
	}

}


void Info(IloDispatcher dispatcher, ofstream& fout, ofstream& fout1, char*& problem) { 
	IloEnv env = dispatcher.getEnv();
	IloSolver solver = dispatcher.getSolver(); 

     fout<< "===============" << endl 
	       << "Cost         : " << dispatcher.getTotalCost()  - dispatcher.getNbOfVehiclesUsed()*VehicleUsagePenalty<< endl  
	       << "Number of vehicles used : "  
	       << dispatcher.getNbOfVehiclesUsed() << endl 
	       << "Solution     : " << endl 
	       << dispatcher << endl; 

	fout1<<problem<<endl;
    fout1<<dispatcher.getTotalCost() - dispatcher.getNbOfVehiclesUsed()*VehicleUsagePenalty<< endl;
    fout1<<dispatcher.getNbOfVehiclesUsed() << endl;

	for (IloIterator<IloVehicle> wi(env); wi.ok(); ++wi) {
		IloVehicle vehicle  = *wi;
		if (dispatcher.getRouteSize(vehicle) != 0) {
			fout1<<vehicle.getName();
			for (IloDispatcher::RouteIterator ri(dispatcher,vehicle);
			                                  ri.ok();
											  ++ri) {
				IloVisit visit = *ri;
				if (!visit.isFirstVisit() && !visit.isLastVisit())
					fout1<<" "<<visit.getName();
			}
			fout1<<" -1"<<endl;
		}
	}
} 

void ReadInSideConstraints(char * buf, 
						   IloInt*& Array, 
						   IloInt& NumberOfTasks,
						   FILE*& fin,
						   ofstream& fout) {


	char buf_read[30];

	fscanf(fin,"%s",&buf_read);
	if (strcmp(buf_read,buf)) {
		cout<<"There should be "<<buf<<" keyword in input file"<<endl;
		exit(1);
	}

	fscanf(fin,"%Ld",&NumberOfTasks);

	Array = new IloInt [2*NumberOfTasks];

	for (int i=0;i<2*NumberOfTasks;i++) {
		fscanf(fin,"%Ld",&Array[i]);
	}

}

void improveWithGLS_TimeLimitVersion(IloDispatcher dispatcher, 
                                     IloRoutingSolution solution, 
                                     IloNHood nhood, 
                                     ofstream& fout,
									 ofstream& fout1) { 
	IloNumVar cost = dispatcher.getCostVar(); 
	IloEnv env = dispatcher.getEnv(); 
	IloModel mdl  = dispatcher.getModel();
	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;  
	bool isIntermediateOutputPoint1Reached = false;
	bool isIntermediateOutputPoint2Reached = false;
	bool isIntermediateOutputPoint3Reached = false;
	bool isIntermediateOutputPoint4Reached = false;


	while (time <= tStart + TimeLimit) { 
		if (solver.solve(move)) { 
/*			fout << "Cost = "<<solver.getMin(cost) <<" time: "<<time<<endl; 

			if (time >= tStart + 600 && time <= tStart + 1200 && !isIntermediateOutputPoint1Reached) {
				isIntermediateOutputPoint1Reached = true;
				fout1 << dispatcher.getNbOfVehiclesUsed()<<" "<<solver.getMin(cost)<<" ";
			}
			if (time >= tStart + 1200 && time <= tStart + 1800 && !isIntermediateOutputPoint2Reached) {
				isIntermediateOutputPoint2Reached = true;
				fout1 << dispatcher.getNbOfVehiclesUsed()<<" "<<solver.getMin(cost)<<" ";
			}
			if (time >= tStart + 1800 && time <= tStart + 2400 && !isIntermediateOutputPoint3Reached) {
				isIntermediateOutputPoint3Reached = true;
				fout1 << dispatcher.getNbOfVehiclesUsed()<<" "<<solver.getMin(cost)<<" ";
			}
			if (time >= tStart + 2400 && time <= tStart + 3000 && !isIntermediateOutputPoint4Reached) {
				isIntermediateOutputPoint4Reached = true;
				fout1 << dispatcher.getNbOfVehiclesUsed()<<" "<<solver.getMin(cost)<<" ";
			}
*/		} 
		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 ImposeVehicleVisitConstraints(IloModel& mdl,
								   IloDimension2 time, 
								   const int nbOfTrucks,
						           int** arrayOfAllowedVehicles, 
								   IloVehicleArray& vehArr,
								   IloVisitArray& visArr,
								   ofstream& fout) {

	for (int i=0;i<nbOfVisits;i++) {
		for (int j=0;j<nbOfTrucks;j++) {
			bool allowed = false;
			for (int k=0;k<nbOfTrucks;k++) {
				if (j==arrayOfAllowedVehicles[i][k]-1) {
					allowed = true;
					break;
				}
			}
			if (!allowed) {
//				fout<<"activity "<<i<<" disallowes resource "<<j<<endl;
				mdl.add(visArr[i].getVehicleVar()!=vehArr[j]);
			}
	}
		}

	for (i=0;i<2*SameNb;i++) {
		if (i % 2 != 0) continue;
		mdl.add(visArr[SameArr[i]-1].getVehicleVar()==visArr[SameArr[i+1]-1].getVehicleVar());
	}	

/*	for (i=0;i<2*DiffNb;i++) {
		if (i % 2 != 0) continue;
		mdl.add(visArr[DiffArr[i]-1].getVehicleVar()!=visArr[DiffArr[i+1]-1].getVehicleVar());
	}	
*/
	for (i=0;i<2*PrecedenceNb;i++) {
		if (i % 2 != 0) continue;
		mdl.add((visArr[PrecedenceArr[i+1]-1].getPrevVar()==
			     visArr[PrecedenceArr[i]-1]) || 
				(visArr[PrecedenceArr[i]-1].getCumulVar(time) + 
				 visArr[PrecedenceArr[i]-1].getDelayVar(time)<= 
				 visArr[PrecedenceArr[i+1]-1].getCumulVar(time))); 
	}

}

void processComments(FILE* infile, char * & problem, int& ctr, char*& type) {
	
	char buf[80000];

	int i;
	ctr = 0;
	while (true) {
		fgets(buf,80000,infile);
		if (buf[0]!='#') {
			type = buf;
			ctr++;
			break;
		} else {
			ctr++;
		}
	}
	fclose(infile);

	if ((infile=fopen(problem,"r"))==NULL) {
		cout<<"Couldn't open"<<problem<<endl;
	}
	for (i=0;i<ctr;i++) {
		fgets(buf,80000,infile);
	}

}

ILOCPGOAL2(CheckTime,char*,nameOfProcess,clock_t,tStart) {

	clock_t	curTime = clock()/CLOCKS_PER_SEC;  
	char * nameOfProcess = "VrpDispat32.exe";
	if (curTime - tStart >TimeLimit) {
		KILL_PROC_BY_NAME(nameOfProcess);
	}
	return 0;
}

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

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



	int i,j;
	FILE* infile;
	ofstream outfile, outfile1, outfile2; 
	TimeLimit = 0; 
	IloBool StartFlag;
	char * problem; 
	char * output; 
	char * output1; 
	char * output2; 
	if (argc == 9) { 
		problem = argv[1]; 
		output  = argv[2]; 
		output1  = argv[3]; 
		output2  = argv[4]; 
		PenaltyFactor = atof(argv[5]); 
		TimeLimit=atoi(argv[6]); 
		StartFlag = atoi(argv[7]);
		Redo = (IloBool) atoi(argv[8]);
	} 
	else { 
		env.out() <<"Usage: <file_name>.exe <datafile> <resfile>\n";
		env.out() <<"       <statistics_file> <standFormatFile>\n"; 
		env.out() <<"       GLSPenalty TimeLimitValue <sec> StartFlag Redo\n";
		return 0; 
	} 

	if ((infile=fopen(argv[1],"r"))==NULL) {
		cout<<"Couldn't open "<<problem<<endl;
		return 0;
	}
	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; 
	} 
	if (!outfile1) {  
	  env.out() << "Cannot open file for output: " << output1 << endl; 
	  env.end(); 
	  return 0; 
	} 


	IloNum depotX, depotY;

	int ctr = 0;

	char * TypeOfProb;// = (char *) TypeOfProblem;
	processComments(infile,problem,ctr,TypeOfProb);

	fscanf(infile,"%d",&nbOfTrucks);
	fscanf(infile,"%d",&nbOfVisits);
	fscanf(infile,"%Lf",&Speed);
	fscanf(infile,"%Lf",&openTime);
	fscanf(infile,"%Lf",&closeTime);
	fscanf(infile,"%Lf",&depotX);
	fscanf(infile,"%Lf",&depotY);

	if (TypeOfProb[0]=='V' &&
		TypeOfProb[1]=='R' &&
		TypeOfProb[2]=='P') {
		VRPFlag = IloTrue;
	} else {
		VRPFlag = IloFalse;
	}
		
	outfile<<"TypeOfProblem = "<<TypeOfProb<<endl;
	outfile<<"nbOfTrucks = "<<nbOfTrucks<<endl;
	outfile<<"nbOfVisits = "<<nbOfVisits<<endl;
	outfile<<"Speed = "<<Speed<<endl;
	outfile<<"openTime = "<<openTime<<endl;
	outfile<<"closeTime = "<<closeTime<<endl;
	outfile<<"depotX = "<<depotX<<endl;
	outfile<<"depotY = "<<depotY<<endl;
	outfile<<"GLS penalty factor = "<<PenaltyFactor<<endl; 

	IloInt size = nbOfVisits+1;
	VrpData = new (env) IloNum * [nbOfVisits];
	DistMatr = new IloNum* [size];
	for (i=0;i<size;i++) {
		VrpData[i] = new IloNum [7+nbOfTrucks]; //VRP format
	}
	for (i=0;i<nbOfVisits;i++) {
		for (j=0;j<7+nbOfTrucks;j++) {
			VrpData[i][j] = 0;
		}
	}
	for (i=0;i<size;i++) {
		DistMatr[i] = new IloNum [size];
	}
	for (i=0;i<size;i++) {
		for (j=0;j<size;j++) {
			DistMatr[i][j] = 0;
		}
	}


	char postcode1[30], postcode2[30];

	for (i=0;i<nbOfVisits;i++) {
		for (j=0;j<3;j++) 
			fscanf(infile,"%Lf",&VrpData[i][j]);
			fscanf(infile,"%s%s",&postcode1,&postcode2);
		for (j=3;j<7;j++) 
			fscanf(infile,"%Lf",&VrpData[i][j]);
		IloNum index = 0;
		IloInt ctr = 0;
		while(index!=-1) {
			fscanf(infile,"%Lf",&index);
			VrpData[i][ctr+7] = index;
			ctr++;
		}
	}

	for (i=0;i<size;i++) {
		for (j=0;j<size;j++) {
			fscanf(infile,"%Lf",&DistMatr[i][j]);
		}
	}	

	for (i=0;i<size;i++) {
		for (int j=0;j<size;j++) {
			DistMatr[i][j] =  myRound(DistMatr[i][j]/Speed);
		}
	}

/*	for (i=0;i<nbOfVisits;i++) {
		for (j=0;j<7+nbOfTrucks;j++) {
			outfile<<VrpData[i][j]<<" ";
		}
		outfile<<endl;
	}
	for (i=0;i<size;i++) {
		for (int j=0;j<size;j++) {
			outfile<<DistMatr[i][j]<<" ";
		}
		outfile<<endl;
	}
*/
	IloNum depotDropTime = 1; 

	
	int** arrayOfAllowedVehicles;
	arrayOfAllowedVehicles = new int* [nbOfVisits];
	for (i=0;i<nbOfVisits;i++) {
		arrayOfAllowedVehicles[i] = new int [nbOfTrucks];
	}
	for (i=0;i<nbOfVisits;i++) {
		for (int j=0;j<nbOfTrucks;j++) { 
			arrayOfAllowedVehicles[i][j] = -1;
		}
	}

	//////////////////////////////////////////////////////////////////////
	//
	// Creating a model 
	//
	//////////////////////////////////////////////////////////////////////

	IloModel mdl(env); 

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

	//creating an instance (an object) of my subclass:

	MyDistanceI DistanceByMatrixObj (env);
	DistanceByMatrixObj.getDistanceMatrix(DistMatr);

	IloDimension2 time(env,&DistanceByMatrixObj, IloTrue, "Time"); 
	mdl.add(time);

	IloDimension2 length(env, &DistanceByMatrixObj, IloTrue, "Length");
	mdl.add(length);

	IloDimension1 weight(env, "Weight"); 
	mdl.add(weight);

//	IloDimension2 criterion(env, IloEuclidean, "Criterion");
//	mdl.add(criterion);

	IloDimension1 tardiness;
	IloNumVar softDeadline;

	cout<<endl;
	cout<<problem<<" is being solved by Dispatcher"<<endl; 
	outfile<<"Solutions to "<<problem<<endl; 

	IloNum * durs;
	IloNum * earliestStarts,
		   * latestEnds;
	durs = new IloNum [nbOfVisits];
	earliestStarts = new IloNum [nbOfVisits];
	latestEnds = new IloNum [nbOfVisits];


	if (VRPFlag) { //a temporary workaround

		for (i = 0; i < nbOfVisits; i++) { 
		  int id; // visit identifier 
		  IloNum quantity, 
				 minTime, maxTime, dropTime, x, y; 

		  id = VrpData[i][0];
		  dropTime = VrpData[i][1];
		  quantity = VrpData[i][2];
		  minTime = VrpData[i][3];
		  maxTime = VrpData[i][4];
		  x = VrpData[i][5];
		  y = VrpData[i][6];

		  int index = 7, ctr = 0;

		  while(VrpData[i][index]!=0 && index<nbOfTrucks+7) {
			  arrayOfAllowedVehicles[i][ctr] = VrpData[i][index];
			  ctr++;
			  index++;
		  }

	//	  outfile<<"arr of allowed for act "<<i<<endl;
	//	  for (int j=0;j<ctr;j++)
	//		  outfile<<arrayOfAllowedVehicles[i][j]<<" ";
	//	  outfile<<endl;

		  char name[16]; 
		  sprintf(name, "%d", id); 
		  IloNode customer(env, x, y, 0, name);
		  IloVisit visit(customer, name); 
		  mdl.add(visit.getDelayVar(time) == dropTime); 
		  durs[i] = dropTime;
		  mdl.add(visit.getTransitVar(weight) == quantity); 

		  mdl.add(minTime <= visit.getCumulVar(time));
		  mdl.add(visit.getCumulVar(time) + visit.getDelayVar(time)<= maxTime); 

		  earliestStarts[i] = minTime;
		  latestEnds[i] = maxTime;
		  mdl.add(visit);  
		  visits[i] = visit;
		} 


		IloNode depot(env, depotX, depotY, 0, "0");

		for (j = 0; j < nbOfTrucks; j++) { 
		  int id;
		  IloVisit first(depot, "Depot"); 
		  mdl.add(first.getCumulVar(time) >= openTime); 
		  mdl.add(first.getDelayVar(time) == depotDropTime); //may be non-zero (after transformation)
		  IloVisit last(depot, "Depot"); 
		  mdl.add(last.getCumulVar(time) <= closeTime-depotDropTime); //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
		  mdl.add(last.getDelayVar(time) == depotDropTime); //may be non-zero (after transformation)
		  char name[16]; 
		  sprintf(name, "%d", j+1); 

		  IloVehicle vehicle(first, last, name); 


		  if (!activateAltVRPCriterion) {
			  vehicle.setCost(length, 1.0); 
		  } else {
			  vehicle.setCost(time, 1.0);
		  }

		  //setting a fixed cost on a vehicle, thus it will tend to minimise the 
		  //number of used vehicles;
		  //vehicle.setCost(VehicleUsagePenalty); 
		  fscanf(infile,"%d",&id);
		  fscanf(infile,"%Ld",&capacity);
		  vehicle.setCapacity(weight, capacity); 
		  vehicles[j] = vehicle;
		  mdl.add(vehicle); 
		} 

		IloExpr expr(env);

		char buf1[30];

		for (i=0;i<3;i++) {
			if (i==0) {
				strcpy(buf1,"Diff");
				ReadInSideConstraints((char *) buf1, DiffArr,DiffNb,infile,outfile);
			}
			if (i==1) {
				strcpy(buf1,"Same");
				ReadInSideConstraints((char *) buf1, SameArr,SameNb,infile,outfile);
			}
			if (i==2) {
				strcpy(buf1,"Precedence");
				ReadInSideConstraints((char *) buf1, PrecedenceArr,PrecedenceNb,infile,outfile);
			}
		}

		ImposeVehicleVisitConstraints(mdl,time,nbOfTrucks,arrayOfAllowedVehicles,vehicles,
									  visits,outfile);

		fclose(infile);
		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; 
//		IloGoal goal = IloInsertionGenerate(env) && instantiateCost; 
//		IloGoal goal = IloDispatcherGenerate(env) && instantiateCost; 

		clock_t tStart = clock()/CLK_TCK, clocktime = tStart;  

		IloGoal goalAdd = MyAdditionGenerate(env,length) && instantiateCost;
 
		if (!Redo) {
			//by default we generate a first solution by savings;
			cout<<"TimeLimit = "<<TimeLimit<<endl;
			if (!solver.solve(IloLimitSearch(env,goal,IloTimeLimit(env,TimeLimit)))) {
				solver.out() << "A first solution can't be constructed. Insoluble or Time Expired" << endl; 
				outfile1<<endl;
				outfile2<<"0"<<endl;
				return -1;
			}
		} else {
			//in the case of inability to construct a first solution
			//within a specified time limit, we rerun the same instance
			//with a different heuristic, which quickly constructs a poor quality
			//solution
			if (!solver.solve(IloLimitSearch(env,goalAdd,IloTimeLimit(env,TimeLimit)))) {
				solver.out() << "A first solution can't be constructed. Insoluble or Time Expired" << endl; 
				outfile1<<endl;
				outfile2<<"0"<<endl;
				return -1;
			}
		}

		clocktime = clock()/CLK_TCK; 
		TimeLimit = TimeLimit - clocktime;
 
		///////////////////////////////////////////
		//
		// outputting the first solution 
		//
		///////////////////////////////////////////

		outfile2.open(output2, ios::out);
		Info(dispatcher,outfile,outfile2,problem);
		outfile2.close();

		IloNum trueCost = dispatcher.getTotalCost() - dispatcher.getNbOfVehiclesUsed()*VehicleUsagePenalty;
		cout<<"First Solution: "<<dispatcher.getNbOfVehiclesUsed()<<"/"<<trueCost<<"\t"; 
		outfile1<<dispatcher.getNbOfVehiclesUsed()<<" "<<trueCost<<" "; 

		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 (TimeLimit>0) { 
			improveWithGLS_TimeLimitVersion(dispatcher,solution,nhood,outfile, outfile1); 
		} 

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

		outfile2.open(output2, ios::out);
		Info(dispatcher,outfile,outfile2,problem);
		outfile2.close();
		trueCost = dispatcher.getTotalCost() - dispatcher.getNbOfVehiclesUsed()*VehicleUsagePenalty;
		cout<<"Last Solution: "<<dispatcher.getNbOfVehiclesUsed()<<"/"<<trueCost<<endl; 
		outfile1<<dispatcher.getNbOfVehiclesUsed()<<" "<<trueCost<<endl; 

	
	} else {

		cout<<"entered strangely enough..."<<endl;

		TypeOfMethod = 1; //GLS

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

		IloNumVarArray DepotTimeArr(env, nbOfTrucks,0,IloInfinity);

		UserTime = 0;
		for(i=0;i<nbOfVisits;i++) {
			UserTime+=VrpData[i][1];
		}

//		UserTime = 151;
		cout<<"UserTime = "<<UserTime<<endl;
		MoveLimit = 1500;
		firstAccept = true;

		tardiness = IloDimension1(env,IloTrue,"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,nbOfVisits);

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

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

		//creating vehicles with first and last visits on them
		//introducing tardiness as cost
		for (IloInt j = 0; j < nbOfTrucks; j++) {

			int id;
		  IloVisit first(depot, "Depot");
      
		  mdl.add(first.getCumulVar(time) >= openTime);
		  mdl.add(first.getDelayVar(time) == depotDropTime); //may be non-zero (after transformation)		  
		  mdl.add(first.getTransitVar(tardiness) == 0);

		  IloVisit last(depot, "Depot");
      
		  IloNumVar tard(env,0,IloInfinity,ILOINT);
		  
		  mdl.add(tard >= last.getCumulVar(time) - softDeadline);
		  
		  mdl.add(last.getTransitVar(tardiness) == tard);

		  mdl.add(DepotTimeArr[j]==last.getCumulVar(time));

		  char name[16];
      
		  sprintf(name, "%d", j+1);
      
		  IloVehicle vehicle(first, last, name);
      
		  vehicles[j]=vehicle;
      
		  vehicle.setCost(tardiness, 1.0);

//		  vehicle.setCost(length,0.001);
		  fscanf(infile,"%d",&id);
		  fscanf(infile,"%Ld",&capacity);
//		  outfile<<id<<" "<<capacity<<endl;

		  mdl.add(vehicle);
		}

		mdl.add(DepotTimeArr);

		char buffer[28];

		//creating customer visits
		for (i = 0; i < nbOfVisits; i++) {
			  int id; // visit identifier 
			  IloNum quantity, 
					 minTime, maxTime, dropTime, x, y; 

			  id = VrpData[i][0];
			  dropTime = VrpData[i][1];
			  quantity = VrpData[i][2];
			  minTime = VrpData[i][3];
			  maxTime = VrpData[i][4];
			  x = VrpData[i][5];
			  y = VrpData[i][6];

			int index = 7, ctr = 0;
			while(VrpData[i][index]!=0 && index<nbOfTrucks+7) {
				arrayOfAllowedVehicles[i][ctr] = VrpData[i][index];
				ctr++;
				index++;
			}

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

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

			char name[16];

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

			IloVisit visit(customer, name);

			mdl.add(visit.getDelayVar(time) == dropTime);

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

			mdl.add(visit.getCumulVar(time) >= minTime); //////////////////////////////////////////
			//outfile<<"i = "<<i<<" minTime = "<<minTime<<" maxTime = "<<maxTime<<endl;
			mdl.add(visit.getCumulVar(time) + visit.getDelayVar(time) <= maxTime); ///////////////////////////////////////////

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

  			visits[i] = visit;

			mdl.add(visit); 
		}

		IloExpr expr(env);

		char buf1[30];

		for (i=0;i<3;i++) {
			if (i==0) {
				strcpy(buf1,"Diff");
				ReadInSideConstraints((char *) buf1, DiffArr,DiffNb,infile,outfile);
			}
			if (i==1) {
				strcpy(buf1,"Same");
				ReadInSideConstraints((char *) buf1, SameArr,SameNb,infile,outfile);
			}
			if (i==2) {
				strcpy(buf1,"Precedence");
				ReadInSideConstraints((char *) buf1, PrecedenceArr,PrecedenceNb,infile,outfile);
			}
		}

		ImposeVehicleVisitConstraints(mdl,time,nbOfTrucks,arrayOfAllowedVehicles,vehicles,
									  visits,outfile);


		//constraining our deadline to be less than or equal to
		//our first guess
		mdl.add(softDeadline <= 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 = IloSavingsGenerate(env) && instantiateCost;
//		IloGoal goal = IloInsertionGenerate(env) && instantiateCost; 

		
//		IloGoal goal = IloDispatcherGenerate(env) && instantiateCost;

//		goal  = IloInsertionGenerate(env) && instantiateCost;
//		goal = MyAdditionGenerate(env,length) && instantiateCost;

		
		clock_t tStart = clock()/CLK_TCK, ttime;  
		//if we can't get a first solution -> quit
		if (!solver.solve(IloLimitSearch(env,goal,IloTimeLimit(env,TimeLimit)))) {
			solver.out() << "Couldn't generate first solution! Try and change your deadline value";
			outfile2<<"0"<<endl;
			outfile1<<endl;
			return -1;
		}

		//outputting the first solution

		outfile2.open(output2, ios::out); 
		bool statisticsWriteFlag = true;
		Info(dispatcher,problem,outfile,outfile1,outfile2,time, 
			 DepotTimeArr,nbOfTrucks,depotDropTime,
			 statisticsWriteFlag);
		statisticsWriteFlag = false;
		outfile2.close(); 

		IloInt makespan;
		GetMakespan(solver,DepotTimeArr,makespan);
		outfile<<"Deadline: "<<UserTime<<"\tMakespan: "<<makespan-depotDropTime<<endl;
		//cout<<"Deadline: "<<UserTime<<"\tMakespan: "<<makespan-depotDropTime<<endl;		
		//cout<<"Total cost: "<<dispatcher.getTotalCost()<<endl;

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

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

		UserTime = makespan - Step;
		IloInt OldUserTime = 0;

		int ctr = 0;

		if (GuidedLocalSearch) {
//			cout<<"GLS"<<endl;

			ttime = clock()/CLK_TCK - tStart; 
 
			while (ttime <= TimeLimit) { 
//				cout<<"elapsed: "<<ttime<<endl;

				//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(IloLimitSearch(env,moveGLS,IloTimeLimit(env,TimeLimit-ttime)))) {
						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);
					
				GetMakespan(solver,DepotTimeArr,makespan);
				
				outfile<<"Deadline: "<<UserTime<<"\tMakespan: "<<makespan-depotDropTime<<endl;
				cout<<"Deadline: "<<UserTime<<"\tMakespan: "<<makespan-depotDropTime<<" Cost: "
					   <<dispatcher.getTotalCost()<<endl;		

				outfile2.open(output2, ios::out); 
				Info(dispatcher,problem,outfile,outfile1,outfile2,time, 
					 DepotTimeArr,nbOfTrucks,depotDropTime,statisticsWriteFlag);
				outfile2.close(); 
				outfile<<endl;
				outfile<<endl;
				outfile<<endl;
				outfile<<endl;

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


				//reducing the deadline and recalculating cost

				if (!solver.solve(IloLimitSearch(env,restoreSolution,IloTimeLimit(env,TimeLimit-ttime)))) {
					solver.out() << "Couldn't generate a subsequent solution!1";
					return 0;
				}
				GetMakespan(solver,DepotTimeArr,makespan);
				
				cout<<"Deadline: "<<UserTime<<"\tMakespan: "<<makespan-depotDropTime<<endl;		

				UserTime=makespan-Step;
				mdl.remove(softDeadline <= UserTime);

				if (OldUserTime!=0) {
					if (UserTime==OldUserTime) {
						UserTime=UserTime-1;
					}
				}
				
				mdl.add(softDeadline <= UserTime);
				
				solver.extract(mdl);

				if (!solver.solve(IloLimitSearch(env,restoreSolution,IloTimeLimit(env,TimeLimit-ttime)))) {
					solver.out() << "Couldn't generate a subsequent solution!";
					return 0;
				}
				GetMakespan(solver,DepotTimeArr,makespan);

				outfile<<"Deadline: "<<UserTime<<"\tMakespan: "<<makespan-depotDropTime<<" Cost: "
					   <<dispatcher.getTotalCost()<<endl;
				cout<<"Deadline: "<<UserTime<<"\tMakespan: "<<makespan-depotDropTime<<" Cost: "
					<<dispatcher.getTotalCost()<<endl;		
				outfile2.open(output2, ios::out); 
				Info(dispatcher,problem,outfile,outfile1,outfile2,time, 
					 DepotTimeArr,nbOfTrucks,depotDropTime,
					 statisticsWriteFlag);
				outfile2.close(); 
				
				rsol.end();
				best.end();
				OldUserTime = UserTime;
				ctr++;
				ttime = clock()/CLK_TCK; 
				
				cout<<"time elapsed: "<<ttime<<endl;
				cout<<"time left:    "<<TimeLimit-ttime<<endl;
				
				if (TimeLimit-ttime<=0) break;
			}

			statisticsWriteFlag = true;
			outfile2.open(output2, ios::out); 
			Info(dispatcher,problem,outfile,outfile1,outfile2,time, 
				 DepotTimeArr,nbOfTrucks,depotDropTime,
				 statisticsWriteFlag);
			outfile2.close(); 
			outfile1<<endl;
		}
	}

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