#include "Scene/SceneViewportSession.h"

#include "Scene/EditorSceneRuntime.h"

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

namespace {

std::uint64_t CombineSceneViewportRequestRevisions(
    std::uint64_t sceneContentRevision,
    std::uint64_t sceneViewCameraRevision) {
    constexpr std::uint64_t kRevisionMixConstant = 0x9e3779b97f4a7c15ull;
    return sceneContentRevision ^
        (sceneViewCameraRevision + kRevisionMixConstant +
         (sceneContentRevision << 6u) +
         (sceneContentRevision >> 2u));
}

} // namespace

SceneViewportSession::SceneViewportSession() {
    Reset();
}

void SceneViewportSession::Reset() {
    m_cameraController.Reset();
    m_toolMode = SceneToolMode::Translate;
    m_toolSpaceMode = SceneToolSpaceMode::World;
    m_toolPivotMode = SceneToolPivotMode::Pivot;
    m_cameraRevision = 0u;
}

EditorSceneCameraSnapshot SceneViewportSession::BuildCameraSnapshot() const {
    EditorSceneCameraSnapshot snapshot = {};
    snapshot.valid = true;
    snapshot.position = m_cameraController.GetPosition();
    snapshot.forward = m_cameraController.GetForward();
    snapshot.right = m_cameraController.GetRight();
    snapshot.up = m_cameraController.GetUp();
    snapshot.verticalFovDegrees = 60.0f;
    snapshot.nearClipPlane = 0.03f;
    snapshot.farClipPlane = 2000.0f;
    snapshot.orbitDistance = m_cameraController.GetDistance();
    return snapshot;
}

SceneViewportRenderRequest SceneViewportSession::BuildRenderRequest(
    const EditorSceneRuntime& sceneRuntime) const {
    SceneViewportRenderRequest request = {};
    request.camera = BuildCameraSnapshot();
    request.requestRevision =
        BuildRequestRevision(sceneRuntime.GetSceneContentRevision());
    if (const std::optional<EditorSceneObjectId> selectedId =
            sceneRuntime.GetSelectedObjectId();
        selectedId.has_value()) {
        request.selectedObjectIds.push_back(selectedId.value());
        request.selectedHelpers =
            sceneRuntime.BuildSelectedViewportHelperSnapshots();
    }
    return request;
}

void SceneViewportSession::ApplyCameraInput(
    const SceneViewportCameraInputState& input) {
    m_cameraController.ApplyInput(input);
    IncrementCameraRevision();
}

bool SceneViewportSession::FocusSelection(
    const EditorSceneRuntime& sceneRuntime) {
    SceneTransformSnapshot snapshot = {};
    if (!sceneRuntime.CaptureSelectedTransformSnapshot(snapshot)) {
        return false;
    }

    m_cameraController.Focus(snapshot.position);
    IncrementCameraRevision();
    return true;
}

SceneToolMode SceneViewportSession::GetToolMode() const {
    return m_toolMode;
}

SceneToolSpaceMode SceneViewportSession::GetToolSpaceMode() const {
    return m_toolSpaceMode;
}

SceneToolPivotMode SceneViewportSession::GetToolPivotMode() const {
    return m_toolPivotMode;
}

void SceneViewportSession::SetToolMode(SceneToolMode mode) {
    m_toolMode = mode;
}

void SceneViewportSession::SetToolSpaceMode(SceneToolSpaceMode mode) {
    m_toolSpaceMode = mode;
}

void SceneViewportSession::SetToolPivotMode(SceneToolPivotMode mode) {
    m_toolPivotMode = mode;
}

void SceneViewportSession::IncrementCameraRevision() {
    ++m_cameraRevision;
}

std::uint64_t SceneViewportSession::BuildRequestRevision(
    std::uint64_t sceneContentRevision) const {
    return CombineSceneViewportRequestRevisions(
        sceneContentRevision,
        m_cameraRevision);
}

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