#pragma once

#include <mutex>
#include <thread>
#include <utility>
#include <queue>
#include <map>
#include <vector>
#include <atomic>
#include <ostream>
#include <wfr/common/types/WfrTypes.h>
#include <wfr/common/types/ResourceTypes.h>



namespace wfr {

namespace wfs {
class AtomicActivityInstance;
}

namespace resource {

class AbstractResource;
class ComputingResource;
class ComputingResourceType;
class ComputingResourceReservation;
class RequiredResourceCapability;

class ResourceManager {
private:
	static ResourceManager* singleton;

// Mutable properties that need to be accessed via getter-/setter-functions.
private:
	std::mutex managerMutex;
	std::map<std::string, ComputingResourceType*> computingResourceTypes;
	std::map<std::string, ComputingResource*> computingResources;

private:
	static std::atomic<wfr_id_t> _nextResourceId;

	static wfr_id_t getNextResourceId() {
		return _nextResourceId.fetch_add(1);
	}

// Non-public functions
private:
	ResourceManager(std::string resourceConfigFile, bool cpuAutoConfig, bool printResourceTable);

	void readConfigFile(std::string configFile);

// Public static functions
public:
	static void init(int argc, char** argv);
	static void finish() noexcept;
	static ResourceManager& getInstance() noexcept;

// Public functions
public:
	~ResourceManager() noexcept;

	wfr_size_t getComputingResourceCount() const noexcept { return computingResources.size(); }
	std::vector<ComputingResource*> getComputingResources() const noexcept;
	ComputingResource* getComputingResource(std::string identifier) const noexcept;
	std::vector<ComputingResource*> filterComputingResources(std::vector<RequiredResourceCapability> filter) const noexcept;

	std::shared_ptr<ComputingResourceReservation> reserveComputingResource(ComputingResource* device, const wfr_size_t& slots, bool requireFreeSlots = false) noexcept;
	bool releaseComputingResources(ComputingResourceReservation* handle) noexcept;

	wfr_size_t getComputingResourceTypeCount() const noexcept { return computingResourceTypes.size(); }
	std::vector<ComputingResourceType*> getComputingResourceTypes() const noexcept;
	std::vector<ComputingResourceType*> getCompatibleComputingResourceTypes(wfs::AtomicActivityInstance* activity) const noexcept;
	ComputingResourceType* getComputingResourceType(std::string name) const noexcept;

	void printResourceTable(std::ostream& out) const noexcept;
};


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