#pragma once
	#include "CFunctionBase.h"
	#include "U_ScriptingStates.h"
	#include "U_SafeLuaCall.h"
	#include "sol/sol.hpp"
	#include <functional>
	#include <iostream>
	template <typename ReturnValue, typename... Args>
	class CLuaFunction : public virtual CFunctionBase<ReturnValue, Args...>
	{
	public:
	//out - CPP to LUA
	//in - LUA TO CPP
	using CustomOutCallerFunction = std::function<ReturnValue(const sol::function&, Args...)>;
	CLuaFunction(const sol::function& _func) : State(ScriptStates::GetStateSharedPtr(_func.lua_state()))
	{
	Function = std::make_shared<sol::function>(_func);
	}
	CLuaFunction(const sol::function& _func, const CustomOutCallerFunction& _outcaller) : State(ScriptStates::GetStateSharedPtr(_func.lua_state()))
	{
	Function = std::make_shared<sol::function>(_func);
	MakeCustomOutCaller(_outcaller);
	}
	~CLuaFunction()
	{
	Function.reset();
	}
	ReturnValue Call(Args... args) const override
	{
	if (CustomOutCaller && Function && Function->valid())
	{
	return (*CustomOutCaller)(*Function, args...);
	}
	sol::object ret;
	if(Function && Function->valid())
	{
	ret = SafeCallLuaReturn((*Function), args...);
	//ret = (*Function)(args...);
	}
	if constexpr (!std::is_void_v<ReturnValue>)
	{
	return ret.valid() ? ret.as<ReturnValue>() : ReturnValue{};
	}
	}
	bool IsValid() const override
	{
	return Function && Function->valid();
	}
	void MakeCustomOutCaller(const CustomOutCallerFunction& outcaller)
	{
	CustomOutCaller.reset();
	CustomOutCaller = std::make_unique<CustomOutCallerFunction>(outcaller);
	}
	std::unique_ptr<CustomOutCallerFunction> CustomOutCaller;
	std::shared_ptr<sol::state> State;
	std::shared_ptr<sol::function> Function;
	};