#include <ilsolver/ilosolver.h>
#include <ildispat/ilodispatcher.h>


ILOSTLBEGIN

void Info(IloDispatcher dispatcher) 
{
  IloSolver solver = dispatcher.getSolver();
  solver.printInformation();
  //dispatcher.printInformation();
  solver.out() << "===============" << endl
               << "Cost         : " << dispatcher.getTotalCost() << endl 
               << "Number of vehicles used : " 
               << dispatcher.getNbOfVehiclesUsed() << endl
               << "Solution     : " << endl
              // << dispatcher << endl;
			   << IloTerse(dispatcher) << endl;
			   
}

void creatVehicle(IloModel model, IloInt nbOfTrucks, ifstream& fin, IloDimension2 length, IloDimension2 tardiness, IloDimension1 weight)
{
	IloEnv env = model.getEnv();

	IloNum capacity;		//용량 입력
	fin >> capacity;

	IloNum depotX, depotY, openTime, closeTime;		//데포정보 입력
	fin >> depotX  >> depotY >> openTime >> closeTime;

	IloNode depot(env, depotX, depotY);	//데포노드 생성

	for(int i=0; i<nbOfTrucks; i++)
	{
		IloVisit first(depot, "Depot");	//출발데포비지트 생성
		IloVisit last(depot, "Depot");		//도작데포비지트 생성

		model.add(first.getCumulVar(length) >= openTime);//타임윈도우 제약			
		model.add(last.getCumulVar(length) <= closeTime);//타임윈도우 제약		

		model.add(first.getCumulVar(weight) == 0);//초기 방문지 제약
		model.add(last.getCumulVar(weight) == 0);//마지막 방문지 제약

		char name[20];
		sprintf(name, "Vehicle %ld", i);//차량이름 생성

		IloVehicle vhc(env, name);//차량 생성

		vhc.setFirstVisit(first);//차량 출발지 설정
		vhc.setLastVisit(last);//차량 도착지 설정

		vhc.setCapacity(weight, capacity);//차량 용량 설정

		vhc.setCost(length, 1);//시간에 따른 코스트 부과

		vhc.setCost(tardiness, 1);//타디니스코스트 //이 코스트가 상당히 모호합니다.
     
		model.add(vhc);//차량 모델에 추가
	}
}

void creatVisit(IloModel model, IloInt nbOfVisits, IloVisitArray visits, ifstream& fin, 
				IloDimension2 length, IloDimension2 tardiness, IloDimension1 weight)
{
	IloEnv env = model.getEnv();
	
	for(int i=0; i<nbOfVisits; i++)
	{
		IloInt id;											//방문지 정보 입력
		IloNum x, y, quantity, minTime, maxTime, dropTime;	//방문지 정보 입력
		fin >> id >> x >> y >> quantity >> minTime >> maxTime >> dropTime;	//방문지 정보 입력
	
		char name[10];
		sprintf(name, "%ld", id);//방문지 이름 설정

		IloNode customer(env, x, y);//방문지 노드 설정
		IloVisit visit(customer, name);//방문지 설정


		model.add(visit.getTransitVar(weight) == -quantity);//방문지 요구 수량 설정

		model.add(visit.getDelayVar(length) == dropTime);//방문지 작업 시간 설정

		model.add(minTime <= visit.getCumulVar(length) <= maxTime);//방문지 타임 윈도우 설정

		//IloNumVar tard(env, 0, IloInfinity, "tard");//이 변수의 도메인 Upper가 데포 close time일 필요가 없습니다.(제약에 의거)
		//model.add(tard >= visit.getCumulVar(length) - maxTime);
		//model.add(tard >= minTime - visit.getCumulVar(length));
		//model.add(visit.getTransitVar(tardiness) == tard);
		
		model.add(visit.getTransitVar(tardiness) >= maxTime - visit.getCumulVar(length));//수정
		model.add(visit.getTransitVar(tardiness) >= visit.getCumulVar(length) - minTime);//수정	
		

		visit.setPenaltyCost(1);	//패널티 코스트 입력

		model.add(visit);//모델에 추가
		visits.add(visit);//방문지 어레이에 현 방문지 추가
	}

	
}

