#pragma once
	#include <vector>
	#include <iostream>
	#include <memory>
	#include <algorithm>
	#include <unordered_map>
	#include "CFunctionBase.h"
	#include "CSwitchable.h"
	#include "CFunction.h"
	#include "CLuaFunction.h"
	#include "CScriptObjectBase.h"
	#include "U_SafeLuaCall.h"
	class CSmartCallback;
	using CSmartCallbackPtr = std::shared_ptr<CSmartCallback>;
	class CCallbackHandlerBase : public virtual CSwitchable, public CScriptObjectBase
	{
	public:
	virtual ~CCallbackHandlerBase();
	void RegisterCallback(CSmartCallback* callback);
	void UnregisterCallback(CSmartCallback* callback);
	virtual sol::object CallFromLua(sol::variadic_args va, sol::state_view s) = 0;
	virtual std::shared_ptr<CSmartCallback> GetLastFunctionHandleShared() = 0;
	virtual CSmartCallbackPtr AddLuaFunction(sol::function func, sol::object name) = 0;
	virtual sol::object CallLua(sol::variadic_args va, sol::this_state s) = 0;
	DEFINE_SOL_USERTYPE();
	virtual void m_deleteFunction(void* ptr) = 0;
	virtual void DeleteFunctionAtIndex(size_t index) = 0;
	virtual void DeleteFunctionsByName(const std::string& name) = 0;
	private:
	std::vector<CSmartCallback*> callbacks;
	};
	class CSmartCallback : public CScriptObjectBase, public std::enable_shared_from_this<CSmartCallback>
	{
	public:
	CSmartCallback() = delete;
	CSmartCallback(CCallbackHandlerBase& _handler, void* _func);
	~CSmartCallback();
	void Invalidate();
	void ForceDelete();
	bool IsValid() const;
	bool V_ScriptInit(std::shared_ptr<sol::state> state, sol::table table) override;
	CCallbackHandlerBase& Handler;
	void* FunctionPointer = nullptr;
	private:
	void m_InitiateDeletion();
	};
	template <typename Ret, typename... Args>
	class CCallbackHandler : public CCallbackHandlerBase //TODO add CallByName
	{
	public:
	//out - CPP to LUA
	//in - LUA TO CPP
	using CLuaArgsOutTransformer = CLuaFunction<Ret, Args...>::CustomOutCallerFunction;
	using CLuaArgsInTransformer = CFunctionBase<Ret, Args...>::CustomInCallerFunction;
	CCallbackHandler() = default;
	CCallbackHandler(CCallbackHandler&&) noexcept = default;
	CCallbackHandler& operator=(CCallbackHandler&&) noexcept = default;
	CCallbackHandler(const CCallbackHandler&) = delete;
	CCallbackHandler& operator=(const CCallbackHandler&) = delete;
	~CCallbackHandler()
	{
	for (auto& func : Functions)
	{
	CLuaFunction<Ret, Args...>* luafunc = dynamic_cast<CLuaFunction<Ret, Args...>*>(func.get());
	if(luafunc) { std::wcout << L"detected lua func at deleting CCallbackHandler\n"; continue; }
	}
	}
	using FuncType = CFunctionBase<Ret, Args...>;
	using FuncTypeUniquePtr = std::unique_ptr<FuncType>;
	using FuncTypeRawPtr = FuncType*;
	using ReturnType = Ret;
	using ReturnsVector = typename std::conditional<std::is_void<Ret>::value, std::vector<int>, std::vector<Ret>>::type;
	CSmartCallbackPtr AddLuaFunction(sol::function func, sol::object name) override
	{
	Add(std::make_unique<CLuaFunction<Ret, Args...>>(func));
	std::string nm;
	if(name.valid() && name.is<std::string>())
	{
	nm = name.as<std::string>();
	if(!nm.empty())
	{
	Functions.back()->SetName(nm);
	}
	}
	return GetLastFunctionHandleShared();
	}
	sol::object CallLua(sol::variadic_args va, sol::this_state s) override
	{
	return CallFromLua(va, s);
	}
	bool V_ScriptInit(std::shared_ptr<sol::state> _state, sol::table table) override //TODO __call
	{
	table.set_function("add", [this](sol::function func, sol::object name) -> sol::table
	{
	Add(std::make_unique<CLuaFunction<Ret, Args...>>(func));
	std::string nm;
	if(name.valid() && name.is<std::string>())
	{
	nm = name.as<std::string>();
	if(!nm.empty())
	{
	Functions.back()->SetName(nm);
	}
	}
	sol::table tabl = sol::state_view(func.lua_state()).create_table();
	FuncTypeRawPtr ptr = Functions.back().get();
	tabl.set_function("delete", [this, ptr]() mutable
	{
	if(!ptr) { return; }
	DeleteFunction(ptr);
	ptr = nullptr;
	});
	tabl.set_function("getSmartDeleter", [this, ptr](sol::this_state ts) mutable
	{
	auto obj = GetFunctionHandleShared(ptr);
	auto ret = obj->GetScriptTable(ts);
	ret["__obj"] = obj;
	return ret;
	});
	tabl.set("name", nm);
	tabl.set("__ptr", ptr);
	return tabl;
	});
	table.set_function("call", [this](sol::variadic_args va, sol::this_state s) -> sol::object
	{
	return CallFromLua(va, s);
	});
	table.set_function("isEnabled", [this](sol::this_state s) -> bool
	{
	return IsEnabled();
	});
	table.set_function("setState", [this](bool state, sol::this_state s) -> void
	{
	return SetEnabledState(state);
	});
	table.set_function("delete", [this](sol::object obj, sol::this_state s) -> void
	{
	if(!obj.valid()) { return; }
	if(obj.is<sol::table>())
	{
	sol::table tabl = obj.as<sol::table>();
	sol::object del_obj = tabl["delete"];
	if(del_obj.valid() && del_obj.is<sol::function>())
	{
	sol::function del_func = del_obj.as<sol::function>();
	SafeCallLua(del_func);
	//del_func();
	}
	}
	else if(obj.is<std::string>())
	{
	std::string nm = obj.as<std::string>();
	DeleteFunctionsByName(nm);
	}
	});
	table.set_function("getLastFunctionSmartDeleter", [this](sol::this_state ts) -> sol::object
	{
	auto obj = GetLastFunctionHandleShared();
	auto ret = obj->GetScriptTable(ts);
	ret["__obj"] = obj;
	return ret;
	});
	return true;
	}
	CCallbackHandler& operator+=(FuncTypeUniquePtr&& func)
	{
	Add(std::move(func));
	return *this;
	}
	FuncTypeRawPtr Add(FuncTypeUniquePtr&& func)
	{
	Functions.push_back(std::move(func));
	SetupSingleFunctionTransformers(Functions.back());
	return Functions.back().get();
	}
	bool IsEmpty() const
	{
	return Functions.empty();
	}
	operator bool() const
	{
	return !Functions.empty();
	}
	void operator()(Args... args) const
	{
	return Call(args...);
	}
	void Call(Args... args) const
	{
	if (!IsEnabled()) { return; }
	for (auto& func : Functions)
	{
	(*func)(args...);
	}
	}
	sol::object CallFromLua(sol::variadic_args va, sol::state_view s) override
	{
	if (!IsEnabled()) { return sol::lua_nil; }
	if constexpr (std::is_same_v<Ret, void>)
	{
	for (auto& func : Functions)
	{
	func->CallFromLua(va, s);
	}
	return sol::lua_nil;
	}
	else
	{
	size_t index = 1;
	sol::table ret = s.create_table();
	for (auto& func : Functions)
	{
	ret[index] = func->CallFromLua(va, s);
	index++;
	}
	return ret;
	}
	}
	ReturnsVector CallWithReturns(Args... args) const
	{
	if (!IsEnabled()) { return ReturnsVector(); }
	ReturnsVector ret;
	if constexpr (std::is_void_v<Ret>)
	{
	ret.resize(Functions.size());
	std::fill(ret.begin(), ret.end(), int(0));
	for (auto& func : Functions)
	{
	(*func)(args...);
	}
	return ret;
	}
	else
	{
	ret.reserve(Functions.size());
	for (auto& func : Functions)
	{
	Ret result = (*func)(args...);
	ret.push_back(result);
	}
	return ret;
	}
	}
	CFunction<Ret, Args...>* AddFunction(const std::function<Ret(Args...)>& func)
	{
	Functions.push_back(std::make_unique<CFunction<Ret, Args...>>(func));
	SetupSingleFunctionTransformers(Functions.back());
	return dynamic_cast<CFunction<Ret, Args...>*>(Functions.back().get());
	}
	CLuaFunction<Ret, Args...>* AddLuaFunction(const sol::protected_function& func)
	{
	Add(std::make_unique<CLuaFunction<Ret, Args...>>(func));
	return dynamic_cast<CLuaFunction<Ret, Args...>*>(Functions.back().get());
	}
	CLuaFunction<Ret, Args...>* AddLuaFunction(std::unique_ptr<CLuaFunction<Ret, Args...>>&& func)
	{
	return dynamic_cast<CLuaFunction<Ret, Args...>*>(Add(func));
	}
	CCallbackHandler& operator+=(const std::function<Ret(Args...)>& func)
	{
	AddFunction(func);
	return *this;
	}
	CCallbackHandler& operator+=(const sol::protected_function& func)
	{
	AddLuaFunction(func);
	return *this;
	}
	bool IsEmpty()
	{
	return Functions.empty();
	}
	void SetupLuaTransformers(const CLuaArgsOutTransformer& outtransform, const CLuaArgsInTransformer& intransform)
	{
	LuaArgsOutTransformer = std::make_unique<CLuaArgsOutTransformer>(outtransform);
	LuaArgsInTransformer = std::make_unique<CLuaArgsInTransformer>(intransform);
	for(auto& func : Functions)
	{
	SetupSingleFunctionTransformers(func);
	}
	}
	size_t GetCount()
	{
	return Functions.size();
	}
	size_t GetLastIndex()
	{
	if(IsEmpty()) { return 0; }
	return GetCount() - 1;
	}
	CSmartCallback GetLastFunctionHandle()
	{
	return CSmartCallback(*this, Functions.empty() ? nullptr : Functions.back().get());
	}
	std::shared_ptr<CSmartCallback> GetLastFunctionHandleShared() override
	{
	return std::make_shared<CSmartCallback>(*this, Functions.empty() ? nullptr : Functions.back().get());
	}
	std::unique_ptr<CSmartCallback> GetLastFunctionHandleUnique()
	{
	return std::make_unique<CSmartCallback>(*this, Functions.empty() ? nullptr : Functions.back().get());
	}
	CSmartCallback GetFunctionHandle(FuncTypeRawPtr rawptr)
	{
	auto it = std::find_if(Functions.begin(), Functions.end(), [rawptr](auto& func) -> bool { return func.get() == rawptr; });
	return CSmartCallback(*this, (it == Functions.end()) ? nullptr : (*it).get());
	}
	std::shared_ptr<CSmartCallback> GetFunctionHandleShared(FuncTypeRawPtr rawptr)
	{
	auto it = std::find_if(Functions.begin(), Functions.end(), [rawptr](auto& func) -> bool { return func.get() == rawptr; });
	return std::make_shared<CSmartCallback>(*this, (it == Functions.end()) ? nullptr : (*it).get());
	}
	std::unique_ptr<CSmartCallback> GetFunctionHandleUnique(FuncTypeRawPtr rawptr)
	{
	auto it = std::find_if(Functions.begin(), Functions.end(), [rawptr](auto& func) -> bool { return func.get() == rawptr; });
	return std::make_unique<CSmartCallback>(*this, (it == Functions.end()) ? nullptr : (*it).get());
	}
	FuncTypeUniquePtr& GetLastFunction()
	{
	if(IsEmpty()) { throw std::runtime_error("No functions"); }
	return Functions.back();
	}
	FuncTypeRawPtr GetLastFunctionRaw()
	{
	if(IsEmpty()) { return nullptr; }
	return Functions.back().get();
	}
	void DeleteFunctionAtIndex(size_t index) override
	{
	if(index >= Functions.size()) { return; }
	Functions.erase(Functions.begin() + index);
	}
	void DeleteFunction(FuncTypeUniquePtr& smrptr)
	{
	auto it = std::find_if(Functions.begin(), Functions.end(), [&smrptr](auto& myptr) -> bool
	{
	return smrptr == myptr;
	});
	if(it == Functions.end()) { return; }
	Functions.erase(it);
	}
	void DeleteFunction(FuncTypeRawPtr ptr)
	{
	auto it = std::find_if(Functions.begin(), Functions.end(), [ptr](auto& myptr) -> bool
	{
	return ptr == myptr.get();
	});
	if(it == Functions.end()) { return; }
	Functions.erase(it);
	}
	void m_deleteFunction(void* ptr) override
	{
	auto it = std::find_if(Functions.begin(), Functions.end(), [ptr](auto& myptr) -> bool
	{
	return ptr == static_cast<void*>(myptr.get());
	});
	if(it == Functions.end()) { return; }
	Functions.erase(it);
	}
	void DeleteFunctionsByName(const std::string& name) override
	{
	if(name.empty()) { return; }
	std::erase_if(Functions, [&name](auto& ptr) -> bool
	{
	return ptr->HasName() && ptr->GetName() == name;
	});
	}
	std::vector<FuncTypeUniquePtr> Functions;
	private:
	void SetupSingleFunctionTransformers(FuncTypeUniquePtr& func)
	{
	CLuaFunction<Ret, Args...>* luafunc = dynamic_cast<CLuaFunction<Ret, Args...>*>(func.get());
	if(luafunc && LuaArgsOutTransformer)
	{
	luafunc->MakeCustomOutCaller(*LuaArgsOutTransformer);
	}
	if(LuaArgsInTransformer)
	{
	func->MakeCustomInCaller(*LuaArgsInTransformer);
	}
	}
	std::unique_ptr<CLuaArgsOutTransformer> LuaArgsOutTransformer;
	std::unique_ptr<CLuaArgsInTransformer> LuaArgsInTransformer;
	};