#include "MetaCoreRender/MetaCoreSceneRenderSync.h"

#include "MetaCoreRender/MetaCoreRenderTypes.h"
#include "MetaCoreScene/MetaCoreScene.h"
#include "MetaCoreScene/MetaCoreTransformUtils.h"

#include <glm/ext/matrix_clip_space.hpp>
#include <glm/ext/matrix_transform.hpp>
#include <glm/geometric.hpp>
#include <glm/vec4.hpp>

#include <algorithm>
#include <cmath>

namespace MetaCore {

namespace {

[[nodiscard]] bool MetaCoreIsUsableDirection(const glm::vec3& value) {
    return std::isfinite(value.x) &&
           std::isfinite(value.y) &&
           std::isfinite(value.z) &&
           glm::length(value) > 0.0001F;
}

[[nodiscard]] glm::vec3 MetaCoreExtractTranslation(const glm::mat4& matrix) {
    return glm::vec3(matrix[3]);
}

[[nodiscard]] std::string MetaCoreNormalizeSyncPath(std::string path) {
    std::replace(path.begin(), path.end(), '\\', '/');
    return path;
}

[[nodiscard]] float MetaCoreSafeAspectRatio(float width, float height) {
    return height > 0.0001F ? std::max(0.0001F, width / height) : 1.0F;
}

[[nodiscard]] glm::mat4 MetaCoreBuildProjectionMatrix(
    const MetaCoreSceneView& sceneView,
    float aspectRatio
) {
    const float nearClip = std::max(0.0001F, sceneView.NearClip);
    const float farClip = std::max(nearClip + 0.0001F, sceneView.FarClip);
    if (sceneView.ProjectionMode == MetaCoreCameraProjectionMode::Orthographic) {
        const float halfHeight = std::max(0.0001F, sceneView.OrthographicSize);
        const float halfWidth = halfHeight * aspectRatio;
        return glm::ortho(-halfWidth, halfWidth, -halfHeight, halfHeight, nearClip, farClip);
    }

    const float fovDegrees = std::clamp(sceneView.VerticalFieldOfViewDegrees, 1.0F, 179.0F);
    return glm::perspective(glm::radians(fovDegrees), aspectRatio, nearClip, farClip);
}

[[nodiscard]] glm::vec3 MetaCoreSafeForward(const MetaCoreSceneView& sceneView) {
    glm::vec3 forward = sceneView.CameraTarget - sceneView.CameraPosition;
    if (!MetaCoreIsUsableDirection(forward)) {
        forward = glm::vec3(0.0F, 0.0F, -1.0F);
    }
    return glm::normalize(forward);
}

[[nodiscard]] glm::vec3 MetaCoreSafeUp(const MetaCoreSceneView& sceneView, const glm::vec3& forward) {
    glm::vec3 up = sceneView.CameraUp;
    if (!MetaCoreIsUsableDirection(up) || glm::length(glm::cross(forward, up)) <= 0.0001F) {
        up = glm::vec3(0.0F, 1.0F, 0.0F);
    }
    if (glm::length(glm::cross(forward, up)) <= 0.0001F) {
        up = glm::vec3(0.0F, 0.0F, 1.0F);
    }
    return glm::normalize(up);
}

}  // namespace

MetaCoreSceneRenderSyncSnapshot MetaCoreSceneRenderSync::BuildSnapshot(const MetaCoreScene& scene) const {
    MetaCoreSceneRenderSyncSnapshot snapshot;
    snapshot.FrameId = ++FrameId_;
    snapshot.SceneRevision = scene.GetRevision();
    snapshot.Environment = scene.GetEnvironmentSettings();

    // 预处理：构建子树模型网格节点计数表，支撑在没有 Tag 时的 Fallback 回溯
    std::unordered_map<MetaCoreId, std::unordered_map<std::string, int>> subtreeModelCounts;
    for (MetaCoreId objectId : scene.BuildHierarchyPreorder()) {
        const MetaCoreGameObject gameObject = scene.FindGameObject(objectId);
        if (gameObject && gameObject.HasComponent<MetaCoreMeshRendererComponent>()) {
            const auto& mesh = gameObject.GetComponent<MetaCoreMeshRendererComponent>();
            if (mesh.ModelNodeIndex >= 0 && !mesh.SourceModelPath.empty()) {
                std::string normPath = MetaCoreNormalizeSyncPath(mesh.SourceModelPath);
                MetaCoreId currentId = objectId;
                while (currentId != 0) {
                    auto currentObj = scene.FindGameObject(currentId);
                    if (!currentObj) break;
                    subtreeModelCounts[currentId][normPath]++;
                    currentId = currentObj.GetParentId();
                }
            }
        }
    }

    for (MetaCoreId objectId : scene.BuildHierarchyPreorder()) {
        const MetaCoreGameObject gameObject = scene.FindGameObject(objectId);
        if (!gameObject) {
            continue;
        }

        glm::mat4 localMatrix{1.0F};
        if (gameObject.HasComponent<MetaCoreTransformComponent>()) {
            localMatrix = MetaCoreBuildTransformMatrix(gameObject.GetComponent<MetaCoreTransformComponent>());
        }

        glm::mat4 worldMatrix = localMatrix;
        const MetaCoreId parentId = gameObject.GetParentId();
        if (parentId != 0) {
            const auto parentWorldIt = snapshot.WorldMatrices.find(parentId);
            if (parentWorldIt != snapshot.WorldMatrices.end()) {
                worldMatrix = parentWorldIt->second * localMatrix;
            }
        }
        snapshot.WorldMatrices[objectId] = worldMatrix;
        snapshot.LocalMatrices[objectId] = localMatrix;

        if (gameObject.HasComponent<MetaCoreMeshRendererComponent>()) {
            const auto& meshRenderer = gameObject.GetComponent<MetaCoreMeshRendererComponent>();
            
            // 黄金算法：溯源确定唯一的模型根加载主体
            MetaCoreGameObject hostRoot = gameObject;
            if (meshRenderer.ModelNodeIndex >= 0) {
                const std::string& currentModelPath = meshRenderer.SourceModelPath;
                std::string normCurrentPath = MetaCoreNormalizeSyncPath(currentModelPath);
                MetaCoreGameObject current = gameObject;
                MetaCoreGameObject foundRoot = {};

                // 1. 优先通过运行时 MetaCoreModelRootTag 快速寻找顶级根
                while (current) {
                    if (current.HasComponent<MetaCoreModelRootTag>()) {
                        auto& tag = current.GetComponent<MetaCoreModelRootTag>();
                        if (MetaCoreNormalizeSyncPath(tag.SourceModelPath) == normCurrentPath) {
                            foundRoot = current;
                            break;
                        }
                    }
                    if (current.GetParentId() == 0) break;
                    current = scene.FindGameObject(current.GetParentId());
                }

                if (foundRoot) {
                    hostRoot = foundRoot;
                } else {
                    // 2. Fallback：若无明确 Tag，使用转折点判定算法
                    current = gameObject;
                    MetaCoreGameObject bestCandidate = gameObject;
                    int maxCount = subtreeModelCounts[gameObject.GetId()][normCurrentPath];

                    while (current) {
                        int count = subtreeModelCounts[current.GetId()][normCurrentPath];
                        if (count > maxCount) {
                            maxCount = count;
                            bestCandidate = current;
                        }
                        if (current.GetParentId() == 0) break;
                        current = scene.FindGameObject(current.GetParentId());
                    }
                    hostRoot = bestCandidate;
                }
            }

            snapshot.Renderables.push_back(MetaCoreRenderSyncRenderable{
                objectId,
                parentId,
                gameObject.GetName(),
                localMatrix,
                worldMatrix,
                meshRenderer.Visible,
                meshRenderer.MeshSource,
                meshRenderer.BuiltinMesh,
                meshRenderer.MeshAssetGuid,
                meshRenderer.SourceModelAssetGuid,
                meshRenderer.SourceModelPath,
                meshRenderer.ModelNodeIndex,
                hostRoot.GetId(),
                hostRoot.GetName(),
                hostRoot.HasComponent<MetaCoreModelRootTag>(),
                meshRenderer.MaterialAssetGuids,
                meshRenderer.BaseColor,
                meshRenderer.Metallic,
                meshRenderer.Roughness,
                meshRenderer.EmissiveColor,
                meshRenderer.AlphaMode,
                meshRenderer.AlphaCutoff,
                meshRenderer.DoubleSided,
                meshRenderer.BaseColorTexturePath,
                meshRenderer.MetallicRoughnessTexturePath,
                meshRenderer.NormalTexturePath,
                meshRenderer.EmissiveTexturePath,
                meshRenderer.AoTexturePath,
                meshRenderer.RenderingLayerMask,
                meshRenderer.MaxDrawDistance,
                meshRenderer.StaticForCulling,
                meshRenderer.CastShadows,
                meshRenderer.ReceiveShadows,
                {},
                meshRenderer.BuiltinMesh == MetaCoreBuiltinMeshType::Cube ? 12U :
                    (meshRenderer.BuiltinMesh == MetaCoreBuiltinMeshType::Plane ? 2U : 0U),
                0U
            });
            auto& syncRenderable = snapshot.Renderables.back();
            const glm::vec3 position = glm::vec3(worldMatrix[3]);
            const glm::vec3 extents{
                std::max(0.001F, glm::length(glm::vec3(worldMatrix[0])) * 0.5F),
                std::max(0.001F, glm::length(glm::vec3(worldMatrix[1])) * 0.5F),
                std::max(0.001F, glm::length(glm::vec3(worldMatrix[2])) * 0.5F)};
            syncRenderable.WorldBounds = {position - extents, position + extents};
        }

        if (gameObject.HasComponent<MetaCoreCameraComponent>()) {
            const auto& camera = gameObject.GetComponent<MetaCoreCameraComponent>();
            MetaCoreRenderSyncCamera syncCamera;
            syncCamera.ObjectId = objectId;
            syncCamera.IsPrimary = camera.IsPrimary;
            syncCamera.FieldOfViewDegrees = camera.FieldOfViewDegrees;
            syncCamera.NearClip = camera.NearClip;
            syncCamera.FarClip = camera.FarClip;
            syncCamera.WorldMatrix = worldMatrix;
            syncCamera.Enabled = camera.Enabled;
            syncCamera.ProjectionMode = camera.ProjectionMode;
            syncCamera.OrthographicSize = camera.OrthographicSize;
            syncCamera.Depth = camera.Depth;
            syncCamera.CullingMask = camera.CullingMask;
            syncCamera.ClearFlags = camera.ClearFlags;
            syncCamera.BackgroundColor = camera.BackgroundColor;
            syncCamera.BackgroundAlpha = camera.BackgroundAlpha;
            syncCamera.PostProcessProfileGuid = camera.PostProcessProfileGuid;
            snapshot.Cameras.push_back(syncCamera);
            if (syncCamera.IsPrimary && syncCamera.Enabled && !snapshot.PrimaryCamera.has_value()) {
                snapshot.PrimaryCamera = syncCamera;
            }
        }

        if (gameObject.HasComponent<MetaCoreLightComponent>()) {
            const auto& light = gameObject.GetComponent<MetaCoreLightComponent>();
            snapshot.Lights.push_back(MetaCoreRenderSyncLight{
                objectId,
                light.Type,
                light.Color,
                light.Intensity,
                worldMatrix,
                light.Enabled,
                light.UseColorTemperature,
                light.ColorTemperatureKelvin,
                light.Range,
                light.InnerConeDegrees,
                light.OuterConeDegrees,
                light.FalloffExponent,
                light.CastShadows,
                light.ShadowBias,
                light.ShadowNormalBias,
                light.ShadowPriority,
                light.LightingMask
            });
        }

        if (gameObject.HasComponent<MetaCoreAnimatorComponent>()) {
            const auto& animator = gameObject.GetComponent<MetaCoreAnimatorComponent>();
            std::string sourceModelPath = animator.SourceModelPath;
            if (sourceModelPath.empty() && gameObject.HasComponent<MetaCoreModelRootTag>()) {
                sourceModelPath = gameObject.GetComponent<MetaCoreModelRootTag>().SourceModelPath;
            }
            snapshot.Animations.push_back(MetaCoreRenderSyncAnimationState{
                objectId,
                animator.SourceModelAssetGuid,
                sourceModelPath,
                animator.ClipIndex,
                animator.RuntimeTimeSeconds,
                animator.Enabled,
                animator.RuntimePlaying,
                animator.Loop,
                animator.Speed
            });
        }
        if(gameObject.HasComponent<MetaCoreReflectionProbeComponent>())snapshot.ReflectionProbes.push_back({objectId,gameObject.GetComponent<MetaCoreReflectionProbeComponent>(),worldMatrix});
        if(gameObject.HasComponent<MetaCoreLodGroupComponent>())snapshot.LodGroups.push_back({objectId,gameObject.GetComponent<MetaCoreLodGroupComponent>(),worldMatrix});
        if(gameObject.HasComponent<MetaCoreParticleEmitterComponent>())snapshot.ParticleEmitters.push_back({objectId,gameObject.GetComponent<MetaCoreParticleEmitterComponent>(),worldMatrix});
        if(gameObject.HasComponent<MetaCoreLineRendererComponent>())snapshot.LineRenderers.push_back({objectId,gameObject.GetComponent<MetaCoreLineRendererComponent>(),worldMatrix});
        if(gameObject.HasComponent<MetaCoreTrailRendererComponent>())snapshot.TrailRenderers.push_back({objectId,gameObject.GetComponent<MetaCoreTrailRendererComponent>(),worldMatrix});
        if(gameObject.HasComponent<MetaCoreDecalProjectorComponent>())snapshot.DecalProjectors.push_back({objectId,gameObject.GetComponent<MetaCoreDecalProjectorComponent>(),worldMatrix});
        if(gameObject.HasComponent<MetaCoreTerrainComponent>())snapshot.Terrains.push_back({objectId,gameObject.GetComponent<MetaCoreTerrainComponent>(),worldMatrix});
    }

    if (!snapshot.PrimaryCamera.has_value() && !snapshot.Cameras.empty()) {
        const MetaCoreRenderSyncCamera* bestCamera = nullptr;
        for (const MetaCoreRenderSyncCamera& camera : snapshot.Cameras) {
            if (!camera.Enabled) {
                continue;
            }
            if (bestCamera == nullptr || camera.Depth < bestCamera->Depth) {
                bestCamera = &camera;
            }
        }
        if (bestCamera != nullptr) {
            snapshot.PrimaryCamera = *bestCamera;
        }
    }

    return snapshot;
}

bool MetaCoreSceneRenderSync::TryBuildSceneViewFromPrimaryCamera(
    const MetaCoreSceneRenderSyncSnapshot& snapshot,
    MetaCoreSceneView& sceneView
) {
    if (!snapshot.PrimaryCamera.has_value()) {
        return false;
    }

    const MetaCoreRenderSyncCamera& camera = *snapshot.PrimaryCamera;
    return TryBuildSceneViewFromCamera(camera, sceneView);
}

bool MetaCoreSceneRenderSync::TryBuildSceneViewFromCamera(
    const MetaCoreRenderSyncCamera& camera,
    MetaCoreSceneView& sceneView
) {
    if (!camera.Enabled) {
        return false;
    }

    const glm::vec3 cameraPosition = MetaCoreExtractTranslation(camera.WorldMatrix);
    glm::vec3 cameraForward = glm::vec3(camera.WorldMatrix * glm::vec4(0.0F, 0.0F, -1.0F, 0.0F));
    glm::vec3 cameraUp = glm::vec3(camera.WorldMatrix * glm::vec4(0.0F, 1.0F, 0.0F, 0.0F));

    if (!MetaCoreIsUsableDirection(cameraForward)) {
        cameraForward = glm::vec3(0.0F, 0.0F, -1.0F);
    }
    if (!MetaCoreIsUsableDirection(cameraUp)) {
        cameraUp = glm::vec3(0.0F, 1.0F, 0.0F);
    }

    sceneView.CameraPosition = cameraPosition;
    sceneView.CameraTarget = cameraPosition + glm::normalize(cameraForward);
    sceneView.CameraUp = glm::normalize(cameraUp);
    sceneView.VerticalFieldOfViewDegrees = camera.FieldOfViewDegrees;
    sceneView.NearClip = camera.NearClip;
    sceneView.FarClip = camera.FarClip;
    sceneView.ProjectionMode = camera.ProjectionMode;
    sceneView.OrthographicSize = camera.OrthographicSize;
    sceneView.ClearFlags = camera.ClearFlags;
    sceneView.BackgroundColor = camera.BackgroundColor;
    sceneView.BackgroundAlpha = camera.BackgroundAlpha;
    sceneView.CullingMask = camera.CullingMask;
    sceneView.SourceCameraObjectId = camera.ObjectId;
    return true;
}

MetaCoreCameraRay MetaCoreScreenPointToRay(
    const MetaCoreSceneView& sceneView,
    const MetaCoreViewportRect& viewportRect,
    const glm::vec2& screenPosition
) {
    const float width = std::max(1.0F, viewportRect.Width);
    const float height = std::max(1.0F, viewportRect.Height);
    const float localX = std::clamp(screenPosition.x - viewportRect.Left, 0.0F, width);
    const float localY = std::clamp(screenPosition.y - viewportRect.Top, 0.0F, height);
    const float normalizedX = (localX / width) * 2.0F - 1.0F;
    const float normalizedY = 1.0F - (localY / height) * 2.0F;

    const glm::vec3 forward = MetaCoreSafeForward(sceneView);
    const glm::vec3 up = MetaCoreSafeUp(sceneView, forward);
    const glm::vec3 right = glm::normalize(glm::cross(forward, up));
    const float aspectRatio = MetaCoreSafeAspectRatio(width, height);

    if (sceneView.ProjectionMode == MetaCoreCameraProjectionMode::Orthographic) {
        const float halfHeight = std::max(0.0001F, sceneView.OrthographicSize);
        const float halfWidth = halfHeight * aspectRatio;
        return MetaCoreCameraRay{
            sceneView.CameraPosition + right * (normalizedX * halfWidth) + up * (normalizedY * halfHeight),
            forward
        };
    }

    const float fovDegrees = std::clamp(sceneView.VerticalFieldOfViewDegrees, 1.0F, 179.0F);
    const float tanHalfFov = std::tan(glm::radians(fovDegrees) * 0.5F);
    return MetaCoreCameraRay{
        sceneView.CameraPosition,
        glm::normalize(forward + right * (normalizedX * tanHalfFov * aspectRatio) + up * (normalizedY * tanHalfFov))
    };
}

std::optional<glm::vec3> MetaCoreWorldToScreenPoint(
    const MetaCoreSceneView& sceneView,
    const MetaCoreViewportRect& viewportRect,
    const glm::vec3& worldPosition
) {
    const float width = std::max(1.0F, viewportRect.Width);
    const float height = std::max(1.0F, viewportRect.Height);
    const glm::vec3 forward = MetaCoreSafeForward(sceneView);
    const glm::vec3 up = MetaCoreSafeUp(sceneView, forward);
    const glm::mat4 viewMatrix = glm::lookAt(sceneView.CameraPosition, sceneView.CameraTarget, up);
    const glm::mat4 projectionMatrix = MetaCoreBuildProjectionMatrix(sceneView, MetaCoreSafeAspectRatio(width, height));
    const glm::vec4 clipPosition = projectionMatrix * viewMatrix * glm::vec4(worldPosition, 1.0F);
    if (std::abs(clipPosition.w) <= 0.000001F) {
        return std::nullopt;
    }

    const glm::vec3 ndc = glm::vec3(clipPosition) / clipPosition.w;
    if (!std::isfinite(ndc.x) || !std::isfinite(ndc.y) || !std::isfinite(ndc.z)) {
        return std::nullopt;
    }

    return glm::vec3(
        viewportRect.Left + (ndc.x + 1.0F) * 0.5F * width,
        viewportRect.Top + (1.0F - ndc.y) * 0.5F * height,
        ndc.z
    );
}

}  // namespace MetaCore