#pragma once

#include "Passes/SceneViewportGridPass.h"
#include "Passes/SceneViewportSelectionOutlinePass.h"
#include "Passes/SceneViewportEditorOverlayPass.h"
#include "SceneViewportEditorOverlayData.h"
#include "ViewportHostRenderFlowUtils.h"

#include <XCEngine/Core/Math/Color.h>
#include <XCEngine/Rendering/RenderPass.h>

#include <functional>
#include <memory>
#include <utility>
#include <vector>

namespace XCEngine {
namespace Editor {

struct SceneViewportRenderPlan {
    Rendering::RenderPassSequence postScenePasses = {};
    Rendering::RenderPassSequence overlayPasses = {};
    bool hasClearColorOverride = true;
    Math::Color clearColorOverride = Math::Color(0.27f, 0.27f, 0.27f, 1.0f);

    bool HasPostScenePasses() const {
        return postScenePasses.GetPassCount() > 0;
    }

    bool HasOverlayPasses() const {
        return overlayPasses.GetPassCount() > 0;
    }
};

using SceneViewportOverlayPassFactory =
    std::function<std::unique_ptr<Rendering::RenderPass>(const SceneViewportOverlayFrameData&)>;
using SceneViewportGridPassFactory =
    std::function<std::unique_ptr<Rendering::RenderPass>(const Rendering::Passes::InfiniteGridPassData&)>;
using SceneViewportSelectionOutlinePassFactory = std::function<std::unique_ptr<Rendering::RenderPass>(
    RHI::RHIResourceView*,
    const std::vector<uint64_t>&,
    const Rendering::Passes::ObjectIdOutlineStyle&)>;

struct SceneViewportRenderPlanBuildResult {
    SceneViewportRenderPlan plan = {};
    const char* warningStatusText = nullptr;
};

inline SceneViewportRenderPlanBuildResult BuildSceneViewportRenderPlan(
    const ViewportRenderTargets& targets,
    const SceneViewportOverlayData& overlay,
    const std::vector<uint64_t>& selectedObjectIds,
    const SceneViewportOverlayFrameData& editorOverlayFrameData,
    const SceneViewportOverlayFrameData& transientOverlayFrameData,
    const SceneViewportGridPassFactory& gridPassFactory,
    const SceneViewportSelectionOutlinePassFactory& selectionOutlinePassFactory,
    const SceneViewportOverlayPassFactory& overlayPassFactory,
    bool debugSelectionMask = false) {
    SceneViewportRenderPlanBuildResult result = {};
    if (!overlay.valid) {
        return result;
    }

    const Rendering::Passes::InfiniteGridPassData gridPassData = BuildSceneViewportGridPassData(overlay);
    if (gridPassData.valid && gridPassFactory != nullptr) {
        std::unique_ptr<Rendering::RenderPass> gridPass = gridPassFactory(gridPassData);
        if (gridPass != nullptr) {
            result.plan.postScenePasses.AddPass(std::move(gridPass));
        }
    }

    if (!selectedObjectIds.empty()) {
        if (targets.objectIdShaderView != nullptr &&
            selectionOutlinePassFactory != nullptr) {
            std::unique_ptr<Rendering::RenderPass> selectionOutlinePass =
                selectionOutlinePassFactory(
                    targets.objectIdShaderView,
                    selectedObjectIds,
                    BuildSceneViewportSelectionOutlineStyle(debugSelectionMask));
            if (selectionOutlinePass != nullptr) {
                result.plan.postScenePasses.AddPass(std::move(selectionOutlinePass));
            }
        } else if (!debugSelectionMask) {
            result.warningStatusText = "Scene object id shader view is unavailable";
        }
    }

    SceneViewportOverlayFrameData renderOverlayFrameData = editorOverlayFrameData;
    AppendSceneViewportOverlayFrameData(renderOverlayFrameData, transientOverlayFrameData);
    if (renderOverlayFrameData.HasOverlayPrimitives() &&
        overlayPassFactory != nullptr) {
        std::unique_ptr<Rendering::RenderPass> overlayPass = overlayPassFactory(renderOverlayFrameData);
        if (overlayPass != nullptr) {
            result.plan.overlayPasses.AddPass(std::move(overlayPass));
        }
    }

    return result;
}

inline void ApplySceneViewportRenderPlan(
    const ViewportRenderTargets& targets,
    SceneViewportRenderPlan& plan,
    Rendering::CameraRenderRequest& request) {
    ApplySceneViewportRenderRequestSetup(
        targets,
        &plan.postScenePasses,
        request);

    if (plan.HasOverlayPasses()) {
        request.overlayPasses = &plan.overlayPasses;
    }

    request.hasClearColorOverride = plan.hasClearColorOverride;
    request.clearColorOverride = plan.clearColorOverride;
}

} // namespace Editor
} // namespace XCEngine