#include "Rendering/SceneRenderer.h"

#include "Components/CameraComponent.h"

#include <algorithm>

namespace XCEngine {
namespace Rendering {

namespace {

bool CompareCameraRenderRequest(const CameraRenderRequest& lhs, const CameraRenderRequest& rhs) {
    if (lhs.cameraDepth != rhs.cameraDepth) {
        return lhs.cameraDepth < rhs.cameraDepth;
    }

    return lhs.camera < rhs.camera;
}

} // namespace

SceneRenderer::SceneRenderer() = default;

SceneRenderer::SceneRenderer(std::unique_ptr<RenderPipeline> pipeline)
    : m_cameraRenderer(std::move(pipeline)) {
}

void SceneRenderer::SetPipeline(std::unique_ptr<RenderPipeline> pipeline) {
    m_cameraRenderer.SetPipeline(std::move(pipeline));
}

std::vector<CameraRenderRequest> SceneRenderer::BuildRenderRequests(
    const Components::Scene& scene,
    Components::CameraComponent* overrideCamera,
    const RenderContext& context,
    const RenderSurface& surface) const {
    std::vector<CameraRenderRequest> requests;

    Components::CameraComponent* camera = m_sceneExtractor.SelectCamera(scene, overrideCamera);
    if (camera == nullptr) {
        return requests;
    }

    CameraRenderRequest request;
    request.scene = &scene;
    request.camera = camera;
    request.context = context;
    request.surface = surface;
    request.cameraDepth = camera->GetDepth();
    requests.push_back(request);
    return requests;
}

bool SceneRenderer::Render(const CameraRenderRequest& request) {
    return m_cameraRenderer.Render(request);
}

bool SceneRenderer::Render(const std::vector<CameraRenderRequest>& requests) {
    if (requests.empty()) {
        return false;
    }

    for (const CameraRenderRequest& request : requests) {
        if (!request.IsValid()) {
            return false;
        }
    }

    std::vector<CameraRenderRequest> sortedRequests = requests;
    std::stable_sort(
        sortedRequests.begin(),
        sortedRequests.end(),
        CompareCameraRenderRequest);

    bool rendered = false;
    for (const CameraRenderRequest& request : sortedRequests) {
        if (!m_cameraRenderer.Render(request)) {
            return false;
        }
        rendered = true;
    }

    return rendered;
}

bool SceneRenderer::Render(
    const Components::Scene& scene,
    Components::CameraComponent* overrideCamera,
    const RenderContext& context,
    const RenderSurface& surface) {
    return Render(BuildRenderRequests(scene, overrideCamera, context, surface));
}

} // namespace Rendering
} // namespace XCEngine