#include "MetaCoreFoundation/MetaCoreGeneratedReflection.h"
#include "MetaCoreFoundation/MetaCoreProject.h"
#include "MetaCoreRuntimeData/MetaCoreRuntimeDataProject.h"
#include "MetaCoreScene/MetaCoreScene.h"
#include "MetaCoreScene/MetaCoreSceneSerializer.h"

#include <algorithm>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <string>

namespace {

[[nodiscard]] MetaCore::MetaCoreSceneDocument MetaCoreBuildPilotSceneDocument() {
    MetaCore::MetaCoreSceneDocument document;
    document.Name = "Main";

    MetaCore::MetaCoreScene scene;
    MetaCore::MetaCoreGameObject mainCamera = scene.CreateGameObjectWithId(1, "Main Camera");
    mainCamera.AddComponent<MetaCore::MetaCoreCameraComponent>().IsPrimary = true;
    mainCamera.GetComponent<MetaCore::MetaCoreTransformComponent>().Position = glm::vec3(0.0F, 2.4F, 7.0F);
    mainCamera.GetComponent<MetaCore::MetaCoreTransformComponent>().RotationEulerDegrees = glm::vec3(-16.0F, 0.0F, 0.0F);

    MetaCore::MetaCoreGameObject keyLight = scene.CreateGameObjectWithId(2, "Directional Light");
    keyLight.AddComponent<MetaCore::MetaCoreLightComponent>();
    keyLight.GetComponent<MetaCore::MetaCoreTransformComponent>().RotationEulerDegrees = glm::vec3(-45.0F, 30.0F, 0.0F);

    MetaCore::MetaCoreGameObject cube = scene.CreateGameObjectWithId(3, "Runtime Cube");
    cube.AddComponent<MetaCore::MetaCoreMeshRendererComponent>().BaseColor = glm::vec3(0.4F, 0.6F, 0.9F);
    cube.GetComponent<MetaCore::MetaCoreTransformComponent>().Position = glm::vec3(0.0F, 0.5F, 0.0F);

    MetaCore::MetaCoreGameObject valve = scene.CreateGameObjectWithId(4, "Runtime Valve");
    valve.AddComponent<MetaCore::MetaCoreMeshRendererComponent>().BaseColor = glm::vec3(0.9F, 0.55F, 0.25F);
    valve.GetComponent<MetaCore::MetaCoreTransformComponent>().Position = glm::vec3(-2.0F, 0.5F, 0.0F);
    valve.GetComponent<MetaCore::MetaCoreTransformComponent>().Scale = glm::vec3(0.65F, 0.65F, 0.65F);

    MetaCore::MetaCoreGameObject tank = scene.CreateGameObjectWithId(5, "Runtime Tank");
    tank.AddComponent<MetaCore::MetaCoreMeshRendererComponent>().BaseColor = glm::vec3(0.35F, 0.65F, 0.90F);
    tank.GetComponent<MetaCore::MetaCoreTransformComponent>().Position = glm::vec3(2.0F, 0.5F, 0.0F);
    tank.GetComponent<MetaCore::MetaCoreTransformComponent>().Scale = glm::vec3(1.25F, 1.25F, 1.25F);

    MetaCore::MetaCoreGameObject alarm = scene.CreateGameObjectWithId(6, "Runtime Alarm Light");
    alarm.AddComponent<MetaCore::MetaCoreLightComponent>().Intensity = 0.0F;
    alarm.GetComponent<MetaCore::MetaCoreTransformComponent>().Position = glm::vec3(0.0F, 3.0F, 0.0F);

    MetaCore::MetaCoreIdGenerator::EnsureAbove(6);
    document.GameObjects = scene.CaptureSnapshot().GameObjects;
    return document;
}

[[nodiscard]] MetaCore::MetaCoreUiDocument MetaCoreBuildPilotUiDocument() {
    MetaCore::MetaCoreUiDocument document;
    document.Name = "RuntimeDataHud";
    document.ReferenceWidth = 1280;
    document.ReferenceHeight = 720;
    document.RootNodeIds = {"runtime.root"};

    MetaCore::MetaCoreUiNodeDocument root;
    root.Id = "runtime.root";
    root.Name = "Runtime Root";
    root.Type = MetaCore::MetaCoreUiNodeType::Panel;
    root.Children = {"runtime.status"};
    root.RectTransform.AnchorMin = glm::vec3(0.0F, 0.0F, 0.0F);
    root.RectTransform.AnchorMax = glm::vec3(1.0F, 1.0F, 0.0F);
    root.RectTransform.Size = glm::vec3(0.0F, 0.0F, 0.0F);
    root.Style.BackgroundColor = glm::vec3(0.0F, 0.0F, 0.0F);

    MetaCore::MetaCoreUiNodeDocument status;
    status.Id = "runtime.status";
    status.Name = "Runtime Status";
    status.Type = MetaCore::MetaCoreUiNodeType::Text;
    status.ParentId = "runtime.root";
    status.Text = "RuntimeData waiting";
    status.RectTransform.Position = glm::vec3(24.0F, 24.0F, 0.0F);
    status.RectTransform.Size = glm::vec3(560.0F, 40.0F, 0.0F);
    status.Style.FontSize = 18.0F;
    status.Style.TextColor = glm::vec3(0.88F, 0.94F, 1.0F);

    document.Nodes = {root, status};
    return document;
}

[[nodiscard]] const MetaCore::MetaCoreGameObjectData* MetaCoreFindSceneObject(
    const MetaCore::MetaCoreSceneDocument& sceneDocument,
    MetaCore::MetaCoreId objectId
) {
    const auto iterator = std::find_if(
        sceneDocument.GameObjects.begin(),
        sceneDocument.GameObjects.end(),
        [objectId](const MetaCore::MetaCoreGameObjectData& objectData) {
            return objectData.Id == objectId;
        }
    );
    return iterator == sceneDocument.GameObjects.end() ? nullptr : &(*iterator);
}

[[nodiscard]] bool MetaCoreValidatePilotRuntimeDocuments(
    const MetaCore::MetaCoreSceneDocument& sceneDocument,
    const MetaCore::MetaCoreUiDocument& uiDocument,
    const MetaCore::MetaCoreRuntimeBindingsDocument& bindings,
    std::string& error
) {
    for (const MetaCore::MetaCoreSceneBindingDefinition& binding : bindings.Bindings) {
        const MetaCore::MetaCoreGameObjectData* targetObject =
            MetaCoreFindSceneObject(sceneDocument, binding.TargetObjectId);
        if (targetObject == nullptr) {
            error = "Scene binding target object does not exist: " + binding.BindingId;
            return false;
        }

        const bool targetHasRequiredComponent =
            binding.Target == MetaCore::MetaCoreRuntimeBindingTarget::TransformPosition ||
            ((binding.Target == MetaCore::MetaCoreRuntimeBindingTarget::MeshRendererVisible ||
              binding.Target == MetaCore::MetaCoreRuntimeBindingTarget::MeshRendererBaseColor) &&
             targetObject->MeshRenderer.has_value()) ||
            ((binding.Target == MetaCore::MetaCoreRuntimeBindingTarget::LightIntensity ||
              binding.Target == MetaCore::MetaCoreRuntimeBindingTarget::LightColor) &&
             targetObject->Light.has_value());
        if (!targetHasRequiredComponent) {
            error = "Scene binding target object is missing the required component: " + binding.BindingId;
            return false;
        }
    }

    for (const MetaCore::MetaCoreUiBindingDefinition& binding : bindings.UiBindings) {
        if (binding.Target != MetaCore::MetaCoreRuntimeUiBindingTarget::Text) {
            continue;
        }

        const auto nodeIterator = std::find_if(
            uiDocument.Nodes.begin(),
            uiDocument.Nodes.end(),
            [&](const MetaCore::MetaCoreUiNodeDocument& node) {
                return node.Id == binding.TargetNodeId;
            }
        );
        if (nodeIterator == uiDocument.Nodes.end() || nodeIterator->Type != MetaCore::MetaCoreUiNodeType::Text) {
            error = "UI binding target Text node does not exist: " + binding.BindingId;
            return false;
        }
    }
    return true;
}

}  // namespace

