#include "WorkerRequestsRemote.h"
#include "CookWorkerClient.h"
namespace UE
{
namespace Cook
{
FWorkerRequestsRemote::FWorkerRequestsRemote(UCookOnTheFlyServer& InCOTFS)
    : IWorkerRequests(InCOTFS), CookWorkerClient(*InCOTFS.CookWorkerClient)
{
}

FWorkerRequestsRemote::~FWorkerRequestsRemote()
{
}

void FWorkerRequestsRemote::OnRemoveSessionPlatform(const ITargetPlatform* TargetPlatform)
{
    ExternalRequests.OnRemoveSessionPlatform(TargetPlatform);
}

bool FWorkerRequestsRemote::DequeueCallbacks(TArray<FSchedulerCallback>& OutCallbacks)
{
    return ExternalRequests.DequeueCallbacks(OutCallbacks);
}

bool FWorkerRequestsRemote::HasRequests()
{
    return ExternalRequests.HasRequests();
}

void FWorkerRequestsRemote::AddCallback(FSchedulerCallback&& Callback)
{
    ExternalRequests.AddCallback(std::move(Callback));
}

void FWorkerRequestsRemote::EnqueueUnique(FFilePlatformRequest&& FileRequest, bool bForceFrontOfQueue)
{
    ExternalRequests.EnqueueUnique(std::move(FileRequest), bForceFrontOfQueue);
}

void FWorkerRequestsRemote::DequeueAll(TArray<FSchedulerCallback>& OutCallbacks, TArray<FFilePlatformRequest>& OutCookRequests)
{
    ExternalRequests.DequeueAll(OutCallbacks, OutCookRequests);
}

EExternalRequestType FWorkerRequestsRemote::DequeueRequest(TArray<FSchedulerCallback>& OutCallbacks, FFilePlatformRequest& OutToBuild)
{
    return ExternalRequests.DequeueRequest(OutCallbacks, OutToBuild);
}

int32 FWorkerRequestsRemote::GetNumRequests() const
{
    return ExternalRequests.GetNumRequests();
}

void FWorkerRequestsRemote::RemapTargetPlatforms(const TMap<ITargetPlatform*, ITargetPlatform*>& Remap)
{
    ExternalRequests.RemapTargetPlatforms(Remap);
}

ECookMode::Type FWorkerRequestsRemote::GetDirectorCookMode()
{
    return CookWorkerClient.GetDirectorCookMode();
}

bool FWorkerRequestsRemote::DecideNextCookAction(FTickStackData& StackData, UCookOnTheFlyServer::ECookAction& CookAction)
{
    if (WaitAssignQueue.Num() > static_cast<int32>(DesiredWaitAssignQueueLength))
    {
        CookAction = UCookOnTheFlyServer::ECookAction::Assign;
        return true;
    }
    return false;
}

bool FWorkerRequestsRemote::AddToWaitAssign(FPackageData& PackageData, EPackageState TargetState)
{
    EPackageState CurrentState = PackageData.GetState();
    if (CurrentState != EPackageState::Request)
    {
        if (CurrentState == EPackageState::Idle)
        {
            if (TargetState != EPackageState::LoadReady || PackageData.HasAllCookedPlatforms(CookWorkerClient.GetTargetPlatforms(), true))
            {
                UE_LOG(LogCook, Error, TEXT("AddToWaitAssign With Cooked-------- Package %s %d=>%d"), *PackageData.GetPackageName().ToString(), (int32)CurrentState, (int32)TargetState);
                return true;
            }
        }
        else
        {
            UE_LOG(LogCook, Error, TEXT("AddToWaitAssign With Cooking++++++++ Package %s %d=>%d"), *PackageData.GetPackageName().ToString(), (int32)CurrentState, (int32)TargetState);
            return true;
        }
    }
    PackageData.SendToState(EPackageState::WaitAssign, ESendFlags::QueueAdd);
    WaitAssignQueue.Add(&PackageData);
    if (TargetState == EPackageState::LoadReady)
    {
        LoadedPackages.Add(&PackageData);
    }
    return true;
}

bool FWorkerRequestsRemote::AssignRequests()
{
    if (WaitAssignQueue.Num() == 0)
    {
        return false;
    }
    TArray<FPackageData*> Requests;
    while (WaitAssignQueue.Num() > 0)
    {
        Requests.Add(WaitAssignQueue.PopFrontValue());
    }
    CookWorkerClient.ReportDiscoveredPackage(Requests, LoadedPackages);
    LoadedPackages.Reset();
    return true;
}
}  // namespace Cook
}  // namespace UE