#pragma once
	#include <map>
	#include <unordered_map>
	#include <memory>
	#include <algorithm>
	#include <string>
	#include <stdexcept>
	#include <functional>
	#include <typeindex>
	#include "U_Log.h"
	#include "CComponent.h"
	#include "CCallbackHandler.h"
	class CComponentsManager
	{
	public:
	~CComponentsManager();
	void Add(std::unique_ptr<CComponent>&& comp);
	bool IsComponentPresent(const std::string& type) const;
	std::unique_ptr<CComponent>& GetComponent(const std::string& type);
	CComponent* GetComponentRaw(const std::string& type);
	void CreateComponent(const std::string& type, bool instantInit = true);
	void Trace(const std::function<void(CComponent* nod)>& func);
	void ReverseTrace(const std::function<void(CComponent* nod)>& func);
	template<typename ComponentType>
	void DeleteComponent()
	{
	auto curHash = typeid(ComponentType).hash_code();
	auto _comp_ptr_it = hashCache.find(curHash);
	if(_comp_ptr_it == hashCache.end()) { return; }
	auto _comp_ptr = _comp_ptr_it->second;
	auto it = std::find_if(Items.begin(), Items.end(), [_comp_ptr](const auto& kv) -> bool
	{
	//return dynamic_cast<ComponentType*>(kv.second.get());
	return kv.second.get() == _comp_ptr;
	});
	if(it != Items.end())
	{
	it->second->DeInit();
	RemoveCache(it->second.get());
	Items.erase(it);
	}
	}
	void DeleteComponent(const std::string& type);
	template<typename ComponentType>
	void CreateComponent(bool instantInit = true)
	{
	Add(std::make_unique<ComponentType>());
	if(instantInit)
	{
	GetComponentTyped<ComponentType>()->Init();
	GetComponentTyped<ComponentType>()->PostInit();
	}
	}
	template<typename ComponentType>
	bool IsComponentPresent() const
	{
	auto curHash = typeid(ComponentType).hash_code();
	auto _comp_ptr_it = hashCache.find(curHash);
	if(_comp_ptr_it == hashCache.end()) { return false; }
	auto _comp_ptr = _comp_ptr_it->second;
	auto it = std::find_if(Items.begin(), Items.end(), [_comp_ptr](const auto& kv) -> bool
	{
	//return dynamic_cast<ComponentType*>(kv.second.get());
	return kv.second.get() == _comp_ptr;
	});
	return it != Items.end();
	}
	template<typename ComponentType>
	ComponentType* GetComponentTyped()
	{
	auto curHash = typeid(ComponentType).hash_code();
	auto _comp_ptr_it = hashCache.find(curHash);
	if(_comp_ptr_it == hashCache.end()) { return nullptr; }
	auto _comp_ptr = _comp_ptr_it->second;
	return dynamic_cast<ComponentType*>(_comp_ptr);
	auto it = std::find_if(Items.begin(), Items.end(), [_comp_ptr](const auto& kv) -> bool
	{
	//if(!kv.second) { return false; }
	return dynamic_cast<ComponentType*>(kv.second.get());
	});
	if (it == Items.end())
	{
	//throw std::runtime_error("Component with the specified type not found");
	return nullptr; //unreachable
	}
	return dynamic_cast<ComponentType*>((*it).second.get());
	}
	template<typename ComponentType>
	ComponentType* GetComponentTyped(const std::string& type)
	{
	const auto& it = Items.find(type);
	//if (it == Items.end()) { throw std::runtime_error("No such component"); }
	if (it == Items.end()) { return nullptr; }
	if (ComponentType* casted = dynamic_cast<ComponentType*>(it->second.get()))
	{
	return casted;
	}
	else
	{
	//throw std::runtime_error("Component type mismatch");
	return nullptr;
	}
	}
	CCallbackHandler<void, std::string> OnComponentAdd;
	CCallbackHandler<void, std::string> OnComponentInit;
	CCallbackHandler<void, std::string> OnComponentPostInit;
	std::unordered_map<std::string, std::unique_ptr<CComponent>> Items;
	void AddCache(const std::string& name, std::type_index _type, CComponent* _component);
	void RemoveCache(CComponent* component);
	private:
	std::vector<CComponent*> getComponentsOrder();
	std::unordered_map<size_t, CComponent*> hashCache;
	std::unordered_map<std::string, CComponent*> nameCache;
	};