void creatInitRouting(IloModel model, IloSolver solver, IloDispatcher dispatcher, IloRoutingSolution solution,
						IloGoal instCost)
{
	cout << "초기 경로 생성. " << endl;

	IloEnv env = model.getEnv();


	for(IloVehicleIterator vehlt(model); vehlt.ok(); ++vehlt)
	{
		IloVehicle vehicle = *vehlt;
		for(int i=0; i<2; i++)//최대 2회차 가능
		{	
			IloVisit visit(vehicle.getFirstVisit().getNode(), "depot");//데포 방문지 설정
			
			visit.setPenaltyCost(0);//방문지 패널티 코스트 입력
			
			model.add(visit);//추가할 방문지 모델에 입력
			
			IloGoal insert = IloInsertVisit(env, visit, vehicle, solution, instCost);

			if(solver.solve(insert))
			{
				solution.add(visit);
				solution.store(solver);//경로가 확정되면 솔루션에 저장
				cout << "회차 데포를 추가합니다. " << endl;
			}
			else
			{
				cout << visit.getNode() << "를 삽입할 수 없습니다. " << endl;
				model.remove(visit);//경로가 실패하면 모델에서 방문지 제거
			}
		}
	}
	
	cout << endl;

}


IloVisitArray OrderVisits(IloEnv env, IloVisitArray visits, IloDistance dist, IloDimension2 tardiness) 
{
  IloModel tspModel(env);

  IloInt nbOfVisits = visits.getSize();
  IloVisit first(visits[0].getNode(), "first");
  IloVisit last(visits[0].getNode(), "last");

  IloVehicle vehicle(first, last, "TSP");
  tspModel.add(vehicle);
  IloDimension2 dim(env, dist, IloFalse);
  vehicle.setCost(dim, 1.0);
  //test
  IloDimension2 tard(env, IloEuclidean, "tardiness");
  vehicle.setCost(tard, 1.0);
  tspModel.add(tard);
  //test end

  tspModel.add(dim);
  IloInt i;
  for (i = 1; i < nbOfVisits; i++)
    tspModel.add(visits[i]);
 
  IloSolver solver(tspModel);
  IloDispatcher dispatcher(solver);
  IloGoal instCost = IloDichotomize(env, dispatcher.getCostVar(), IloFalse);
  
  solver.out() << "Producing insertion order" << endl;
  solver.solve(IloNearestAdditionGenerate(env) && instCost);
  
  IloRoutingSolution rsolution(tspModel);
  rsolution.store(solver);
  IloNHood nhood = IloTwoOpt(env);
  IloMetaHeuristic improve = IloImprove(env);
  IloGoal move = IloSingleMove(env, rsolution, nhood, improve, instCost);
  
  while (solver.solve(move)) { }
 
  IloVisitArray orderedVisits(env, nbOfVisits);

  IloRoutingSolution::RouteIterator rit(rsolution, vehicle);
  ++rit;
  orderedVisits[0] = visits[0];//처음은 데포

  for (IloInt k = 1; k < nbOfVisits; ++k, ++rit)
    orderedVisits[k] = *rit;//데포는 이미 입력했으므로 vehicle가 방문하는 방문지 입력

  nhood.end();
  solver.end();
  rsolution.end();

  
  return orderedVisits;//vehicle차량이 방문하는 방문지를 리턴
}


IloVisit getVisitByOrderedVisits(IloVisit orderedVisit, IloVisitArray visits)
{
	
	for(int i=0; i<visits.getSize(); i++)
	{
		if(orderedVisit.getNode() == visits[i].getNode())
			return visits[i];
	}
	return NULL;

}

void creatNewRouting(IloModel model, IloSolver solver, IloDispatcher dispatcher, IloRoutingSolution solution,
						IloGoal instCost, IloVisitArray orderedVisits, IloVisitArray visits)
{
	cout << endl << "새로운 경로 생성" << endl;

	IloEnv env = model.getEnv();

	for(int i=0; i<orderedVisits.getSize(); i++)
	{
		IloVisit visit = getVisitByOrderedVisits(orderedVisits[i], visits);//새로운 방문순서대로 비지트 생성
		
		visit.setPenaltyCost(500);//반드시 방문해야 하는 방문지의 페널티코스트
		model.add(visit);//해당 방문지 모델에 추가
			
		IloGoal insert = IloInsertVisit(env, visit, solution, instCost);//새로운 방문지를 하나씩 추가하는 골
		if(!solver.solve(insert))
		{
			cout << "새로운 방문지를 추가할 수 없습니다. " << endl;
			//model.remove(visit);//제거하게 되면 기존의 방문지 까지 제거됩니다. 제거하면 안됨
		}
		else
		{
			cout << "새로운 방문지 추가 완료" << endl;
			//solution.add(visit);//기존의 방문지를 사용하기 때문에 중복 추가할 필요가 없음
			solution.store(solver);
		}
	}

	cout << endl;

}

void Info2(IloDispatcher dispatcher, const char* message) 
{	
	cout << message << "Cost : " << dispatcher.getTotalCost() << endl
        << "Unperformed visits : " << dispatcher.getNumberOfUnperformedVisits() << endl
        << "Number of vehicles used : " << dispatcher.getNbOfVehiclesUsed() << endl;
        
}

