#pragma once

#include <wfr/common/types/ResourceTypes.h>
#include <wfr/common/resource/ResourceCapabilities.h>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <initializer_list>


namespace wfr {

// Forward declarations
namespace wfs { class AtomicActivityImplementation; }

namespace resource {



class AbstractResource {

// Invariant properties that can be accessed directly.
public:
	const ResourceClass resourceClass;
	const std::string resourceIdentifier;
	const wfr_id_t resourceId;

// Public Functions
public:
	AbstractResource( ResourceClass resourceClass, const std::string& resourceIdentifier, const wfr_id_t resourceId ) noexcept
		: resourceClass(resourceClass), resourceIdentifier(resourceIdentifier), resourceId(resourceId) {}
	virtual ~AbstractResource() {}

	virtual bool hasCapability(const RequiredResourceCapability& type) const noexcept = 0;
};



class AbstractResourceType {

// Invariant properties that can be accessed directly.
public:
	const ResourceClass resourceClass;
	const std::string resourceTypeName;

// Mutable properties that need to be accessed via getter-/setter-functions.
protected:
	std::set<ResourceCapability> capabilities;
	std::map<std::string, std::string> properties;

// Public Functions
public:
	AbstractResourceType( ResourceClass resourceClass, const std::string& resourceName,
			const std::set<ResourceCapability>& capabilities = std::set<ResourceCapability>(),
			const std::map<std::string, std::string>& properties = std::map<std::string, std::string>() ) noexcept
		: resourceClass(resourceClass), resourceTypeName(resourceName), capabilities(capabilities), properties(properties) {}
	virtual ~AbstractResourceType() {}

	wfr_size_t getCapabilityCount() const noexcept { return capabilities.size(); }
	const std::set<ResourceCapability>& getCapabilities() const noexcept { return capabilities; }
	bool hasCapability(const RequiredResourceCapability& type) const noexcept;
	bool hasCapability(wfr::resource::ResourceCapabilityType type) const noexcept;

	wfr_size_t getPropertyCount() const noexcept { return properties.size(); }
	const std::map<std::string, std::string>& getProperties() const noexcept { return properties; }
	std::vector<std::string> getPropertyKeys() const noexcept;
	std::string getProperty(const std::string& key) const noexcept;
};



template<class Resource>
class ResourceTypeBase : public AbstractResourceType {

// Mutable properties that need to be accessed via getter-/setter-functions.
private:
	std::vector<Resource*> resources;

// Public Functions
public:
	ResourceTypeBase( ResourceClass resourceClass, const std::string& resourceName,
			const std::set<ResourceCapability>& capabilities = std::set<ResourceCapability>(),
			const std::map<std::string, std::string>& properties = std::map<std::string, std::string>() ) noexcept
		: AbstractResourceType(resourceClass, resourceName, capabilities, properties) {}

	wfr_size_t getResourceCount() const noexcept { return resources.size(); }
	const std::vector<Resource*> getResources() const noexcept { return resources; }
	void addResource(Resource* resource) noexcept { resources.push_back(resource); }
};



template<class RType>
class ResourceBase : public AbstractResource {

// Invariant properties that can be accessed directly.
public:
	RType& resourceType;

// Public Functions
public:
	ResourceBase(ResourceClass resourceClass, const std::string& resourceIdentifier, const wfr_id_t resourceId, RType& resourceType ) noexcept
			: AbstractResource(resourceClass, resourceIdentifier, resourceId), resourceType(resourceType) {}

	virtual bool hasCapability(const RequiredResourceCapability& type) const noexcept { return resourceType.hasCapability(type); }
	virtual bool hasCapability(wfr::resource::ResourceCapabilityType type) const noexcept { return resourceType.hasCapability(type); }
};


class ComputingResource;

class ComputingResourceType : public ResourceTypeBase<ComputingResource> {

// Invariant properties that can be accessed directly.
public:
	const ComputingDeviceClass computingDeviceClass;
	const wfr_size_t maxSlots;


// Public Functions
public:
	ComputingResourceType( const std::string& resourceName, ComputingDeviceClass computingDeviceClass, wfr_size_t maxSlots,
			const std::set<ResourceCapability>& capabilities = std::set<ResourceCapability>(),
			const std::map<std::string, std::string>& properties = std::map<std::string, std::string>() ) noexcept
		: ResourceTypeBase(ResourceClass::ComputingResource, resourceName, capabilities, properties),
		  computingDeviceClass(computingDeviceClass), maxSlots(maxSlots) {}
};



class ComputingResource : public ResourceBase<ComputingResourceType> {

// Mutable properties that need to be accessed via getter-/setter-functions.
protected:
	wfr_size_t reservedSlots =0;
	wfr_size_t busySlots = 0;

// Public Functions
public:
	ComputingResource( const std::string& resourceIdentifier, const wfr_id_t resourceId, ComputingResourceType& resourceType ) noexcept
			: ResourceBase(ResourceClass::ComputingResource, resourceIdentifier, resourceId, resourceType) {
		resourceType.addResource(this);
	}

	wfr_size_t getMaxSlotCount() const noexcept { return resourceType.maxSlots; }
	wfr_size_t getReservedSlotCount() const noexcept { return reservedSlots; }
	wfr_size_t getBusySlotCount() const noexcept { return busySlots; }
	wfr_size_t getFreeSlotCount() const noexcept {
		auto nonFreeSlots = busySlots + reservedSlots;
		return nonFreeSlots >= resourceType.maxSlots ? 0 : resourceType.maxSlots - nonFreeSlots;
	}

	bool reserveSlots(const wfr_size_t& slots, bool requireFreeSlots = false) noexcept;
	bool markReservedSlotsBusy(const wfr_size_t& slots) noexcept;
	bool markFreeSlotsBusy(const wfr_size_t& slots) noexcept;
	bool releaseBusySlots(const wfr_size_t& slots) noexcept;
};



ComputingDeviceClass parseComputingDeviceType(const std::string& type);

std::string getComputingDeviceTypeString(const ComputingDeviceClass& type);



ResourceCapabilityType parseResourceCapabilityType(const std::string& type);

std::string getResourceCapabilityTypeString(const ResourceCapabilityType& type);



} /* namespace resource */
} /* namespace wfr */