#include "CResource.h"
#include "CEngine.h"
#include "CResourcesManager.h"

#include <filesystem>

CLoadingContext::CLoadingContext(CResource* _current_resource, const std::filesystem::path& _path) : CurrentResource(_current_resource), LoadPath(_path)
{
    //Log::Instance() << "CLoadingContext::CLoadingContext\n"; LOGLOG
}

CResource::CResource()
{
}

CResource::~CResource()
{
}

bool CResource::Load(const std::filesystem::path& path)
{
    std::filesystem::path pp(path);
    Name = pp.stem().string();

    bool loaded = V_Load(path);
    if(!loaded) { Name.clear(); return false; }

    COMPONENT_CALL(CResourcesManager, RegisterResource(shared_from_this()));
    return true;
}

bool CResource::V_Load(const std::filesystem::path& path)
{
    return true;
}

bool CResource::V_SynchronisedLoad()
{
    return true;
}

bool CResource::IsReady() const
{
    return LoadingStatus == CResource::CLoadingStatus::Done;
}

void CResource::SetupLoadPipeline(CLoadPipeline& pipeline)
{
    V_BaseSetupLoadPipeline(pipeline);
    V_SetupLoadPipeline(pipeline);
    GetLoadPipelineSetupCallback()(pipeline);
}

void CResource::V_SetupLoadPipeline(CLoadPipeline& pipeline)
{

}

void CResource::V_BaseSetupLoadPipeline(CLoadPipeline& pipeline)
{

}

std::shared_ptr<CLoadingContext> CResource::CreatePipelineContext(const std::filesystem::path& path)
{
    return std::make_shared<CLoadingContext>(this, path);
}

void CResource::StartPipeline(const std::filesystem::path& path)
{
    LoadingContext = CreatePipelineContext(path);
    LoadingFunctionIndex = 0;
    LoadingStatus = CResource::CLoadingStatus::Waiting;
}

void CResource::PipelineWaitForRequired()
{
    LoadingStatus = CResource::CLoadingStatus::WaitingForRequired;
}

void CResource::PipelineCheckRequired()
{
    if(LoadingContext->RequiredResources.empty()) { return; }

    //Log::Instance() << "For " << GetType() << " " << Name << ":\n";

    bool allOk = true;
    for(auto res : LoadingContext->RequiredResources)
    {
        //Log::Instance() << "Checking required " << res->GetType() << " " << res->Name << " status " << (int)res->LoadingStatus << Log::Endl; 
        if(res->LoadingStatus != CResource::CLoadingStatus::Done)
        {
            allOk = false;
            break;
        }
    }

    if(!allOk && LoadingStatus != CResource::CLoadingStatus::WaitingForRequired)
    {
        LoadingStatus = CResource::CLoadingStatus::WaitingForRequired;
    }
    else if(allOk)
    {
        LoadingStatus = CResource::CLoadingStatus::Waiting;
    }
    
    //Log::Instance() << "PipelineCheckRequired set status to " << (int)LoadingStatus << " with allok " << allOk << Log::Endl;
}

