#include "CLogger.h"
#include "CEngine.h"
#include "CTerminal.h"
#include "CFunction.h"
#include "CStartupArgsManager.h"
#include "CConVarManager.h"
#include "CWrapable.h"

#include <future>
#include <chrono>
#include <thread>

std::wofstream* CLogger::m_OpenStream(std::string path)
{
	if (streams.find(path) == streams.end())
	{
		std::wofstream wf;
		wf.open(path, std::ios::app | std::ios::out);

		if (!wf.is_open()) { return nullptr; }
		streams[path] = std::move(wf);
	}

	return &streams[path];
}

bool CLogger::V_Init()
{
	std::string outPath, errPath, slowModeDelay;

	bool notasync = false;
	bool forceasync = false;
	bool nofiles = false;

	COMPONENT_CALL_GET(outPath, CStartupArgsManager, GetArgumentValue("-out"));
	COMPONENT_CALL_GET(errPath, CStartupArgsManager, GetArgumentValue("-err"));
	COMPONENT_CALL_GET(slowModeDelay, CStartupArgsManager, GetArgumentValue("-slowloggerdelay"));
	COMPONENT_CALL_GET(notasync, CStartupArgsManager, IsArgumentSet("-synclogger"));
	COMPONENT_CALL_GET(forceasync, CStartupArgsManager, IsArgumentSet("-asynclogger"));
	COMPONENT_CALL_GET(nofiles, CStartupArgsManager, IsArgumentSet("-loggernofiles"));
	COMPONENT_CALL_GET(m_slowMode, CStartupArgsManager, IsArgumentSet("-slowlogger"));

	if(m_slowMode && !slowModeDelay.empty())
	{
		m_slowModeDelay = StringUtils::FromStr<unsigned int>(slowModeDelay);
	}

	if(notasync) { m_isAsync = false; }
	if(forceasync) { m_isAsync = true; }

	if(!nofiles)
	{
		outstream = m_OpenStream(outPath);
		errstream = m_OpenStream(errPath);
	}

	if (m_isAsync)
	{
		outqueue.reserve(128);
		errqueue.reserve(128);

		m_thread = std::make_unique<std::thread>(&CLogger::m_ThreadedWorker, this);
	}
	return true;
}

void CLogger::V_PostInit()
{
	auto mgr = CEngine::GetInstance()->Components.GetComponentTyped<CConVarManager>();

	mgr->AddConVar("time.limit.logger.maxfps", new CWrapable<unsigned int>(20));
	mgr->AddConVar("time.limit.logger.yield", new CWrapable<bool>(true));
	mgr->AddConVar("time.limit.logger.adaptive_sleep", new CWrapable<bool>(true));
	mgr->AddConVar("time.limit.logger.strict_sleep", new CWrapable<bool>(false));
}

void CLogger::V_Update()
{
	if(CClock::now() - lastsync >= std::chrono::duration<float>(sync_datas_interval))
	{
		auto mgr = CEngine::GetInstance()->Components.GetComponentTyped<CConVarManager>();
		async_data data;

		data.adaptive_sleep = mgr->GetConVarValue<unsigned int>("time.limit.logger.maxfps");
		data.yield = mgr->GetConVarValue<bool>("time.limit.logger.yield");
		data.adaptive_sleep = mgr->GetConVarValue<bool>("time.limit.logger.adaptive_sleep");
		data.strict_sleep = mgr->GetConVarValue<bool>("time.limit.logger.strict_sleep");

		{
			std::lock_guard _lock(async_data_mutex);
			threaded_async = data;
		}
		lastsync = CClock::now();
	}
}

CLogger::~CLogger()
{
	if (m_isAsync)
	{
		AskedToStop.store(true, std::memory_order_relaxed);
		while (!Stopped)
		{
			std::this_thread::yield();
		}

		if(m_thread->joinable())
		{
			m_thread->join();
		}
	}

	if (outstream && outstream->is_open()) { outstream->flush(); outstream->close(); }
	if (errstream && errstream->is_open()) { errstream->flush(); errstream->close(); }
}

void CLogger::m_flushOut(const std::wstring& str)
{
	if (outstream && outstream->is_open())
	{
		(*outstream) << str;
		outstream->flush();
	}

	if(!CEngine::GetInstance()->GetStopFlag())
	{
		COMPONENT_CALL(CTerminal, Print(str));
	}
	m_Wait();
}

void CLogger::m_flushErr(const std::wstring& err)
{
	if (errstream && errstream->is_open())
	{
		(*errstream) << err;
		errstream->flush();
	}

	if(!CEngine::GetInstance()->GetStopFlag())
	{
		COMPONENT_CALL(CTerminal, Error(err));
	}
	m_Wait();
}

void CLogger::Out(const std::wstring& str)
{
	if (m_isAsync)
	{
		std::lock_guard lock(mutex);
		outqueue.push_back(str);
	}
	else
	{
		m_flushOut(str);
	}

	OnOut(str);
}

void CLogger::Err(const std::wstring& err)
{
	if (m_isAsync)
	{
		std::lock_guard lock(mutex);
		errqueue.push_back(err);
	}
	else
	{
		m_flushErr(err);
	}

	OnErr(err);
}

void CLogger::Outln(const std::wstring& str)
{
	Out(str + L"\n");
}

void CLogger::Errln(const std::wstring& err)
{
	Err(err + L"\n");
}

void CLogger::SetAsync()
{
	m_isAsync = true;
}

bool CLogger::IsAsync()
{
	return m_isAsync;
}

void CLogger::m_ThreadedWorker()
{
	std::vector<std::wstring> outcopy, errcopy;

	while (true)
	{
		//mgr->AddConVar("time.limit.logger.maxfps", new CWrapable<unsigned int>(20));
		//mgr->AddConVar("time.limit.logger.yield", new CWrapable<bool>(true));
		//mgr->AddConVar("time.limit.logger.adaptive_sleep", new CWrapable<bool>(true));
		//mgr->AddConVar("time.limit.logger.strict_sleep", new CWrapable<bool>(false));

		async_data asdata;
		{
			std::lock_guard _lock(async_data_mutex);
			asdata = threaded_async;
		}

		Sleeper.Start(asdata.maxfps);

		{
			std::lock_guard lock(mutex);

			if(!outqueue.empty()) { outcopy.swap(outqueue); }
			if(!errqueue.empty()) { errcopy.swap(errqueue); }
		}

		for (const auto& s : outcopy) { m_flushOut(s); }
		for (const auto& e : errcopy) { m_flushErr(e); }

		outcopy.clear();
		errcopy.clear();

		if (AskedToStop.load(std::memory_order_acquire)) 
		{
			Stopped.store(true, std::memory_order_release);
			break;
		}

		Sleeper.End(asdata.yield, asdata.adaptive_sleep, asdata.strict_sleep);
	}
}

bool CLogger::V_ScriptInit(std::shared_ptr<sol::state> state, sol::table table)
{
	table.set_function("out", [this](const std::wstring& text) { Out(text); });
	table.set_function("outln", [this](const std::wstring& text) { Outln(text); });
	table.set_function("err", [this](const std::wstring& err) { Err(err); });
	table.set_function("errln", [this](const std::wstring& err) { Errln(err); });

	return true;
}

void CLogger::m_Wait() const
{
	if(!m_slowMode) { return; }
	std::this_thread::sleep_for(std::chrono::milliseconds(m_slowModeDelay));
}

sol::object CLogger::V_GetScriptUserType(sol::state_view state)
{
	return sol::make_object(state, this);
}

LINK_COMPONENT_TO_CLASS(CLogger, logger);