#include "Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.h"

#include "Debug/Logger.h"
#include "Rendering/GraphicsSettingsState.h"
#include "Rendering/Internal/RenderPipelineFactory.h"

#include <utility>

namespace XCEngine {
namespace Rendering {
namespace Pipelines {

namespace {

void ApplyManagedDirectionalShadowPlanningPolicyOrDefault(
    const std::string& assetKey,
    CameraRenderRequest& request,
    size_t renderedBaseCameraCount,
    size_t renderedRequestCount,
    const DirectionalShadowPlanningSettings& directionalShadowSettings) {
    if (assetKey.empty()) {
        ApplyDefaultRenderPipelineAssetCameraRenderRequestPolicy(
            request,
            renderedBaseCameraCount,
            renderedRequestCount,
            directionalShadowSettings);
        return;
    }

    if (!Rendering::Internal::ApplyDirectionalShadowPlanningPolicyByKey(
            assetKey,
            request,
            renderedBaseCameraCount,
            renderedRequestCount,
            directionalShadowSettings)) {
        Debug::Logger::Get().Error(
            Debug::LogCategory::Rendering,
            Containers::String(
                "ManagedScriptableRenderPipelineAsset failed to resolve directional shadow planning policy asset key: ") +
                assetKey.c_str());
    }
}

void ApplyManagedCameraFramePlanPolicyOrDefault(
    const std::string& assetKey,
    CameraFramePlan& plan,
    const FinalColorSettings& defaultFinalColorSettings) {
    if (assetKey.empty()) {
        ApplyDefaultRenderPipelineAssetCameraFramePlanPolicy(
            plan,
            defaultFinalColorSettings);
        return;
    }

    if (!Rendering::Internal::ApplyCameraFramePlanPolicyByKey(
            assetKey,
            plan,
            defaultFinalColorSettings)) {
        Debug::Logger::Get().Error(
            Debug::LogCategory::Rendering,
            Containers::String(
                "ManagedScriptableRenderPipelineAsset failed to resolve camera frame plan policy asset key: ") +
                assetKey.c_str());
        ApplyDefaultRenderPipelineAssetCameraFramePlanPolicy(
            plan,
            defaultFinalColorSettings);
    }
}

} // namespace

ManagedScriptableRenderPipelineAsset::ManagedScriptableRenderPipelineAsset(
    ManagedRenderPipelineAssetDescriptor descriptor)
    : m_descriptor(std::move(descriptor)) {
}

std::shared_ptr<const ManagedRenderPipelineAssetRuntime>
ManagedScriptableRenderPipelineAsset::ResolveManagedAssetRuntime() const {
    const GraphicsSettingsState& graphicsSettings =
        GetGraphicsSettingsState();
    const size_t bridgeGeneration =
        graphicsSettings.GetManagedRenderPipelineBridgeGeneration();
    if (m_managedAssetRuntime != nullptr &&
        m_managedAssetRuntimeBridgeGeneration == bridgeGeneration) {
        return m_managedAssetRuntime;
    }

    m_managedAssetRuntime.reset();
    m_managedAssetRuntimeBridgeGeneration = bridgeGeneration;

    const std::shared_ptr<const ManagedRenderPipelineBridge> bridge =
        graphicsSettings.GetManagedRenderPipelineBridge();
    if (bridge == nullptr) {
        return nullptr;
    }

    m_managedAssetRuntime = bridge->CreateAssetRuntime(m_descriptor);
    return m_managedAssetRuntime;
}

std::shared_ptr<const RenderPipelineAsset>
ManagedScriptableRenderPipelineAsset::ResolvePipelineRendererAsset() const {
    if (const std::shared_ptr<const ManagedRenderPipelineAssetRuntime> runtime =
            ResolveManagedAssetRuntime();
        runtime != nullptr) {
        return runtime->GetPipelineRendererAsset();
    }

    return nullptr;
}

ScriptableRenderPipelineHostAsset
ManagedScriptableRenderPipelineAsset::CreateExecutionHostAsset() const {
    const std::shared_ptr<const ManagedRenderPipelineAssetRuntime> runtime =
        ResolveManagedAssetRuntime();
    if (const std::shared_ptr<const RenderPipelineAsset> pipelineRendererAsset =
            ResolvePipelineRendererAsset();
        pipelineRendererAsset != nullptr) {
        return ScriptableRenderPipelineHostAsset(
            pipelineRendererAsset,
            runtime);
    }

    return ScriptableRenderPipelineHostAsset(
        nullptr,
        runtime);
}

std::unique_ptr<RenderPipeline> ManagedScriptableRenderPipelineAsset::CreatePipeline() const {
    const ScriptableRenderPipelineHostAsset executionHostAsset =
        CreateExecutionHostAsset();
    std::unique_ptr<RenderPipeline> pipeline =
        executionHostAsset.CreatePipeline();
    auto* host = dynamic_cast<ScriptableRenderPipelineHost*>(pipeline.get());
    if (host == nullptr) {
        return pipeline;
    }

    if (const std::shared_ptr<const ManagedRenderPipelineAssetRuntime> runtime =
            ResolveManagedAssetRuntime();
        runtime != nullptr) {
        host->SetStageRecorder(runtime->CreateStageRecorder());
    }

    return pipeline;
}

void ManagedScriptableRenderPipelineAsset::ConfigureCameraRenderRequest(
    CameraRenderRequest& request,
    size_t renderedBaseCameraCount,
    size_t renderedRequestCount,
    const DirectionalShadowPlanningSettings& directionalShadowSettings) const {
    if (const std::shared_ptr<const ManagedRenderPipelineAssetRuntime> runtime =
            ResolveManagedAssetRuntime();
        runtime != nullptr) {
        ApplyManagedDirectionalShadowPlanningPolicyOrDefault(
            runtime->GetDirectionalShadowPlanningPolicyAssetKey(),
            request,
            renderedBaseCameraCount,
            renderedRequestCount,
            directionalShadowSettings);
        runtime->ConfigureCameraRenderRequest(
            request,
            renderedBaseCameraCount,
            renderedRequestCount,
            directionalShadowSettings);
        return;
    }

    RenderPipelineAsset::ConfigureCameraRenderRequest(
        request,
        renderedBaseCameraCount,
        renderedRequestCount,
        directionalShadowSettings);
}

void ManagedScriptableRenderPipelineAsset::ConfigureCameraFramePlan(
    CameraFramePlan& plan) const {
    if (const std::shared_ptr<const ManagedRenderPipelineAssetRuntime> runtime =
            ResolveManagedAssetRuntime();
        runtime != nullptr) {
        ApplyManagedCameraFramePlanPolicyOrDefault(
            runtime->GetCameraFramePlanPolicyAssetKey(
                plan.request.rendererIndex),
            plan,
            GetDefaultFinalColorSettings());
        runtime->ConfigureCameraFramePlan(plan);
        return;
    }

    RenderPipelineAsset::ConfigureCameraFramePlan(plan);
}

FinalColorSettings ManagedScriptableRenderPipelineAsset::GetDefaultFinalColorSettings() const {
    if (const std::shared_ptr<const ManagedRenderPipelineAssetRuntime> runtime =
            ResolveManagedAssetRuntime();
        runtime != nullptr) {
        FinalColorSettings settings = {};
        if (runtime->TryGetDefaultFinalColorSettings(settings)) {
            return settings;
        }
    }

    const ScriptableRenderPipelineHostAsset executionHostAsset =
        CreateExecutionHostAsset();
    return executionHostAsset.GetDefaultFinalColorSettings();
}

void SetManagedRenderPipelineBridge(
    std::shared_ptr<const ManagedRenderPipelineBridge> bridge) {
    GetGraphicsSettingsState().SetManagedRenderPipelineBridge(
        std::move(bridge));
}

void ClearManagedRenderPipelineBridge() {
    GetGraphicsSettingsState().ClearManagedRenderPipelineBridge();
}

std::shared_ptr<const ManagedRenderPipelineBridge>
GetManagedRenderPipelineBridge() {
    return GetGraphicsSettingsState().GetManagedRenderPipelineBridge();
}

size_t GetManagedRenderPipelineEnvironmentGeneration() {
    return GetGraphicsSettingsState().GetEnvironmentGeneration();
}

void SetConfiguredManagedRenderPipelineAssetDescriptor(
    const ManagedRenderPipelineAssetDescriptor& descriptor) {
    GetGraphicsSettingsState().SetConfiguredRenderPipelineAssetDescriptor(
        descriptor);
}

void ClearConfiguredManagedRenderPipelineAssetDescriptor() {
    GetGraphicsSettingsState().ClearConfiguredRenderPipelineAssetDescriptor();
}

ManagedRenderPipelineAssetDescriptor
GetConfiguredManagedRenderPipelineAssetDescriptor() {
    return GetGraphicsSettingsState()
        .GetConfiguredRenderPipelineAssetDescriptor();
}

std::shared_ptr<const RenderPipelineAsset>
CreateConfiguredManagedRenderPipelineAsset() {
    const ManagedRenderPipelineAssetDescriptor descriptor =
        GetGraphicsSettingsState().GetConfiguredRenderPipelineAssetDescriptor();
    if (descriptor.IsValid()) {
        return std::make_shared<ManagedScriptableRenderPipelineAsset>(descriptor);
    }

    return nullptr;
}

} // namespace Pipelines
} // namespace Rendering
} // namespace XCEngine