void CResource::ProcessPipeline()
{
    if(LoadingStatus == CResource::CLoadingStatus::CompletedAsync && LoadingFunctionIndex < 0 && !LoadingContext)
    {
        LoadingStatus = CResource::CLoadingStatus::Done;
        return;
    }

    if(!LoadingContext) { return; }
    PipelineCheckRequired();

    if(LoadingStatus == CResource::CLoadingStatus::WaitingForRequired
        || LoadingStatus == CResource::CLoadingStatus::WaitingAsync
        || LoadingStatus == CResource::CLoadingStatus::StartedAsync) { return; }
    if(LoadingFunctionIndex < 0) { return; }

    auto resman = CEngine::GetInstance()->Components.GetComponentTyped<CResourcesManager>();
    auto& pipeline = GetLoadPipeline();

    for(; LoadingFunctionIndex < pipeline.size(); )
    {
        auto& func = pipeline.at(LoadingFunctionIndex);

        if(!func.RunAsync)
        {
            if (LoadingContext->CurrentAsyncFuture.valid())
            {
                LoadingContext->CurrentAsyncFuture.wait();
                LoadingContext->CurrentAsyncFuture = {};
            }

            LoadingStatus = CResource::CLoadingStatus::Sync;
            func.Function(LoadingContext);
            LoadingFunctionIndex++;

            PipelineCheckRequired();
            if(LoadingStatus == CResource::CLoadingStatus::WaitingForRequired
                || LoadingStatus == CResource::CLoadingStatus::WaitingAsync
                || LoadingStatus == CResource::CLoadingStatus::StartedAsync) { return; }
        }
        else
        {
            LoadingStatus = CResource::CLoadingStatus::WaitingAsync;

            auto promise = std::make_shared<std::promise<void>>();
            LoadingContext->CurrentAsyncFuture = promise->get_future().share();

            auto waitingpromise = std::make_shared<std::promise<void>>();
            WaitingFuture = waitingpromise->get_future().share();

            auto thisResource = shared_from_this();

            resman->AsyncLoadingPool.AddTask([func, this, promise, waitingpromise, thisResource]()
            {
                this->LoadingStatus = CResource::CLoadingStatus::StartedAsync;
                func.Function(this->LoadingContext);

                if(this->LoadingStatus != CResource::CLoadingStatus::Done)
                {
                    this->LoadingStatus = CResource::CLoadingStatus::CompletedAsync;
                }

                promise->set_value();
                waitingpromise->set_value();
            });

            LoadingFunctionIndex++;
            break;
        }
    }

    if
    (
        LoadingFunctionIndex >= pipeline.size() - 1 &&
        LoadingStatus != CResource::CLoadingStatus::WaitingForRequired &&
        LoadingStatus != CResource::CLoadingStatus::WaitingAsync &&
        LoadingStatus != CResource::CLoadingStatus::StartedAsync
    )
    {
        LoadingFunctionIndex = -1;
        LoadingStatus = CResource::CLoadingStatus::Done;
        LoadingContext.reset();
        OnDoneLoading(this);
    }
}

//this entire function doesn't make any sense
//we should update all the resources so they'll all load as
//requirements for others
//
//also wait can be called from other threads which is invalid behaviour
void CResource::Wait()
{
    if(!LoadingContext) { Log::Instance() << "Can't wait\n"; return; }
    while(LoadingStatus != CResource::CLoadingStatus::Done)
    {
        if(LoadingStatus == CResource::CLoadingStatus::WaitingAsync ||
            LoadingStatus == CResource::CLoadingStatus::StartedAsync)
        {
            if (WaitingFuture.valid())
            {
                WaitingFuture.wait();
                WaitingFuture = {};
            }
        }
        else
        {
            for(auto res : LoadingContext->RequiredResources)
            {
                if(res->LoadingStatus != CResource::CLoadingStatus::Done)
                {
                    res->ProcessPipeline();
                    break;
                }
            }
            ProcessPipeline();
            //TODO don't do active waiting
        }
    }
    Log::Instance() << "Wait end\n";
    WaitingFuture = {};
}

CLoadPipeline& CResource::GetLoadPipeline()
{
    auto resman = CEngine::GetInstance()->Components.GetComponentTyped<CResourcesManager>();
    auto& cache = resman->PipelinesCache.Cache;

    auto it = cache.find(GetType());

    if(it == cache.end())
    {
        CLoadPipeline pipeline;

        SetupLoadPipeline(pipeline);
        return cache.emplace(GetType(), std::move(pipeline)).first->second;
    }
    return it->second;
}

CLoadCallback& CResource::GetLoadPipelineSetupCallback()
{
    auto resman = CEngine::GetInstance()->Components.GetComponentTyped<CResourcesManager>();
    auto& cache = resman->PipelinesCache.CacheCallbacks;

    auto it = cache.find(GetType());

    if(it == cache.end())
    {
        return cache.emplace(GetType(), CLoadCallback()).first->second;
    }
    return it->second;
}