#pragma once


#include <cstdint>
#include <wfr/common/types/WfrTypes.h>
#include <string>

namespace wfr {

namespace wfs {
class AtomicActivityImplementation;
class ActivityInstance;
}

namespace resource {
class Resource;
class ComputingResourceType;
class ComputingResource;
class ResourceManager;
}

namespace prediction {

class PredictionService;



class ExecutionTimeResult {

// Mutable properties that need to be accessed via getter-/setter-functions.
// Some of them are invariant, but this class needs to be copyable, so no const properties :(
public:
	wfs::ActivityInstance* instance = nullptr;
	wfs::AtomicActivityImplementation* implementation = nullptr;
	resource::ComputingResourceType* resourceType = nullptr;
	wfr::NumericalMeasurement executionTime;
	wfr_size_t slots = 0;
	bool validFlag = false;

// Public functions
public:
	ExecutionTimeResult() noexcept {}
	ExecutionTimeResult(wfs::ActivityInstance* instance, wfs::AtomicActivityImplementation* implementation,
		resource::ComputingResourceType* resourceType, wfr::NumericalMeasurement executionTime, wfr_size_t slots = 1, bool validFlag = true) noexcept
			: instance(instance), implementation(implementation), resourceType(resourceType), executionTime(executionTime),
			  slots(slots), validFlag(validFlag) {}

	wfs::ActivityInstance* getActivityInstance() const noexcept { return instance; }
	wfs::AtomicActivityImplementation* getActivityImplementation() const noexcept { return implementation; }
	resource::ComputingResourceType* getResourceType() const noexcept { return resourceType; }
	const wfr::NumericalMeasurement& getExecutionTime() const noexcept { return executionTime; }
	wfr_size_t getSlots() const noexcept { return slots; }
	bool isValid() const noexcept { return validFlag; }
	operator bool() const noexcept { return validFlag; }
};



class CommunicationTimeResult {

// Invariant properties that can be accessed directly.
public:
	wfs::ActivityInstance* const srcInstance = nullptr;
	resource::ComputingResource* const srcResource = nullptr;
	wfs::ActivityInstance* const destInstance = nullptr;
	resource::ComputingResource* const destResource = nullptr;
	const wfr::NumericalMeasurement communicationTime;
	const bool isValid = false;
public:
	CommunicationTimeResult() noexcept {}
	CommunicationTimeResult(wfs::ActivityInstance* srcInstance, resource::ComputingResource* srcResource,
		wfs::ActivityInstance* destInstance, resource::ComputingResource* destResource,
		wfr::NumericalMeasurement communicationTime, bool validFlag = true) noexcept
			: srcInstance(srcInstance), srcResource(srcResource), destInstance(destInstance), destResource(destResource),
			  communicationTime(communicationTime), isValid(validFlag) {}

	operator bool() const {
		return isValid;
	}
};


class PredictionManager {
private:
	static PredictionManager singleton;
	PredictionService* service = nullptr;
public:
	static void init(int argc, char** argv);

	static void finish() noexcept;

	static PredictionManager& getInstance() noexcept { return singleton; }

public:
	~PredictionManager() noexcept;

	ExecutionTimeResult predictExecutionTime(wfs::ActivityInstance& instance, wfs::AtomicActivityImplementation& implementation,
			resource::ComputingResourceType& resourceType, const wfr_size_t& slots = 1) noexcept;

	CommunicationTimeResult predictCommunicationTime(wfs::ActivityInstance& srcInstance, resource::ComputingResource& srcResource,
			wfs::ActivityInstance& destInstance, resource::ComputingResource& destResource) noexcept;
};


} /* namespace prediction */
} /* namespace wfr */