#include "CTypesEngine.h"
	#include "CTypesRegistering.h"
	#include "CEngine.h"
	#include "U_ScriptClasses.h"
	#include "CScriptingEngine.h"
	#include "CScenesManager.h"
	void CScriptingEngine::RegisterEngineType()
	{
	State->new_usertype<CComponentsManager>
	(
	"CComponentsManager",
	sol::no_constructor,
	"IsComponentPresent", [](CComponentsManager& mgr, const std::string& _name)
	{
	std::string name = _name;
	std::transform(name.begin(), name.end(), name.begin(), ::tolower);
	return mgr.IsComponentPresent(name);
	},
	"GetComponent", [](CComponentsManager& mgr, const std::string& _name, sol::this_state ts) -> sol::object
	{
	std::string name = _name;
	std::transform(name.begin(), name.end(), name.begin(), ::tolower);
	auto comp = mgr.GetComponentRaw(name);
	if(comp)
	{
	return comp->GetScriptUserType(ts);
	}
	return sol::lua_nil;
	},
	"Create", [](CComponentsManager& mgr, const std::string& _type, sol::object instantInitObj, sol::this_state ts) -> sol::object
	{
	std::string type = _type;
	std::transform(type.begin(), type.end(), type.begin(), ::tolower);
	bool instantInit = true;
	if(instantInitObj.valid() && instantInitObj.is<bool>())
	{
	instantInit = instantInitObj.as<bool>();
	}
	if(!mgr.IsComponentPresent(type))
	{
	mgr.CreateComponent(type, instantInit);
	if(!mgr.IsComponentPresent(type)) { return sol::lua_nil; }
	}
	return mgr.GetComponent(type)->GetScriptUserType(ts); //TODO problem, if not initted table might not be created properly
	},
	"Register", [](CComponentsManager& mgr, sol::table functions, sol::this_state ts)
	{
	InvokeRegisterFunction<CComponent, "component">(functions, ts);
	},
	"Trace", [](CComponentsManager& mgr, sol::function func)
	{
	mgr.Trace([&func](CComponent* comp) { func(comp); });
	},
	"ReverseTrace", [](CComponentsManager& mgr, sol::function func)
	{
	mgr.ReverseTrace([&func](CComponent* comp) { func(comp); });
	}
	);
	State->new_usertype<CTime>
	(
	"CTime",
	"Init", &CTime::Init,
	"NewTick", &CTime::NewTick,
	"EndTick", &CTime::EndTick,
	"GetCurrent", &CTime::GetCurrent,
	"GetFPS", &CTime::GetFPS,
	"GetPrevFPS", &CTime::GetPrevFPS,
	"ResetDeltaTime", [](CTime& _time, sol::object obj)
	{
	double toSet = 0.0;
	if(obj.valid() && obj.is<double>())
	{
	toSet = obj.as<double>();
	}
	_time.ResetDeltaTime(toSet);
	},
	"DeltaTime", sol::property([](CTime& _time) { return _time.GetDeltaTime(); }),
	"DeltaTimePrecise", sol::property([](CTime& _time) { return _time.GetDeltaTimePrecise(); }),
	"GetDeltaTime", &CTime::GetDeltaTime,
	"GetDeltaTimePrecise", &CTime::GetDeltaTimePrecise,
	"OnNewTick", sol::property([](CTime& _time) -> HANDLER
	{
	return _time.OnNewTick;
	}),
	"OnEndTick", sol::property([](CTime& _time) -> HANDLER
	{
	return _time.OnEndTick;
	})
	);
	State->new_usertype<CBuildInfo>
	(
	"CBuildInfo",
	"Date", sol::property([](CBuildInfo& b) { return CBuildInfo::GetBuildDate(); }),
	"Time", sol::property([](CBuildInfo& b) { return CBuildInfo::GetBuildTime(); }),
	"Compiler", sol::property([](CBuildInfo& b) { return CBuildInfo::GetCompiler(); }),
	"OperatingSystem", sol::property([](CBuildInfo& b) { return CBuildInfo::GetOperatingSystemName(); })
	);
	State->new_usertype<CEngine>
	(
	"CEngine",
	sol::meta_function::index,
	[](CEngine& engine, const std::string& _key, sol::this_state ts) -> sol::object
	{
	sol::state_view lua(ts);
	std::string key = _key;
	std::transform(key.begin(), key.end(), key.begin(), ::tolower);
	auto* comp = engine.Components.GetComponentRaw(key);
	if (comp)
	{
	return comp->GetScriptUserType(ts);
	//return sol::make_object(lua, comp);
	}
	return sol::nil;
	},
	"Init", &CEngine::Init,
	"DeInit", &CEngine::DeInit,
	"Update", &CEngine::Update,
	"Quit", &CEngine::Quit,
	"GetStopFlag", &CEngine::GetStopFlag,
	"BuildInfo", &CEngine::BuildInfo,
	"Time", &CEngine::Time,
	"CommandLine", &CEngine::CommandLine,
	"Components", &CEngine::Components,
	"GetMainCameraTransform", [](CEngine& engine, sol::this_state ts) -> sol::object //TODO temporary
	{
	auto scenesMan = engine.Components.GetComponentTyped<CScenesManager>();
	if(!scenesMan) { return sol::lua_nil; }
	auto mainScene = scenesMan->ActiveScene;
	if(!mainScene.lock()) { return sol::lua_nil; }
	auto _mainCamera = mainScene.lock()->CamerasManager.ActiveCamera;
	if(!_mainCamera.lock()) { return sol::lua_nil; }
	auto mainCamera = _mainCamera.lock();
	return sol::make_object(ts, &mainCamera->Transform);
	},
	"Register", [](CEngine& engine, sol::table tabl, sol::this_state ts) -> int
	{
	sol::object root_typenm = tabl["root_type"];
	if(!root_typenm.valid() || !root_typenm.is<std::string>()) { return 6; }
	std::string _strroottypenm = root_typenm.as<std::string>();
	std::string strroottypenm = _strroottypenm;
	std::transform(strroottypenm.begin(), strroottypenm.end(), strroottypenm.begin(), ::tolower);
	if(strroottypenm == "component")
	{
	return InvokeRegisterFunction<CComponent, "component">(tabl, ts);
	}
	else if(strroottypenm == "entity")
	{
	return InvokeRegisterFunction<CEntity, "entity">(tabl, ts);
	}
	else if(strroottypenm == "resource")
	{
	return InvokeRegisterFunction<CResource, "resource">(tabl, ts);
	}
	return 7;
	}
	);
	}