#pragma once

#include <wfr/common/types/ResourceTypes.h>


namespace wfr {
namespace resource {


/**
 * Represents the capabilities of a resource.
 */
class ResourceCapability {
public:
	const ResourceCapabilityType type;
	const wfr_size_t majorVersion;
	const wfr_size_t minorVersion;

public:
	ResourceCapability()
			: type(ResourceCapabilityType::Unknown), majorVersion(0), minorVersion(0) {}

	ResourceCapability(const ResourceCapabilityType& type, const wfr_size_t& majorVersion, const wfr_size_t& minorVersion)
			: type(type), majorVersion(majorVersion), minorVersion(minorVersion) {}


	static ResourceCapability GenericCPU() {
		return ResourceCapability(ResourceCapabilityType::GenericCPU, 0, 0);
	}

	static ResourceCapability OpenCL(const wfr_size_t& majorVersion, const wfr_size_t& minorVersion) {
		return ResourceCapability(ResourceCapabilityType::OpenCL, majorVersion, minorVersion);
	}

	static ResourceCapability CUDA(const wfr_size_t& majorVersion, const wfr_size_t& minorVersion) {
		return ResourceCapability(ResourceCapabilityType::CUDA, majorVersion, minorVersion);
	}
};


/**
 * Represents the requirements of an activity implementation.
 **/
class RequiredResourceCapability {
public:
	const ResourceCapabilityType type;
	const wfr_size_t minMajorVersion;
	const wfr_size_t minMinorVersion;
	const wfr_size_t maxMajorVersion;
	const wfr_size_t maxMinorVersion;

public:
	RequiredResourceCapability()
			: type(ResourceCapabilityType::Unknown), minMajorVersion(0), minMinorVersion(0), maxMajorVersion(0), maxMinorVersion(0) {}

	RequiredResourceCapability(const ResourceCapabilityType& type, const wfr_size_t& minMajorVersion, const wfr_size_t& minMinorVersion,
				const wfr_size_t& maxMajorVersion = 0, const wfr_size_t& maxMinorVersion = 0)
			: type(type), minMajorVersion(minMajorVersion), minMinorVersion(minMinorVersion),
			  maxMajorVersion(maxMajorVersion), maxMinorVersion(maxMinorVersion) {}


	static RequiredResourceCapability GenericCPU() {
		return RequiredResourceCapability(ResourceCapabilityType::GenericCPU, 0, 0, 0, 0);
	}

	static RequiredResourceCapability OpenCL(const wfr_size_t& minMajorVersion, const wfr_size_t& minMinorVersion,
			const wfr_size_t& maxMajorVersion = 0, const wfr_size_t& maxMinorVersion = 0) {
		return RequiredResourceCapability(ResourceCapabilityType::OpenCL, minMajorVersion, minMinorVersion, maxMajorVersion, maxMinorVersion);
	}

	static RequiredResourceCapability CUDA(const wfr_size_t& minMajorVersion, const wfr_size_t& minMinorVersion,
			const wfr_size_t& maxMajorVersion = 0, const wfr_size_t& maxMinorVersion = 0) {
		return RequiredResourceCapability(ResourceCapabilityType::CUDA, minMajorVersion, minMinorVersion, maxMajorVersion, maxMinorVersion);
	}
};


typedef std::initializer_list<resource::ResourceCapability> CapabilityList;
typedef std::initializer_list<resource::RequiredResourceCapability> RequiredCapabilityList;

inline bool operator<(const wfr::resource::ResourceCapability& dev1, const wfr::resource::ResourceCapability& dev2) {
	if (dev1.type == dev2.type) {
		if (dev1.majorVersion == dev2.majorVersion) {
			return dev1.minorVersion < dev2.minorVersion;
		} else {
			return dev1.majorVersion < dev2.majorVersion;
		}
	} else {
		return dev1.type < dev2.type;
	}
}

inline bool operator==(const wfr::resource::ResourceCapability& cap, const wfr::resource::RequiredResourceCapability& rcap) {
	if (cap.type == rcap.type) {
		if (cap.majorVersion >= rcap.minMajorVersion && cap.majorVersion <= rcap.maxMajorVersion) {
			return true;
		} else {
			return false;
		}
	} else {
		return false;
	}
}

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