#include "CEntity.h"
	#include "CEntityHandle.h"
	#include "U_ShortAPI.h"
	CEntity::CEntity() : Components(this) {}
	CEntity::~CEntity() { OnDestruct(this); }
	std::string CEntity::GetType() const { return {}; }
	CEntityHandle CEntity::GetHandle() const
	{
	return CEntityHandle(this);
	}
	void CEntity::V_Update() {}
	void CEntity::OverridePersistent(serial_t serial, entityid_t id, worldid_t worldid)
	{
	SerialNumber = serial;
	UUID = id;
	WorldID = worldid;
	}
	void CEntity::AddInitParam(const std::string& name, CWrapableBase* wrapable)
	{
	if(!wrapable) { return; }
	InitParams.emplace(name, std::unique_ptr<CWrapableBase>(wrapable));
	}
	void CEntity::FullPack(CBufferWrapper& packet) {}
	void CEntity::FullUnpack(CBufferWrapper& packet) {}
	serial_t CEntity::GetSerialNumber() const
	{
	return SerialNumber;
	}
	entityid_t CEntity::GetUUID() const
	{
	return UUID;
	}
	worldid_t CEntity::GetWorldID() const
	{
	return WorldID;
	}
	void CEntity::Update()
	{
	Components.Trace([](CEntityComponent* _comp) { _comp->Update(); });
	V_Update();
	OnUpdate(this);
	}
	void CEntity::Init()
	{
	V_Init();
	OnInit(this);
	}
	void CEntity::SetNetSync(bool sync, bool sendMessage)
	{
	if(sendMessage)
	{
	if(NetSync && !sync)
	{
	//TODO stop net entity message
	}
	else if(!NetSync && sync)
	{
	//TODO start net entity message
	}
	}
	NetSync = sync;
	}
	bool CEntity::IsNetSync() const
	{
	return NetSync;
	}
	void CEntity::V_Init() {}
	void CEntity::PostInit()
	{
	Log::Instance() << "CEntity::PostInit\n";
	Components.Trace([](CEntityComponent* comp)
	{
	comp->Init();
	});
	V_PostInit();
	OnPostInit(this);
	}
	void CEntity::V_PostInit() {}
	bool CEntity::V_BaseScriptInit(std::shared_ptr<sol::state> state, sol::table table)
	{
	auto components = table.create_named("components");
	components.set_function("create", [this](const std::string& _typename, sol::object instantInit)
	{
	bool instantInitBool = true;
	if(instantInit.valid() && instantInit.is<bool>())
	{
	instantInitBool = instantInit.as<bool>();
	}
	Components.CreateComponent(_typename, instantInitBool);
	});
	components.set_function("isPresent", [this](const std::string& _typename) -> bool
	{
	return Components.IsComponentPresent(_typename);
	});
	SetFieldsManager(components, [this](FieldsManPtr fieldsMan)
	{
	//using Optional = std::optional<sol::object>;
	//using IndexFunc = std::function<Optional(sol::table, sol::object, sol::this_state)>;
	fieldsMan->AddIndexChecker([this](sol::table tabl, sol::object obj, sol::this_state ts) -> std::optional<sol::object>
	{
	if(obj.is<std::string>())
	{
	auto keystr = obj.as<std::string>();
	if(this->Components.IsComponentPresent(keystr))
	{
	auto& comp = this->Components.GetComponent(keystr);
	return comp->GetScriptTable(ts);
	}
	}
	return std::nullopt;
	});
	});
	table.set_function("init", [this]() { Init(); });
	table.set_function("postinit", [this]() { Init(); });
	table.set_function("update", [this]() { Update(); });
	table.set_function("getInitParam", [this](const std::string& name, sol::this_state ts) -> sol::object
	{
	auto param = GetInitParamRaw(name);
	if(!param.has_value()) { return sol::lua_nil; }
	auto luawrap = dynamic_cast<ILuaWrapableBase*>(param.value());
	if(!luawrap) { return sol::lua_nil; }
	return luawrap->ConvertToLua(ts);
	});
	table.set_function("setInitParam", [this](const std::string& name, sol::object obj, sol::this_state ts) -> int
	{
	if(obj.get_type() == sol::type::boolean) { AddInitParam(name, new CWrapable<bool>(obj.as<bool>())); }
	else if(obj.get_type() == sol::type::number) { AddInitParam(name, new CWrapable<double>(obj.as<double>())); }
	else if(obj.get_type() == sol::type::string) { AddInitParam(name, new CWrapable<std::wstring>(obj.as<std::wstring>())); }
	else { return 1; }
	return 0;
	});
	SetFieldsManager(table, [this](FieldsManPtr fieldsMan)
	{
	fieldsMan->AddField("type", std::make_unique<CFunctionalScriptField>([this](sol::state_view ts) -> sol::object { return sol::make_object(ts, this->GetType()); }));
	fieldsMan->AddField("serialNumber", std::make_unique<CFunctionalScriptField>([this](sol::state_view ts) -> sol::object { return sol::make_object<size_t>(ts, this->GetSerialNumber()); }));
	fieldsMan->AddField("uuid", std::make_unique<CFunctionalScriptField>([this](sol::state_view ts) -> sol::object { return sol::make_object<size_t>(ts, this->GetUUID()); }));
	fieldsMan->AddField("worldId", std::make_unique<CFunctionalScriptField>([this](sol::state_view ts) -> sol::object { return sol::make_object<size_t>(ts, this->GetWorldID()); }));
	fieldsMan->AddField("oninit", std::make_unique<CFunctionalScriptField>([this](sol::state_view ts) -> sol::object { return OnInit.GetScriptTable(ts); }));
	fieldsMan->AddField("onpostinit", std::make_unique<CFunctionalScriptField>([this](sol::state_view ts) -> sol::object { return OnPostInit.GetScriptTable(ts); }));
	fieldsMan->AddField("onupdate", std::make_unique<CFunctionalScriptField>([this](sol::state_view ts) -> sol::object { return OnUpdate.GetScriptTable(ts); }));
	fieldsMan->AddField("ondestruct", std::make_unique<CFunctionalScriptField>([this](sol::state_view ts) -> sol::object { return OnDestruct.GetScriptTable(ts); }));
	});
	return true;
	}
	std::optional<CWrapableBase*> CEntity::GetInitParamRaw(const std::string& name)
	{
	auto it = std::find_if(InitParams.begin(), InitParams.end(), [&name](auto& kv) -> bool { return kv.first == name; });
	if(it == InitParams.end()) { return std::nullopt; }
	return it->second.get();
	}