#include "CTime.h"
#include "CConVarManager.h"
#include "CEngine.h"
#include "CLogger.h"
#include "CScriptFieldsManager.h"
#include "U_Scripting.h"

void CTime::Init()
{
    m_LastTick = m_NextTick = m_CurrentTick = m_LastFpsCheck = CClock::now();
}

void CTime::NewTick()
{
    m_CurrentTick = CClock::now();

    std::chrono::duration<double> delta = m_CurrentTick - m_LastTick;
    m_DeltaTime = delta.count();

    m_LastTick = m_CurrentTick;
    COMPONENT_CALL_GET(m_MaxFps, CConVarManager, GetConVarValue<unsigned int>("fps.max"));

    if (m_MaxFps)
    {
        m_WaitTime = 1.0 / static_cast<double>(m_MaxFps);
        auto interval = std::chrono::duration<double>(m_WaitTime);

        m_NextTick = std::chrono::time_point_cast<CClock::duration>(m_CurrentTick + interval);
    }
    else
    {
        m_NextTick = m_CurrentTick;
    }
    OnNewTick();
}

void CTime::EndTick()
{
    auto now = CClock::now();
    auto mgr = CEngine::GetInstance()->Components.GetComponentTyped<CConVarManager>();

    bool yield = mgr->GetConVarValue<bool>("time.limit.yield");
    bool adaptive_sleep = mgr->GetConVarValue<bool>("time.limit.adaptive_sleep");
    bool strict_sleep = mgr->GetConVarValue<bool>("time.limit.strict_sleep");

    if (m_MaxFps)
    {
        if(adaptive_sleep)
        {
            if (now < m_NextTick)
            {
                std::this_thread::sleep_until(m_NextTick);
            }
            else
            {
                //too late!
                m_NextTick = now;
            }
        }

        if(strict_sleep)
        {
            std::this_thread::sleep_for(std::chrono::duration<double>(m_WaitTime));
        }

        while (CClock::now() < m_NextTick)
        {
            if(yield)
            {
                std::this_thread::yield();
            }
        }
    }

    now = CClock::now();

    if(now - m_LastFpsCheck >= std::chrono::seconds(1))
    {
        bool dump = false;
        COMPONENT_CALL_GET(dump, CConVarManager, GetConVarValue<bool>("fps.dump"));

        if(dump)
        {
            COMPONENT_CALL(CLogger, Outln(L"FPS is " + StringUtils::ToStr<std::wstring>(m_FPS) + L" with deltatime " + StringUtils::ToStr<std::wstring>(m_DeltaTime) + 
                                            L" and maxfps is " + StringUtils::ToStr<std::wstring>(m_MaxFps)));
        }

        m_PrevFPS = m_FPS;
        m_FPS = 0;

        m_LastFpsCheck = now;
    }

    m_FPS++;
    OnEndTick();
}

unsigned int CTime::GetFPS() const
{
    return m_FPS;
}

unsigned int CTime::GetPrevFPS() const
{
    return m_PrevFPS;
}

float CTime::GetDeltaTime() const
{
    return static_cast<float>(m_DeltaTime);
}

double CTime::GetDeltaTimePrecise() const
{
    return m_DeltaTime;
}

void CTime::ResetDeltaTime(double resetValue)
{
    m_DeltaTime = resetValue;
}

CTimePoint CTime::GetCurrent() const
{
    return CClock::now();
}

bool CTime::V_ScriptInit(std::shared_ptr<sol::state> state, sol::table table)
{
    sol::table onNewTick = OnNewTick.GetScriptTable(state);
    sol::table onEndTick = OnEndTick.GetScriptTable(state);

    table["onNewTick"] = onNewTick;
    table["onEndTick"] = onEndTick;

    static std::unordered_map<std::string, CTimePoint> measures;

    table.set_function("start_measure", [](const std::string& name)
    {
        measures.emplace(name, CEngine::GetInstance()->Time.GetCurrent());
    });

    table.set_function("stop_measure", [](const std::string& name) -> float
    {
        auto it = measures.find(name);
        if(it == measures.end()) { return 0.0f; }

        auto now = CEngine::GetInstance()->Time.GetCurrent();
        auto past = it->second;

        measures.erase(it);
        return std::chrono::duration_cast<std::chrono::duration<float>>(now - past).count();
    });

    auto fieldsMan = CScriptFieldsManager::CreateFieldsManager(table);

    auto scDeltaTime = std::make_unique<CFunctionalScriptField>([this](sol::state_view st) -> sol::object
    { return ScriptUtils::ToObject<float>(GetDeltaTime(), st); });

    auto scDeltaTimePrecise = std::make_unique<CFunctionalScriptField>([this](sol::state_view st) -> sol::object
    { return ScriptUtils::ToObject<double>(GetDeltaTimePrecise(), st); });

    auto scFps = std::make_unique<CFunctionalScriptField>([this](sol::state_view st) -> sol::object
    { return ScriptUtils::ToObject<unsigned int>(GetPrevFPS(), st); });

    auto scCurrentFps = std::make_unique<CFunctionalScriptField>([this](sol::state_view st) -> sol::object
    { return ScriptUtils::ToObject<unsigned int>(GetFPS(), st); });

    fieldsMan->AddField("deltaTime", std::move(scDeltaTime));
    fieldsMan->AddField("deltaTimePrecise", std::move(scDeltaTimePrecise));
    fieldsMan->AddField("fps", std::move(scFps));
    fieldsMan->AddField("fpsCurrent", std::move(scCurrentFps));

    fieldsMan->CreateMetaTable(table);
    return true;
}