void ImproveWithGreedy(IloDispatcher dispatcher,
                        IloRoutingSolution solution,
                        IloNHood nhood,
                        int limitTime,
                        IloGoal subGoal) 
{
	IloEnv env = dispatcher.getEnv();
	IloSolver solver = dispatcher.getSolver();

	IloGoal move = IloSingleMove(env, solution, nhood, IloImprove(env), subGoal);
	IloGoal limitGoal = IloLimitSearch(env, move, IloTimeLimit(env, limitTime));

	
	for (int i=0; int(env.getTime()) <= limitTime; i++)
	{
		if (solver.solve(limitGoal))
		{					
			solution.store(solver);
		    if (i%20 == 0) Info2(dispatcher, "<Greedy> --- ");
		}
		else break;
	}

	IloGoal restoreSolution = IloRestoreSolution(env, solution);// && subGoal;
	solver.solve(restoreSolution);
}


int main()
{

	IloEnv env;
	try 
	{
		IloModel model(env);	//모델 객체 생성

		IloDimension2 length(env, IloEuclidean, "Length");	//시간 디멘전
		model.add(length);

		IloDimension2 tardiness(env, IloEuclidean, "Tardiness");			//타디 디멘전
		model.add(tardiness);

		IloDimension1 weight(env, "Weight");				//무게 디멘전
		model.add(weight);
		

		ifstream fin;
		fin.open("vrp5.dat");

		IloInt nbOfVisits;		//비지트 수 입력
		fin >> nbOfVisits;

		IloInt nbOfTrucks;		//차량 수 입력
		fin >> nbOfTrucks;
			
   
		//===============================================
		//* 차량 생성								   //
		//**										   //
		//===============================================		
		creatVehicle(model, nbOfTrucks, fin, length, tardiness, weight);//차량생성



		//===============================================
		//* 방문지(IloVisit) 생성					   //
		//**										   //
		//===============================================
		IloVisitArray visits(env); //방문지 어레이 생성		
		
		creatVisit(model, nbOfVisits, visits, fin, length, tardiness, weight);//방문지 생성
		
		fin.close();


		//===============================================
		//* 초기해 생성								   //
		//**										   //
		//===============================================
		IloSolver solver(model);//솔버객체 생성
		IloDispatcher dispatcher(solver);//디스패쳐 객체 생성
		IloRoutingSolution solution(model);//라이팅솔루션 객체 생성

		IloGoal instCost = IloDichotomize(env, dispatcher.getCostVar(), IloFalse);//골 생성
		//IloGoal goal = IloNearestAdditionGenerate(env, instCost);//골 생성
					 //= IloInsertionGenerate(env);
				     //= IloSavingsGenerate(env) && instCost;

		creatInitRouting(model, solver, dispatcher, solution, instCost);//초기해 생성
		cout << "초기 경로 === 데포 경로를 나타냅니다. " << endl;
		cout << "===================================================" << endl;
		cout << IloTerse(dispatcher) << endl;
		cout << "===================================================" << endl << endl;
		
		//===============================================
		//* 새로운 경로 생성						   //
		//**										   //
		//===============================================
		IloDistance distance = IloDistance(env, IloEuclidean);//거리 객체 생성
		IloVisitArray orderedVisits = OrderVisits(env, visits, distance, tardiness);//새로운 비클이 방문하는 방문지 


		//===============================================
		//* 새로운 방문지 추가						   //
		//**										   //
		//===============================================
		creatNewRouting(model, solver, dispatcher, solution, instCost, orderedVisits, visits);//새로운 방문지 추가 함수
		
			
		//===============================================
		//* 휴리스틱 적용							   //
		//**										   //
		//===============================================
		IloInt limitTime = 10;//휴리스틱적용시간 /초
		IloNHood nhood = 
			  IloMakePerformed(env)
			  + IloSwapPerform(env)
			+ IloRelocate(env)
			+ IloExchange(env)
			+ IloCross(env)
			+ IloOrOpt(env)
			+ IloTwoOpt(env)
			+ IloMakeUnperformed(env);

		cout << endl << "===============================================" << endl;
		cout << "휴리스틱을 적용합니다." << endl << "해 개선이 없을경우 중단될 수 있습니다.  " << endl;
		cout << "===============================================" << endl;
		ImproveWithGreedy(dispatcher, solution, nhood, limitTime, instCost);//휴리스틱 적용

		cout << endl << "===============================================" << endl;
		cout << "최종 보고서를 출력합니다. " << endl;
		cout << "===============================================" << endl;
		Info(dispatcher); //최종 보고서   
	

	} 
	catch(IloException& ex) 
	{
    cout << "Error: " << ex << endl;
	} 
	env.end();
	return 0;


}