#include "Engine/EngineEditorServices.h"

#include "Engine/EditorEngineLifecycle.h"
#include "Engine/EditorSceneBackendFactory.h"
#include "Engine/EditorShaderProvider.h"
#include "Engine/EngineGameViewportBridge.h"
#include "Engine/EngineSceneViewportBridge.h"
#include "Engine/GameViewportEngineBridge.h"
#include "Engine/SceneViewportEngineBridge.h"
#include "Scene/EngineEditorSceneBackend.h"

#include <XCEngine/Core/Asset/ResourceManager.h>
#include <XCEngine/Scene/SceneManager.h>

namespace XCEngine::UI::Editor::App {

namespace {

class EngineEditorServices final
    : public EditorSceneBackendFactory
    , public SceneViewportEngineBridge
    , public GameViewportEngineBridge
    , public EditorShaderProvider
    , public EditorEngineLifecycle {
public:
    void UpdateAsyncLoads() override {
        ::XCEngine::Resources::ResourceManager::Get().UpdateAsyncLoads();
    }

    void Shutdown() override {
        m_sceneViewportBridge.Shutdown();
        ::XCEngine::Resources::ResourceManager::Get().Shutdown();
    }

    std::unique_ptr<EditorSceneBackend> CreateSceneBackend() override {
        return CreateEngineEditorSceneBackend(
            ::XCEngine::Components::SceneManager::Get(),
            ::XCEngine::Resources::ResourceManager::Get());
    }

    ::XCEngine::Resources::ResourceHandle<::XCEngine::Resources::Shader>
    LoadShader(const ::XCEngine::Containers::String& path) override {
        return ::XCEngine::Resources::ResourceManager::Get()
            .Load<::XCEngine::Resources::Shader>(path);
    }

    SceneViewportFramePlanBuildStatus BuildSceneViewportFramePlan(
        const SceneViewportRenderRequest& request,
        const ::XCEngine::Rendering::RenderContext& renderContext,
        const ::XCEngine::Rendering::RenderSurface& surface,
        ::XCEngine::Rendering::CameraFramePlan& outFramePlan) override {
        return m_sceneViewportBridge.BuildFramePlan(
            request,
            renderContext,
            surface,
            outFramePlan);
    }

    bool RenderSceneViewportFramePlan(
        const ::XCEngine::Rendering::CameraFramePlan& framePlan) override {
        return m_sceneViewportBridge.RenderFramePlan(framePlan);
    }

    GameViewportFramePlanBuildStatus BuildGameViewportFramePlans(
        const ::XCEngine::Rendering::RenderContext& renderContext,
        const ::XCEngine::Rendering::RenderSurface& surface,
        std::vector<::XCEngine::Rendering::CameraStackFramePlan>& outFramePlans)
        override {
        return m_gameViewportBridge.BuildFramePlans(
            renderContext,
            surface,
            outFramePlans);
    }

    bool RenderGameViewportFramePlans(
        const std::vector<::XCEngine::Rendering::CameraStackFramePlan>& framePlans)
        override {
        return m_gameViewportBridge.RenderFramePlans(framePlans);
    }

    bool TryResolveActiveSceneRenderObjectId(
        ::XCEngine::Rendering::RenderObjectId renderObjectId,
        EditorSceneObjectId& outRuntimeObjectId) const override {
        return m_sceneViewportBridge.TryResolveActiveSceneRenderObjectId(
            renderObjectId,
            outRuntimeObjectId);
    }

private:
    EngineGameViewportBridge m_gameViewportBridge = {};
    EngineSceneViewportBridge m_sceneViewportBridge = {};
};

} // namespace

class EngineEditorComposition::Impl final {
public:
    EditorSceneBackendFactory& GetSceneBackendFactory() {
        return m_services;
    }

    SceneViewportEngineBridge& GetSceneViewportBridge() {
        return m_services;
    }

    GameViewportEngineBridge& GetGameViewportBridge() {
        return m_services;
    }

    EditorShaderProvider& GetShaderProvider() {
        return m_services;
    }

    EditorEngineLifecycle& GetLifecycle() {
        return m_services;
    }

private:
    EngineEditorServices m_services = {};
};

EngineEditorComposition::EngineEditorComposition()
    : m_impl(std::make_unique<Impl>()) {}

EngineEditorComposition::~EngineEditorComposition() = default;

EditorSceneBackendFactory& EngineEditorComposition::GetSceneBackendFactory() {
    return m_impl->GetSceneBackendFactory();
}

SceneViewportEngineBridge& EngineEditorComposition::GetSceneViewportBridge() {
    return m_impl->GetSceneViewportBridge();
}

GameViewportEngineBridge& EngineEditorComposition::GetGameViewportBridge() {
    return m_impl->GetGameViewportBridge();
}

EditorShaderProvider& EngineEditorComposition::GetShaderProvider() {
    return m_impl->GetShaderProvider();
}

EditorEngineLifecycle& EngineEditorComposition::GetLifecycle() {
    return m_impl->GetLifecycle();
}

std::unique_ptr<EngineEditorComposition> CreateEngineEditorComposition() {
    return std::make_unique<EngineEditorComposition>();
}

} // namespace XCEngine::UI::Editor::App