#include "Rendering/SceneRenderRequestPlanner.h"

#include "Rendering/SceneRenderRequestUtils.h"

#include "Scene/Scene.h"

#include <algorithm>

namespace XCEngine {
namespace Rendering {

std::vector<Components::CameraComponent*> SceneRenderRequestPlanner::CollectCameras(
    const Components::Scene& scene,
    Components::CameraComponent* overrideCamera) const {
    std::vector<Components::CameraComponent*> cameras;

    if (SceneRenderRequestUtils::IsUsableCamera(overrideCamera)) {
        cameras.push_back(overrideCamera);
        return cameras;
    }

    cameras = scene.FindObjectsOfType<Components::CameraComponent>();
    cameras.erase(
        std::remove_if(
            cameras.begin(),
            cameras.end(),
            [](const Components::CameraComponent* camera) {
                return !SceneRenderRequestUtils::IsUsableCamera(camera);
            }),
        cameras.end());

    SceneRenderRequestUtils::SortSceneCamerasForRendering(cameras);
    return cameras;
}

std::vector<CameraRenderRequest> SceneRenderRequestPlanner::BuildRequests(
    const Components::Scene& scene,
    Components::CameraComponent* overrideCamera,
    const RenderContext& context,
    const RenderSurface& surface) const {
    std::vector<CameraRenderRequest> requests;
    const std::vector<Components::CameraComponent*> cameras =
        CollectCameras(scene, overrideCamera);

    size_t renderedBaseCameraCount = 0;
    for (Components::CameraComponent* camera : cameras) {
        CameraRenderRequest request;
        if (!SceneRenderRequestUtils::BuildCameraRenderRequest(
                scene,
                *camera,
                context,
                surface,
                renderedBaseCameraCount,
                requests.size(),
                request)) {
            continue;
        }

        requests.push_back(request);
        if (camera->GetStackType() == Components::CameraStackType::Base) {
            ++renderedBaseCameraCount;
        }
    }

    return requests;
}

} // namespace Rendering
} // namespace XCEngine