int main(int argc, char* argv[]) {
    if (argc < 2) {
        std::cerr << "Usage: MetaCoreRuntimeConfigTool <runtime-directory> [--tcp]\n";
        return 1;
    }

    const bool generateTcpConfig = argc >= 3 && std::string_view(argv[2]) == "--tcp";

    MetaCore::MetaCoreTypeRegistry registry;
    MetaCore::MetaCoreRegisterFoundationGeneratedTypes(registry);
    MetaCore::MetaCoreRegisterSceneGeneratedTypes(registry);
    MetaCore::MetaCoreRegisterRuntimeDataGeneratedTypes(registry);

    const std::filesystem::path runtimeDirectory = std::filesystem::absolute(argv[1]).lexically_normal();
    const std::filesystem::path projectRoot = runtimeDirectory.parent_path();
    const std::filesystem::path runtimeDirectoryRelative =
        MetaCore::MetaCoreBuildRuntimeDirectoryRelativePath(projectRoot, runtimeDirectory);
    const std::filesystem::path sceneRelativePath = std::filesystem::path("Scenes") / "Main.mcscene.json";
    const std::filesystem::path uiRelativePath = std::filesystem::path("Assets") / "UI" / "Hud.mcui.json";

    MetaCore::MetaCoreRuntimeDataSourcesDocument sources;
    sources.Sources.push_back(MetaCore::MetaCoreDataSourceDefinition{
        generateTcpConfig ? "tcp-source" : "replay-source",
        generateTcpConfig ? "tcp" : "file_replay",
        generateTcpConfig ? "Tcp Source" : "Replay Source",
        generateTcpConfig
            ? std::vector<MetaCore::MetaCoreDataSourceSetting>{
                MetaCore::MetaCoreDataSourceSetting{"host", "127.0.0.1"},
                MetaCore::MetaCoreDataSourceSetting{"port", "7001"}
            }
            : std::vector<MetaCore::MetaCoreDataSourceSetting>{
                // 动态计算相对于项目根目录的播放流文件路径，替代原先硬编码的 TestProject
                MetaCore::MetaCoreDataSourceSetting{"file_path", (runtimeDirectoryRelative / "RuntimeReplay.mcstream").generic_string()}
            },
        true,
        1000
    });
    sources.DataPoints.push_back(MetaCore::MetaCoreDataPointDefinition{
        "cube.position",
        generateTcpConfig ? "tcp-source" : "replay-source",
        "cube.position",
        MetaCore::MetaCoreRuntimeValueType::Vec3
    });
    sources.DataPoints.push_back(MetaCore::MetaCoreDataPointDefinition{
        "cube.visible",
        generateTcpConfig ? "tcp-source" : "replay-source",
        "cube.visible",
        MetaCore::MetaCoreRuntimeValueType::Bool
    });
    sources.DataPoints.push_back(MetaCore::MetaCoreDataPointDefinition{
        "cube.base_color",
        generateTcpConfig ? "tcp-source" : "replay-source",
        "cube.base_color",
        MetaCore::MetaCoreRuntimeValueType::Vec3
    });
    sources.DataPoints.push_back(MetaCore::MetaCoreDataPointDefinition{
        "valve.visible",
        generateTcpConfig ? "tcp-source" : "replay-source",
        "valve.visible",
        MetaCore::MetaCoreRuntimeValueType::Bool
    });
    sources.DataPoints.push_back(MetaCore::MetaCoreDataPointDefinition{
        "tank.base_color",
        generateTcpConfig ? "tcp-source" : "replay-source",
        "tank.base_color",
        MetaCore::MetaCoreRuntimeValueType::Vec3
    });
    sources.DataPoints.push_back(MetaCore::MetaCoreDataPointDefinition{
        "alarm.intensity",
        generateTcpConfig ? "tcp-source" : "replay-source",
        "alarm.intensity",
        MetaCore::MetaCoreRuntimeValueType::Double
    });
    sources.DataPoints.push_back(MetaCore::MetaCoreDataPointDefinition{
        "runtime.status",
        generateTcpConfig ? "tcp-source" : "replay-source",
        "runtime.status",
        MetaCore::MetaCoreRuntimeValueType::String
    });

    MetaCore::MetaCoreRuntimeBindingsDocument bindings;
    bindings.Bindings.push_back(MetaCore::MetaCoreSceneBindingDefinition{
        "binding.cube.position",
        "cube.position",
        3,
        MetaCore::MetaCoreRuntimeBindingTarget::TransformPosition,
        MetaCore::MetaCoreRuntimeMissingDataPolicy::KeepLastValue
    });
    bindings.Bindings.push_back(MetaCore::MetaCoreSceneBindingDefinition{
        "binding.cube.visible",
        "cube.visible",
        3,
        MetaCore::MetaCoreRuntimeBindingTarget::MeshRendererVisible,
        MetaCore::MetaCoreRuntimeMissingDataPolicy::KeepLastValue
    });
    bindings.Bindings.push_back(MetaCore::MetaCoreSceneBindingDefinition{
        "binding.cube.base_color",
        "cube.base_color",
        3,
        MetaCore::MetaCoreRuntimeBindingTarget::MeshRendererBaseColor,
        MetaCore::MetaCoreRuntimeMissingDataPolicy::KeepLastValue
    });
    bindings.Bindings.push_back(MetaCore::MetaCoreSceneBindingDefinition{
        "binding.valve.visible",
        "valve.visible",
        4,
        MetaCore::MetaCoreRuntimeBindingTarget::MeshRendererVisible,
        MetaCore::MetaCoreRuntimeMissingDataPolicy::KeepLastValue
    });
    bindings.Bindings.push_back(MetaCore::MetaCoreSceneBindingDefinition{
        "binding.tank.base_color",
        "tank.base_color",
        5,
        MetaCore::MetaCoreRuntimeBindingTarget::MeshRendererBaseColor,
        MetaCore::MetaCoreRuntimeMissingDataPolicy::KeepLastValue
    });
    bindings.Bindings.push_back(MetaCore::MetaCoreSceneBindingDefinition{
        "binding.alarm.intensity",
        "alarm.intensity",
        6,
        MetaCore::MetaCoreRuntimeBindingTarget::LightIntensity,
        MetaCore::MetaCoreRuntimeMissingDataPolicy::KeepLastValue
    });
    bindings.UiBindings.push_back(MetaCore::MetaCoreUiBindingDefinition{
        "binding.runtime.status",
        "runtime.status",
        "runtime.status",
        MetaCore::MetaCoreRuntimeUiBindingTarget::Text,
        MetaCore::MetaCoreRuntimeMissingDataPolicy::KeepLastValue
    });

    const MetaCore::MetaCoreSceneDocument sceneDocument = MetaCoreBuildPilotSceneDocument();
    const MetaCore::MetaCoreUiDocument uiDocument = MetaCoreBuildPilotUiDocument();
    std::string validationError;
    if (!MetaCoreValidatePilotRuntimeDocuments(sceneDocument, uiDocument, bindings, validationError)) {
        std::cerr << "Generated runtime config is invalid: " << validationError << '\n';
        return 1;
    }

    const std::filesystem::path scenePath = projectRoot / sceneRelativePath;
    const std::filesystem::path uiPath = projectRoot / uiRelativePath;
    std::filesystem::create_directories(runtimeDirectory);
    if (!MetaCore::MetaCoreWriteRuntimeDataSourcesDocument(runtimeDirectory / "DataSources.mcruntime", sources, registry)) {
        std::cerr << "Failed to write DataSources.mcruntime\n";
        return 1;
    }
    if (!MetaCore::MetaCoreWriteRuntimeBindingsDocument(runtimeDirectory / "Bindings.mcruntime", bindings, registry)) {
        std::cerr << "Failed to write Bindings.mcruntime\n";
        return 1;
    }
    MetaCore::MetaCoreRuntimeProjectDocument runtimeProjectDocument =
        MetaCore::MetaCoreBuildDefaultRuntimeProjectDocument(runtimeDirectoryRelative);
    runtimeProjectDocument.StartupScenePath = sceneRelativePath;
    runtimeProjectDocument.StartupUiPath = uiRelativePath;
    if (!MetaCore::MetaCoreWriteRuntimeProjectDocument(runtimeDirectory / "ProjectRuntime.mcruntimecfg", runtimeProjectDocument, registry)) {
        std::cerr << "Failed to write ProjectRuntime.mcruntimecfg\n";
        return 1;
    }

    MetaCore::MetaCoreProjectFileDocument projectDocument;
    projectDocument.Name = generateTcpConfig ? "MetaCoreTcpRuntimeDataPilot" : "MetaCoreRuntimeDataPilot";
    projectDocument.RuntimeDirectory = runtimeDirectoryRelative;
    projectDocument.UiDirectory = std::filesystem::path("Assets") / "UI";
    projectDocument.BuildDirectory = std::filesystem::path("Build");
    projectDocument.StartupScenePath = sceneRelativePath;
    projectDocument.ScenePaths = {sceneRelativePath};
    if (!MetaCore::MetaCoreWriteProjectFile(MetaCore::MetaCoreGetProjectFilePath(projectRoot), projectDocument)) {
        std::cerr << "Failed to write MetaCore.project.json\n";
        return 1;
    }

    std::filesystem::create_directories(scenePath.parent_path());
    if (!MetaCore::MetaCoreSceneSerializer::SaveSceneToJson(scenePath, sceneDocument, registry)) {
        std::cerr << "Failed to write Main.mcscene.json\n";
        return 1;
    }
    std::filesystem::create_directories(uiPath.parent_path());
    if (!MetaCore::MetaCoreSceneSerializer::SaveUiToJson(uiPath, uiDocument, registry)) {
        std::cerr << "Failed to write Hud.mcui.json\n";
        return 1;
    }

    if (!generateTcpConfig) {
        std::ofstream replayFile(runtimeDirectory / "RuntimeReplay.mcstream", std::ios::trunc);
        if (!replayFile) {
            std::cerr << "Failed to write RuntimeReplay.mcstream\n";
            return 1;
        }
        replayFile
            << "# emit_after_seconds data_point_id value_type payload\n"
            << "0.00 cube.position vec3 0.0 0.5 0.0\n"
            << "0.00 cube.visible bool true\n"
            << "0.00 cube.base_color vec3 0.4 0.6 0.9\n"
            << "0.00 valve.visible bool true\n"
            << "0.00 tank.base_color vec3 0.35 0.65 0.90\n"
            << "0.00 alarm.intensity double 0.0\n"
            << "0.00 runtime.status string RuntimeData replay started\n"
            << "0.50 cube.position vec3 1.5 0.5 0.0\n"
            << "0.50 cube.base_color vec3 0.8 0.6 0.5\n"
            << "0.50 tank.base_color vec3 0.20 0.80 0.25\n"
            << "0.50 alarm.intensity double 2.0\n"
            << "0.50 runtime.status string Replay frame 0.50s active\n"
            << "1.00 cube.visible bool false\n"
            << "1.00 valve.visible bool false\n"
            << "1.00 runtime.status string Replay toggled visibility\n"
            << "1.50 cube.position vec3 -1.5 0.5 0.0\n"
            << "1.50 cube.visible bool true\n"
            << "1.50 valve.visible bool true\n"
            << "1.50 alarm.intensity double 0.0\n"
            << "1.50 runtime.status string Replay restored scene\n";
    }

    std::cout << "Runtime config generated at " << runtimeDirectory.string()
              << " scene=" << scenePath.string()
              << " ui=" << uiPath.string()
              << " mode=" << (generateTcpConfig ? "tcp" : "file_replay") << '\n';
    return 0;
}