#pragma once
	#include "CWrapableBase.h"
	#include "CCallbackHandler.h"
	#include "CConversionRegistry.h"
	#include "ILuaWrapableBase.h"
	#include "CScriptFieldsManager.h"
	#include "U_String.h"
	#include "U_Types.h"
	#include "U_Scripting.h"
	#include "U_SafeLuaCall.h"
	template<typename T>
	class CTypedWrapableBase : public virtual CWrapableBase
	{
	public:
	using ValueType = T;
	CScriptFieldsManager ScriptFields;
	CTypedWrapableBase()
	{
	OnValueChanged.SetupLuaTransformers([](const sol::function& func, CTypedWrapableBase<T>* self, T old, T newval) -> void
	{
	SafeCallLua(func, self->GetScriptTable(func.lua_state()), old, newval);
	//func(old, newval);
	},
	[this](auto func, sol::variadic_args va)
	{
	T args[2];
	for(size_t i = 0; i < va.size() && i < sizeof(args) / sizeof(args[0]); i++)
	{
	sol::object obj = va.get<sol::object>();
	if(obj.valid() && obj.is<T>())
	{
	args[i] = obj.as<T>();
	}
	}
	func->Call(this, args[0], args[1]);
	return sol::make_object<int>(va.lua_state(), 0);
	});
	OnScriptInit += [this](std::shared_ptr<sol::state> _state, sol::table _table) -> bool
	{
	ScriptFields.AddField("value", std::make_unique<CFunctionalScriptField>(
	[this](sol::state_view sv) -> sol::object
	{
	return ScriptUtils::ToObject<T>(GetValue(), sv);
	},
	[this](sol::object obj) -> void
	{
	SetValue(ScriptUtils::FromObject<T>(obj));
	}));
	sol::table onvaluechanged = OnValueChanged.GetScriptTable(_state);
	_table["onvaluechanged"] = onvaluechanged;
	ScriptFields.CreateMetaTable(_table);
	return true;
	};
	}
	CTypedWrapableBase(const T& val) : CTypedWrapableBase()
	{
	SetValue(val);
	}
	const std::string GetType() const override
	{
	return GetTypeName<T>();
	}
	const std::type_info& GetTypeInfo() const override
	{
	return typeid(T);
	}
	size_t GetSize() const override
	{
	return sizeof(T);
	}
	void SetValue(const T& value)
	{
	T oldValue = m_getValue();
	m_setValue(value);
	if (!OnValueChanged.IsEmpty())
	{
	OnValueChanged(this, oldValue, value);
	}
	if (!OnStrValueChanged.IsEmpty())
	{
	constexpr bool is_string = std::is_same_v<T, std::string>;
	constexpr bool is_wstring = std::is_same_v<T, std::wstring>;
	if constexpr (is_string)
	{
	OnStrValueChanged(this, StringUtils::StrToWstr(oldValue), StringUtils::StrToWstr(value));
	}
	else if constexpr (is_wstring)
	{
	OnStrValueChanged(this, oldValue, value);
	}
	else
	{
	OnStrValueChanged(this, StringUtils::ToStr<std::wstring>(oldValue), StringUtils::ToStr<std::wstring>(value));
	}
	}
	if(!OnValueChangedShared.IsEmpty())
	{
	OnValueChangedShared(this);
	}
	}
	T GetValue() const
	{
	return m_getValue();
	}
	void SetValueStr(const std::wstring& str) override
	{
	constexpr bool is_string = std::is_same_v<T, std::string>;
	constexpr bool is_wstring = std::is_same_v<T, std::wstring>;
	if constexpr (is_string)
	{
	SetValue(StringUtils::WstrToStr(str));
	}
	else if constexpr (is_wstring)
	{
	SetValue(str);
	}
	else
	{
	SetValue(StringUtils::FromStr<T, std::wstring>(str));
	}
	}
	std::wstring GetValueStr() const override
	{
	constexpr bool is_string = std::is_same_v<T, std::string>;
	constexpr bool is_wstring = std::is_same_v<T, std::wstring>;
	if constexpr (is_string)
	{
	return StringUtils::StrToWstr(m_getValue());
	}
	else if constexpr (is_wstring)
	{
	return m_getValue();
	}
	else
	{
	return StringUtils::ToStr<std::wstring, T>(m_getValue());
	}
	}
	void* m_castToAny(const std::type_info& targetType) const override
	{
	T arg = m_getValue();
	return CConversionRegistry::GetInstance()->convert(&arg, GetTypeInfo(), targetType);
	}
	void m_setByPtr(void* ptr, const std::type_info& targetType) override
	{
	void* var = CConversionRegistry::GetInstance()->convert(ptr, targetType, GetTypeInfo());
	if (!var) { return; }
	T toset = *reinterpret_cast<T*>(var);
	SetValue(toset);
	delete var;
	}
	virtual void m_setValue(const T& val) = 0;
	virtual T m_getValue() const = 0;
	CCallbackHandler<void, CTypedWrapableBase<T>*, T, T> OnValueChanged;
	};