#include <wfr/scheduling/scheduler/justintime/JustInTimeScheduler.h>
#include <wfr/common/wep/WorkflowExecutionPlan.h>
#include <wfr/common/wep/AbstractWepNode.h>
#include <wfr/common/wep/activities/AtomicWepNode.h>
#include <wfr/common/wfs/Activity.h>
#include <wfr/common/wfs/ActivityInstance.h>
#include <wfr/common/wfs/AtomicActivityImplementation.h>
#include <wfr/common/wfs/instances/AtomicActivityInstance.h>
#include <wfr/common/wfs/templates/AtomicActivityTemplate.h>
#include <wfr/prediction/PredictionManager.h>
#include <wfr/common/resource/ResourceManager.h>
#include <wfr/enactment/EnactmentEngine.h>
#include <wfr/common/scheduling/SchedulingDecision.h>
#include <wfr/execution/ExecutionManager.h>
#include <wfr/WorkflowRuntime.h>
#include <wfr/wep/utils/WepSearch.h>
#include <iostream>
#include <set>
#include <queue>


namespace wfr {
namespace scheduling {


void JustInTimeScheduler::_notifyWEPUpdate(SchedulerBase::WepMapEntry& wepe, std::set<wep::AtomicWepNode*> readyToExecute, std::unique_lock<std::mutex>& schedulerLock) {
	for (auto n : readyToExecute) {
		nodeQueue.insert(n);
	}
	auto resourceTypes = resourceManager.getComputingResourceTypes();
	std::vector<wep::AtomicWepNode*> scheduledQueue;
	for (auto n : nodeQueue) {
		auto& ai = n->activity.as<wfs::AtomicActivityInstance>();
		wfs::AtomicActivityImplementation* fastestImpl = nullptr;
		resource::ComputingResource* fastestRes = nullptr;
		prediction::ExecutionTimeResult fastestPred;
		double minEFT = -1;

		for (auto restype : resourceTypes) {
			wfs::AtomicActivityImplementation* bestImpl = nullptr;
			prediction::ExecutionTimeResult bestPred;
			auto& aat = ai.baseActivity.baseTemplate.as<wfs::AtomicActivityTemplate>();
			for (auto impl : aat.atomicActivityType->getImplementations()) {
				auto execPred = predictionManager.predictExecutionTime(ai, *impl, *restype);
				if (execPred.isValid()) {
					if (!bestImpl || !bestPred.isValid() || execPred.executionTime.getValue() < bestPred.executionTime.getValue()) {
						bestImpl = impl;
						bestPred = execPred;
					}
				}
			}
			for (auto res : restype->getResources()) {
				auto eft = _getResourceEstimatedAvailableTime(res) + bestPred.executionTime.getValue();
				if (minEFT < 0 || eft < minEFT) {
					minEFT = eft;
					fastestImpl = bestImpl;
					fastestRes = res;
					fastestPred = bestPred;
				}
			}
		}

		if (fastestImpl) {
			auto reservation = resourceManager.reserveComputingResource(fastestRes, 1, false);
			auto sd = std::make_shared<SchedulingDecision>(&ai, fastestImpl, wepe.wep, reservation);
			sd->setPrediction(fastestPred);
			ai.setInstanceStatus(wfs::ActivityInstanceStatus::Scheduled);
			scheduledQueue.push_back(n);
			executeSchedulingDecision(wepe, sd, schedulerLock);
		} else {
			//throw exception::wfr_fatal_error("JustInTimeScheduler could not find a suitable implementation.");
		}
	}
	for (auto n : scheduledQueue) {
		nodeQueue.erase(n);
	}
}


} /* namespace scheduling */
} /* namespace wfr */