#include "MetaCoreFoundation/MetaCoreProject.h"
#include "MetaCorePlatform/MetaCoreWindow.h"
#include "MetaCoreRender/MetaCoreEditorViewportRenderer.h"
#include "MetaCoreRender/MetaCoreRenderDevice.h"

#include <imgui.h>
#if defined(_WIN32)
#include <imgui_impl_win32.h>
#else
#include <imgui_impl_glfw.h>
#include <GLFW/glfw3.h>
#endif
#include <nlohmann/json.hpp>

#include <algorithm>
#include <array>
#include <chrono>
#include <csignal>
#include <cctype>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <filesystem>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <new>
#include <optional>
#include <sstream>
#include <string>
#include <string_view>
#include <system_error>
#include <vector>

#if defined(_WIN32)
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#include <windows.h>
#else
#include <limits.h>
#include <spawn.h>
#include <unistd.h>
#endif

#if defined(_WIN32)
extern IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
#else
extern char** environ;
#endif

namespace {

struct MetaCoreLauncherProjectRecord {
    std::string Name{};
    std::filesystem::path Root{};
    std::string LastOpened{};
};

enum class MetaCoreLauncherPathPickerTarget {
    NewProjectParent,
    ExistingProject
};

struct MetaCoreLauncherPathPickerEntry {
    std::filesystem::path Path{};
    std::string Label{};
    bool IsDirectory = false;
    bool IsProjectFile = false;
};

[[nodiscard]] std::string MetaCoreToLower(std::string value) {
    std::transform(value.begin(), value.end(), value.begin(), [](unsigned char character) {
        return static_cast<char>(std::tolower(character));
    });
    return value;
}

[[nodiscard]] std::string MetaCoreNowIsoString() {
    const auto now = std::chrono::system_clock::now();
    const auto timeValue = std::chrono::system_clock::to_time_t(now);
    std::tm timeInfo{};
#if defined(_WIN32)
    localtime_s(&timeInfo, &timeValue);
#else
    localtime_r(&timeValue, &timeInfo);
#endif

    std::ostringstream stream;
    stream << std::put_time(&timeInfo, "%Y-%m-%dT%H:%M:%S");
    return stream.str();
}

[[nodiscard]] std::filesystem::path MetaCoreGetExecutableDirectory() {
#if defined(_WIN32)
    std::vector<wchar_t> buffer(MAX_PATH, L'\0');
    while (true) {
        const DWORD copied = GetModuleFileNameW(nullptr, buffer.data(), static_cast<DWORD>(buffer.size()));
        if (copied == 0) {
            return {};
        }
        if (copied < buffer.size() - 1) {
            return std::filesystem::path(std::wstring(buffer.data(), copied)).parent_path();
        }
        buffer.resize(buffer.size() * 2, L'\0');
    }
#else
    std::vector<char> buffer(PATH_MAX, '\0');
    while (true) {
        const ssize_t copied = readlink("/proc/self/exe", buffer.data(), buffer.size());
        if (copied < 0) {
            return {};
        }
        if (static_cast<std::size_t>(copied) < buffer.size()) {
            return std::filesystem::path(std::string(buffer.data(), static_cast<std::size_t>(copied))).parent_path();
        }
        buffer.resize(buffer.size() * 2, '\0');
    }
#endif
}

[[nodiscard]] std::filesystem::path MetaCoreGetLauncherStatePath() {
#if defined(_WIN32)
    if (const char* appData = std::getenv("APPDATA"); appData != nullptr && appData[0] != '\0') {
        return std::filesystem::path(appData) / "MetaCore" / "launcher_projects.json";
    }
#else
    if (const char* home = std::getenv("HOME"); home != nullptr && home[0] != '\0') {
        return std::filesystem::path(home) / ".metacore" / "launcher_projects.json";
    }
#endif
    return std::filesystem::current_path() / ".metacore" / "launcher_projects.json";
}

[[nodiscard]] std::filesystem::path MetaCoreGetHomeDirectory() {
#if defined(_WIN32)
    if (const char* userProfile = std::getenv("USERPROFILE"); userProfile != nullptr && userProfile[0] != '\0') {
        return std::filesystem::path(userProfile);
    }
#else
    if (const char* home = std::getenv("HOME"); home != nullptr && home[0] != '\0') {
        return std::filesystem::path(home);
    }
#endif
    return std::filesystem::current_path();
}

[[nodiscard]] std::string MetaCoreReadProjectDisplayName(const std::filesystem::path& projectRoot) {
    if (const auto projectDocument = MetaCore::MetaCoreReadProjectFile(MetaCore::MetaCoreGetProjectFilePath(projectRoot));
        projectDocument.has_value() && !projectDocument->Name.empty()) {
        return projectDocument->Name;
    }
    return projectRoot.filename().string();
}

[[nodiscard]] std::string MetaCoreProjectRootKey(const std::filesystem::path& projectRoot) {
    if (const auto resolvedRoot = MetaCore::MetaCoreResolveProjectRootCandidate(projectRoot); resolvedRoot.has_value()) {
        return resolvedRoot->generic_string();
    }
    return projectRoot.lexically_normal().generic_string();
}

void MetaCoreCopyToBuffer(std::array<char, 512>& buffer, const std::string& value) {
    std::memset(buffer.data(), 0, buffer.size());
    std::strncpy(buffer.data(), value.c_str(), buffer.size() - 1);
}

void MetaCoreCopyToBuffer(std::array<char, 128>& buffer, const std::string& value) {
    std::memset(buffer.data(), 0, buffer.size());
    std::strncpy(buffer.data(), value.c_str(), buffer.size() - 1);
}

[[nodiscard]] std::vector<MetaCoreLauncherPathPickerEntry> MetaCoreCollectPathPickerEntries(
    const std::filesystem::path& directory,
    bool includeProjectFile
) {
    std::vector<MetaCoreLauncherPathPickerEntry> entries;
    std::error_code errorCode;
    const std::filesystem::directory_options options = std::filesystem::directory_options::skip_permission_denied;
    for (auto iterator = std::filesystem::directory_iterator(directory, options, errorCode);
         iterator != std::filesystem::directory_iterator();
         iterator.increment(errorCode)) {
        if (errorCode) {
            errorCode.clear();
            continue;
        }

        const std::filesystem::path entryPath = iterator->path();
        errorCode.clear();
        const bool isDirectory = iterator->is_directory(errorCode);
        errorCode.clear();
        const bool isProjectFile =
            includeProjectFile &&
            iterator->is_regular_file(errorCode) &&
            entryPath.filename() == "MetaCore.project.json";
        if (!isDirectory && !isProjectFile) {
            continue;
        }

        MetaCoreLauncherPathPickerEntry entry;
        entry.Path = entryPath;
        entry.Label = entryPath.filename().string();
        entry.IsDirectory = isDirectory;
        entry.IsProjectFile = isProjectFile;
        entries.push_back(std::move(entry));
    }

    std::sort(entries.begin(), entries.end(), [](const auto& lhs, const auto& rhs) {
        if (lhs.IsDirectory != rhs.IsDirectory) {
            return lhs.IsDirectory;
        }
        return MetaCoreToLower(lhs.Label) < MetaCoreToLower(rhs.Label);
    });
    return entries;
}

[[nodiscard]] std::filesystem::path MetaCoreEditorExecutablePath() {
    std::filesystem::path editorPath = MetaCoreGetExecutableDirectory() / "MetaCoreEditorApp";
#if defined(_WIN32)
    editorPath += ".exe";
#endif
    return editorPath;
}

bool MetaCoreLaunchEditorForProject(
    const std::filesystem::path& projectRoot,
    std::string& outError,
    bool removeLauncherOwnedBackend = false
) {
    const std::filesystem::path editorPath = MetaCoreEditorExecutablePath();
    if (!std::filesystem::exists(editorPath)) {
        outError = "启动器旁边找不到 MetaCoreEditorApp。";
        return false;
    }

#if defined(_WIN32)
    SetEnvironmentVariableW(L"METACORE_PROJECT_PATH", projectRoot.wstring().c_str());
    std::wstring commandLine =
        L"\"" + editorPath.wstring() + L"\" --project \"" + projectRoot.wstring() + L"\"";

    STARTUPINFOW startupInfo{};
    startupInfo.cb = sizeof(startupInfo);
    PROCESS_INFORMATION processInfo{};
    std::vector<wchar_t> mutableCommandLine(commandLine.begin(), commandLine.end());
    mutableCommandLine.push_back(L'\0');

    const BOOL created = CreateProcessW(
        nullptr,
        mutableCommandLine.data(),
        nullptr,
        nullptr,
        FALSE,
        0,
        nullptr,
        editorPath.parent_path().wstring().c_str(),
        &startupInfo,
        &processInfo
    );
    if (!created) {
        outError = "启动 MetaCoreEditorApp 失败。";
        return false;
    }
    CloseHandle(processInfo.hThread);
    CloseHandle(processInfo.hProcess);
    return true;
#else
    const std::string editorPathString = editorPath.string();
    const std::string editorNameString = editorPath.filename().string();
    const std::string projectRootString = projectRoot.string();

    std::vector<std::string> environmentStrings;
    for (char** iterator = environ; iterator != nullptr && *iterator != nullptr; ++iterator) {
        const std::string_view entry(*iterator);
        if (entry.rfind("METACORE_PROJECT_PATH=", 0) == 0) {
            continue;
        }
        if (removeLauncherOwnedBackend && entry.rfind("METACORE_FILAMENT_BACKEND=", 0) == 0) {
            continue;
        }
        environmentStrings.emplace_back(*iterator);
    }
    environmentStrings.emplace_back("METACORE_PROJECT_PATH=" + projectRootString);

    std::vector<char*> environmentPointers;
    environmentPointers.reserve(environmentStrings.size() + 1);
    for (std::string& entry : environmentStrings) {
        environmentPointers.push_back(entry.data());
    }
    environmentPointers.push_back(nullptr);

    std::array<char*, 4> arguments = {
        const_cast<char*>(editorNameString.c_str()),
        const_cast<char*>("--project"),
        const_cast<char*>(projectRootString.c_str()),
        nullptr
    };

    pid_t childPid = 0;
    const int result = posix_spawn(
        &childPid,
        editorPathString.c_str(),
        nullptr,
        nullptr,
        arguments.data(),
        environmentPointers.data()
    );
    if (result != 0) {
        outError = "启动 MetaCoreEditorApp 失败。";
        return false;
    }
    return true;
#endif
}

void MetaCoreConfigureLauncherFont() {
    ImGuiIO& io = ImGui::GetIO();
    io.Fonts->AddFontDefault();

    std::vector<std::filesystem::path> candidatePaths;
    if (const char* overrideFontPath = std::getenv("METACORE_IMGUI_FONT"); overrideFontPath != nullptr && overrideFontPath[0] != '\0') {
        candidatePaths.emplace_back(overrideFontPath);
    }

#if defined(_WIN32)
    char* windowsDirectory = nullptr;
    std::size_t windowsDirectoryLength = 0;
    if (_dupenv_s(&windowsDirectory, &windowsDirectoryLength, "WINDIR") == 0 && windowsDirectory != nullptr) {
        const std::filesystem::path fontsPath = std::filesystem::path(windowsDirectory) / "Fonts";
        candidatePaths.push_back(fontsPath / "NotoSansSC-VF.ttf");
        candidatePaths.push_back(fontsPath / "msyh.ttc");
        candidatePaths.push_back(fontsPath / "msyhbd.ttc");
        candidatePaths.push_back(fontsPath / "Deng.ttf");
        candidatePaths.push_back(fontsPath / "simhei.ttf");
        free(windowsDirectory);
    }
#else
    candidatePaths.emplace_back("/usr/share/fonts/opentype/noto/NotoSansCJK-Regular.ttc");
    candidatePaths.emplace_back("/usr/share/fonts/opentype/noto/NotoSansCJK-Medium.ttc");
    candidatePaths.emplace_back("/usr/share/fonts/truetype/wqy/wqy-microhei.ttc");
    candidatePaths.emplace_back("/usr/share/fonts/truetype/wqy/wqy-zenhei.ttc");
    candidatePaths.emplace_back("/usr/share/fonts/truetype/droid/DroidSansFallbackFull.ttf");
    candidatePaths.emplace_back("/usr/share/fonts/truetype/arphic/uming.ttc");
#endif

    for (const auto& candidatePath : candidatePaths) {
        if (!std::filesystem::exists(candidatePath)) {
            continue;
        }

        try {
            ImFont* font = io.Fonts->AddFontFromFileTTF(
                candidatePath.string().c_str(),
                17.0F,
                nullptr,
                io.Fonts->GetGlyphRangesChineseSimplifiedCommon()
            );
            if (font != nullptr) {
                io.FontDefault = font;
                return;
            }
        } catch (const std::bad_alloc&) {
        }
    }
}

void MetaCoreApplyLauncherStyle() {
    ImGuiStyle& style = ImGui::GetStyle();
    ImGui::StyleColorsDark();
    style.WindowRounding = 0.0F;
    style.ChildRounding = 6.0F;
    style.PopupRounding = 6.0F;
    style.FrameRounding = 6.0F;
    style.GrabRounding = 6.0F;
    style.WindowBorderSize = 0.0F;
    style.FrameBorderSize = 1.0F;
    style.WindowPadding = ImVec2(0.0F, 0.0F);
    style.FramePadding = ImVec2(10.0F, 7.0F);
    style.ItemSpacing = ImVec2(8.0F, 8.0F);
    style.ScrollbarSize = 8.0F;

    style.Colors[ImGuiCol_Text] = ImVec4(0.81F, 0.81F, 0.81F, 1.0F);
    style.Colors[ImGuiCol_TextDisabled] = ImVec4(0.42F, 0.42F, 0.42F, 1.0F);
    style.Colors[ImGuiCol_WindowBg] = ImVec4(0.098F, 0.098F, 0.098F, 1.0F);
    style.Colors[ImGuiCol_ChildBg] = ImVec4(0.125F, 0.125F, 0.125F, 1.0F);
    style.Colors[ImGuiCol_PopupBg] = ImVec4(0.125F, 0.125F, 0.125F, 0.98F);
    style.Colors[ImGuiCol_Border] = ImVec4(0.18F, 0.18F, 0.18F, 1.0F);
    style.Colors[ImGuiCol_FrameBg] = ImVec4(0.125F, 0.125F, 0.125F, 1.0F);
    style.Colors[ImGuiCol_FrameBgHovered] = ImVec4(0.165F, 0.165F, 0.165F, 1.0F);
    style.Colors[ImGuiCol_FrameBgActive] = ImVec4(0.20F, 0.20F, 0.20F, 1.0F);
    style.Colors[ImGuiCol_Button] = ImVec4(0.125F, 0.125F, 0.125F, 1.0F);
    style.Colors[ImGuiCol_ButtonHovered] = ImVec4(0.165F, 0.165F, 0.165F, 1.0F);
    style.Colors[ImGuiCol_ButtonActive] = ImVec4(0.20F, 0.20F, 0.20F, 1.0F);
    style.Colors[ImGuiCol_Header] = ImVec4(0.20F, 0.20F, 0.20F, 1.0F);
    style.Colors[ImGuiCol_HeaderHovered] = ImVec4(0.24F, 0.24F, 0.24F, 1.0F);
    style.Colors[ImGuiCol_HeaderActive] = ImVec4(1.0F, 1.0F, 1.0F, 0.18F);
    style.Colors[ImGuiCol_Separator] = ImVec4(0.18F, 0.18F, 0.18F, 1.0F);
}

class MetaCoreLauncherApp {
public:
    ~MetaCoreLauncherApp() {
        Shutdown();
    }

    bool Initialize() {
        if (std::getenv("METACORE_FILAMENT_BACKEND") == nullptr) {
#if defined(_WIN32)
            _putenv_s("METACORE_FILAMENT_BACKEND", "opengl");
#else
            setenv("METACORE_FILAMENT_BACKEND", "opengl", 0);
#endif
            LauncherSetFilamentBackend_ = true;
        }

        if (!Window_.Initialize(1080, 720, "MetaCore 启动器")) {
            return false;
        }

#if defined(_WIN32)
        Window_.SetNativeWindowMessageHandler([](void* nativeWindowHandle, unsigned int message, std::uintptr_t wparam, std::intptr_t lparam) {
            return ImGui_ImplWin32_WndProcHandler(static_cast<HWND>(nativeWindowHandle), message, static_cast<WPARAM>(wparam), static_cast<LPARAM>(lparam)) != 0;
        });
#endif

        if (!RenderDevice_.Initialize(Window_)) {
            return false;
        }

        IMGUI_CHECKVERSION();
        ImGui::CreateContext();
        ImGuiIO& io = ImGui::GetIO();
        io.IniFilename = nullptr;
        io.LogFilename = nullptr;
        MetaCoreConfigureLauncherFont();
        MetaCoreApplyLauncherStyle();

#if defined(_WIN32)
        if (!ImGui_ImplWin32_InitForOpenGL(Window_.GetNativeWindowHandle())) {
#else
        if (!ImGui_ImplGlfw_InitForOther(static_cast<GLFWwindow*>(Window_.GetNativeWindowHandle()), true)) {
#endif
            return false;
        }

        if (!ViewportRenderer_.Initialize(RenderDevice_, Window_, true)) {
            return false;
        }

        LoadState();
        MetaCoreCopyToBuffer(NewProjectParentBuffer_, std::filesystem::current_path().string());
        MetaCoreCopyToBuffer(NewProjectNameBuffer_, "新项目");
        Initialized_ = true;
        return true;
    }

    int Run() {
        while (!Window_.ShouldClose()) {
            Window_.BeginFrame();
#if defined(_WIN32)
            ImGui_ImplWin32_NewFrame();
#else
            ImGui_ImplGlfw_NewFrame();
#endif
            ImGui::NewFrame();
            DrawFrame();
            ImGui::Render();
            ViewportRenderer_.RenderAll();
            Window_.EndFrame();
        }
        return 0;
    }

    void Shutdown() {
        if (!Initialized_) {
            return;
        }
        ViewportRenderer_.Shutdown();
#if defined(_WIN32)
        ImGui_ImplWin32_Shutdown();
#else
        ImGui_ImplGlfw_Shutdown();
#endif
        ImGui::DestroyContext();
        RenderDevice_.Shutdown();
        Window_.Shutdown();
        Initialized_ = false;
    }

private:
    void LoadState() {
        Projects_.clear();
        const std::filesystem::path statePath = MetaCoreGetLauncherStatePath();
        std::ifstream input(statePath);
        if (!input.is_open()) {
            return;
        }

        try {
            nlohmann::json json;
            input >> json;
            if (!json.contains("recent_projects") || !json["recent_projects"].is_array()) {
                return;
            }
            for (const auto& item : json["recent_projects"]) {
                if (!item.contains("root") || !item["root"].is_string()) {
                    continue;
                }
                MetaCoreLauncherProjectRecord record;
                record.Root = item["root"].get<std::string>();
                if (item.contains("name") && item["name"].is_string()) {
                    record.Name = item["name"].get<std::string>();
                }
                if (item.contains("last_opened") && item["last_opened"].is_string()) {
                    record.LastOpened = item["last_opened"].get<std::string>();
                }
                if (const auto resolvedRoot = MetaCore::MetaCoreResolveProjectRootCandidate(record.Root); resolvedRoot.has_value()) {
                    record.Root = *resolvedRoot;
                    record.Name = MetaCoreReadProjectDisplayName(record.Root);
                } else if (record.Name.empty()) {
                    record.Name = record.Root.filename().string();
                }
                Projects_.push_back(std::move(record));
            }
        } catch (const std::exception& exceptionObject) {
            StatusMessage_ = std::string("读取启动器状态失败：") + exceptionObject.what();
        }
    }

    void SaveState() const {
        const std::filesystem::path statePath = MetaCoreGetLauncherStatePath();
        std::error_code errorCode;
        std::filesystem::create_directories(statePath.parent_path(), errorCode);
        if (errorCode) {
            return;
        }

        nlohmann::json json;
        json["recent_projects"] = nlohmann::json::array();
        for (const auto& project : Projects_) {
            json["recent_projects"].push_back({
                {"name", project.Name},
                {"root", project.Root.generic_string()},
                {"last_opened", project.LastOpened}
            });
        }

        std::ofstream output(statePath, std::ios::trunc);
        if (output.is_open()) {
            output << json.dump(2);
        }
    }

    bool UpsertProject(const std::filesystem::path& projectRoot) {
        const auto resolvedRoot = MetaCore::MetaCoreResolveProjectRootCandidate(projectRoot);
        if (!resolvedRoot.has_value()) {
            StatusMessage_ = "该路径不是有效的 MetaCore 项目。";
            return false;
        }

        const std::string key = MetaCoreProjectRootKey(*resolvedRoot);
        auto iterator = std::find_if(Projects_.begin(), Projects_.end(), [&](const MetaCoreLauncherProjectRecord& record) {
            return MetaCoreProjectRootKey(record.Root) == key;
        });

        MetaCoreLauncherProjectRecord record;
        record.Root = *resolvedRoot;
        record.Name = MetaCoreReadProjectDisplayName(*resolvedRoot);
        record.LastOpened = MetaCoreNowIsoString();

        if (iterator != Projects_.end()) {
            *iterator = std::move(record);
            const auto index = static_cast<int>(std::distance(Projects_.begin(), iterator));
            SelectedIndex_ = index;
            std::rotate(Projects_.begin(), Projects_.begin() + index, Projects_.begin() + index + 1);
            SelectedIndex_ = 0;
        } else {
            Projects_.insert(Projects_.begin(), std::move(record));
            SelectedIndex_ = 0;
        }
        SaveState();
        return true;
    }

    void LaunchSelectedProject() {
        if (SelectedIndex_ < 0 || SelectedIndex_ >= static_cast<int>(Projects_.size())) {
            StatusMessage_ = "请先选择一个项目。";
            return;
        }

        auto& project = Projects_[static_cast<std::size_t>(SelectedIndex_)];
        const auto resolvedRoot = MetaCore::MetaCoreResolveProjectRootCandidate(project.Root);
        if (!resolvedRoot.has_value()) {
            StatusMessage_ = "项目文件夹缺失或无效。";
            return;
        }

        std::string error;
        if (!MetaCoreLaunchEditorForProject(*resolvedRoot, error, LauncherSetFilamentBackend_)) {
            StatusMessage_ = error;
            return;
        }

        project.Root = *resolvedRoot;
        project.Name = MetaCoreReadProjectDisplayName(*resolvedRoot);
        project.LastOpened = MetaCoreNowIsoString();
        SaveState();
        StatusMessage_ = "已启动编辑器：" + project.Name;
    }

    void RemoveSelectedProjectRecord() {
        if (SelectedIndex_ < 0 || SelectedIndex_ >= static_cast<int>(Projects_.size())) {
            StatusMessage_ = "请先选择一条项目记录。";
            return;
        }
        Projects_.erase(Projects_.begin() + SelectedIndex_);
        if (Projects_.empty()) {
            SelectedIndex_ = -1;
        } else if (SelectedIndex_ >= static_cast<int>(Projects_.size())) {
            SelectedIndex_ = static_cast<int>(Projects_.size()) - 1;
        }
        SaveState();
    }

    bool SetPathPickerDirectory(const std::filesystem::path& requestedPath) {
        std::filesystem::path directory = requestedPath;
        std::error_code errorCode;

        if (directory.filename() == "MetaCore.project.json" || std::filesystem::is_regular_file(directory, errorCode)) {
            directory = directory.parent_path();
        }

        errorCode.clear();
        if (!std::filesystem::exists(directory, errorCode) || !std::filesystem::is_directory(directory, errorCode)) {
            PathPickerError_ = "目录不存在或无法访问。";
            return false;
        }

        errorCode.clear();
        const std::filesystem::path canonicalDirectory = std::filesystem::weakly_canonical(directory, errorCode);
        PathPickerCurrentDirectory_ = !errorCode && !canonicalDirectory.empty()
            ? canonicalDirectory
            : directory.lexically_normal();
        MetaCoreCopyToBuffer(PathPickerPathBuffer_, PathPickerCurrentDirectory_.string());
        PathPickerSelectedPath_.clear();
        PathPickerError_.clear();
        return true;
    }

    void OpenPathPicker(MetaCoreLauncherPathPickerTarget target) {
        PathPickerTarget_ = target;
        PathPickerSelectedPath_.clear();
        PathPickerError_.clear();

        std::filesystem::path initialPath = target == MetaCoreLauncherPathPickerTarget::NewProjectParent
            ? std::filesystem::path(NewProjectParentBuffer_.data())
            : std::filesystem::path(AddExistingPathBuffer_.data());
        if (initialPath.empty()) {
            initialPath = std::filesystem::current_path();
        }

        if (!SetPathPickerDirectory(initialPath)) {
            PathPickerError_.clear();
            if (!SetPathPickerDirectory(std::filesystem::current_path())) {
                (void)SetPathPickerDirectory(MetaCoreGetHomeDirectory());
            }
        }
        OpenPathPickerPopup_ = true;
    }

    void ApplyPickedPath(const std::filesystem::path& pickedPath) {
        if (PathPickerTarget_ == MetaCoreLauncherPathPickerTarget::NewProjectParent) {
            MetaCoreCopyToBuffer(NewProjectParentBuffer_, pickedPath.string());
        } else {
            MetaCoreCopyToBuffer(AddExistingPathBuffer_, pickedPath.string());
        }
    }

    void DrawFrame() {
        const ImGuiViewport* viewport = ImGui::GetMainViewport();
        ImGui::SetNextWindowPos(viewport->Pos);
        ImGui::SetNextWindowSize(viewport->Size);
        ImGui::SetNextWindowViewport(viewport->ID);

        constexpr ImGuiWindowFlags rootFlags =
            ImGuiWindowFlags_NoDecoration |
            ImGuiWindowFlags_NoMove |
            ImGuiWindowFlags_NoResize |
            ImGuiWindowFlags_NoSavedSettings |
            ImGuiWindowFlags_NoBringToFrontOnFocus;

        ImGui::Begin("MetaCoreLauncherRoot", nullptr, rootFlags);
        DrawSidebar();
        ImGui::SameLine(0.0F, 0.0F);
        DrawProjectsPage();
        DrawNewProjectPopup();
        DrawAddExistingPopup();
        ImGui::End();
    }

    void DrawSidebar() {
        ImGui::PushStyleColor(ImGuiCol_ChildBg, ImVec4(0.078F, 0.078F, 0.078F, 1.0F));
        ImGui::BeginChild("Sidebar", ImVec2(220.0F, 0.0F), false, ImGuiWindowFlags_NoScrollbar);
        ImGui::SetCursorPos(ImVec2(20.0F, 24.0F));
        ImGui::TextUnformatted("MetaCore");
        ImGui::SetCursorPosX(20.0F);
        ImGui::TextDisabled("启动器");
        ImGui::Spacing();
        ImGui::Separator();
        ImGui::Spacing();
        ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.145F, 0.145F, 0.145F, 1.0F));
        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.16F, 0.16F, 0.16F, 1.0F));
        ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(0.18F, 0.18F, 0.18F, 1.0F));
        ImGui::SetCursorPosX(12.0F);
        if (ImGui::Button("项目", ImVec2(196.0F, 38.0F))) {
            StatusMessage_ = "当前页面：项目";
        }
        ImGui::PopStyleColor(3);
        ImGui::EndChild();
        ImGui::PopStyleColor();
    }

    void DrawProjectsPage() {
        ImGui::PushStyleColor(ImGuiCol_ChildBg, ImVec4(0.098F, 0.098F, 0.098F, 1.0F));
        ImGui::BeginChild("ProjectsPage", ImVec2(0.0F, 0.0F), false);
        ImGui::SetCursorPos(ImVec2(28.0F, 24.0F));
        ImGui::BeginGroup();

        constexpr float pageRightPadding = 28.0F;
        const float headerStartX = ImGui::GetCursorPosX();
        const float pageContentWidth = std::max(1.0F, ImGui::GetContentRegionAvail().x - pageRightPadding);
        const float headerButtonsWidth =
            112.0F + 112.0F + 76.0F + 112.0F + ImGui::GetStyle().ItemSpacing.x * 3.0F;
        ImGui::TextUnformatted("项目");
        ImGui::SameLine(headerStartX + std::max(0.0F, pageContentWidth - headerButtonsWidth));
        if (ImGui::Button("新建项目", ImVec2(112.0F, 36.0F))) {
            MetaCoreCopyToBuffer(NewProjectNameBuffer_, "新项目");
            if (NewProjectParentBuffer_[0] == '\0') {
                MetaCoreCopyToBuffer(NewProjectParentBuffer_, std::filesystem::current_path().string());
            }
            OpenNewProjectPopup_ = true;
        }
        ImGui::SameLine();
        if (ImGui::Button("添加已有", ImVec2(112.0F, 36.0F))) {
            MetaCoreCopyToBuffer(AddExistingPathBuffer_, std::filesystem::current_path().string());
            OpenAddExistingPopup_ = true;
        }
        ImGui::SameLine();
        if (ImGui::Button("启动", ImVec2(76.0F, 36.0F))) {
            LaunchSelectedProject();
        }
        ImGui::SameLine();
        if (ImGui::Button("移除记录", ImVec2(112.0F, 36.0F))) {
            RemoveSelectedProjectRecord();
        }

        ImGui::SetCursorPosX(headerStartX);
        ImGui::SetNextItemWidth(pageContentWidth);
        ImGui::InputTextWithHint("##SearchProjects", "搜索项目...", SearchBuffer_.data(), SearchBuffer_.size());

        if (!StatusMessage_.empty()) {
            ImGui::SetCursorPosX(headerStartX);
            ImGui::TextDisabled("%s", StatusMessage_.c_str());
        }

        ImGui::SetCursorPosX(headerStartX);
        ImGui::BeginChild("ProjectCards", ImVec2(pageContentWidth, 0.0F), false);
        DrawProjectCards();
        ImGui::EndChild();

        ImGui::EndGroup();
        ImGui::EndChild();
        ImGui::PopStyleColor();
    }

    void DrawProjectCards() {
        const std::string searchNeedle = MetaCoreToLower(SearchBuffer_.data());
        int visibleCount = 0;
        for (std::size_t index = 0; index < Projects_.size(); ++index) {
            const auto& project = Projects_[index];
            const std::string haystack = MetaCoreToLower(project.Name + " " + project.Root.string());
            if (!searchNeedle.empty() && haystack.find(searchNeedle) == std::string::npos) {
                continue;
            }

            ++visibleCount;
            const bool selected = SelectedIndex_ == static_cast<int>(index);
            const bool missing = !MetaCore::MetaCoreResolveProjectRootCandidate(project.Root).has_value();
            const ImVec4 cardColor = selected
                ? ImVec4(0.20F, 0.20F, 0.20F, 1.0F)
                : ImVec4(0.125F, 0.125F, 0.125F, 1.0F);
            ImGui::PushID(static_cast<int>(index));
            ImGui::PushStyleColor(ImGuiCol_ChildBg, cardColor);
            ImGui::PushStyleColor(ImGuiCol_Border, selected ? ImVec4(1.0F, 1.0F, 1.0F, 0.65F) : ImVec4(0.18F, 0.18F, 0.18F, 1.0F));
            ImGui::BeginChild("ProjectCard", ImVec2(0.0F, 96.0F), true, ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse);
            ImGui::SetCursorPos(ImVec2(14.0F, 12.0F));
            ImGui::BeginGroup();
            if (missing) {
                ImGui::TextDisabled("%s", project.Name.c_str());
            } else {
                ImGui::TextUnformatted(project.Name.c_str());
            }
            ImGui::TextDisabled("%s", project.Root.string().c_str());
            if (missing) {
                ImGui::TextColored(ImVec4(0.92F, 0.34F, 0.34F, 1.0F), "项目缺失");
            } else if (!project.LastOpened.empty()) {
                ImGui::TextDisabled("上次打开 %s", project.LastOpened.c_str());
            }
            ImGui::EndGroup();
            ImGui::EndChild();

            if (ImGui::IsItemHovered()) {
                if (ImGui::IsMouseClicked(ImGuiMouseButton_Left)) {
                    SelectedIndex_ = static_cast<int>(index);
                }
                if (!missing && ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left)) {
                    SelectedIndex_ = static_cast<int>(index);
                    LaunchSelectedProject();
                }
            }
            ImGui::PopStyleColor(2);
            ImGui::PopID();
        }

        if (visibleCount == 0) {
            ImGui::Dummy(ImVec2(1.0F, 48.0F));
            ImGui::TextDisabled("没有项目");
        }
    }

    void DrawNewProjectPopup() {
        if (OpenNewProjectPopup_) {
            ImGui::OpenPopup("新建项目");
            OpenNewProjectPopup_ = false;
        }
        ImGui::SetNextWindowSize(ImVec2(620.0F, 300.0F), ImGuiCond_Always);
        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(28.0F, 24.0F));
        if (ImGui::BeginPopupModal("新建项目", nullptr, ImGuiWindowFlags_NoResize)) {
            const float popupInputWidth = ImGui::GetContentRegionAvail().x;

            ImGui::TextUnformatted("项目名称");
            ImGui::SetNextItemWidth(popupInputWidth);
            ImGui::InputText("##NewProjectName", NewProjectNameBuffer_.data(), NewProjectNameBuffer_.size());
            ImGui::Spacing();
            ImGui::TextUnformatted("父目录");
            const float browseButtonWidth = 88.0F;
            ImGui::SetNextItemWidth(std::max(1.0F, popupInputWidth - browseButtonWidth - ImGui::GetStyle().ItemSpacing.x));
            ImGui::InputText("##NewProjectParent", NewProjectParentBuffer_.data(), NewProjectParentBuffer_.size());
            ImGui::SameLine();
            if (ImGui::Button("选择...", ImVec2(browseButtonWidth, 0.0F))) {
                OpenPathPicker(MetaCoreLauncherPathPickerTarget::NewProjectParent);
            }
            ImGui::Spacing();
            ImGui::Separator();
            ImGui::Spacing();

            ImGui::SetCursorPosX(std::max(28.0F, ImGui::GetWindowWidth() - 28.0F - 96.0F * 2.0F - ImGui::GetStyle().ItemSpacing.x));
            if (ImGui::Button("创建", ImVec2(96.0F, 32.0F))) {
                const std::string name = NewProjectNameBuffer_.data();
                const std::filesystem::path parent = NewProjectParentBuffer_.data();
                if (name.empty() || parent.empty()) {
                    StatusMessage_ = "项目名称和父目录不能为空。";
                } else {
                    const std::filesystem::path projectRoot = parent / name;
                    if (MetaCore::MetaCoreCreateProjectSkeleton(projectRoot, name)) {
                        if (UpsertProject(projectRoot)) {
                            StatusMessage_ = "已创建项目：" + name;
                            ImGui::CloseCurrentPopup();
                        }
                    } else {
                        StatusMessage_ = "创建项目失败。";
                    }
                }
            }
            ImGui::SameLine();
            if (ImGui::Button("取消", ImVec2(96.0F, 32.0F))) {
                ImGui::CloseCurrentPopup();
            }
            DrawPathPickerPopup();
            ImGui::EndPopup();
        }
        ImGui::PopStyleVar();
    }

    void DrawAddExistingPopup() {
        if (OpenAddExistingPopup_) {
            ImGui::OpenPopup("添加已有项目");
            OpenAddExistingPopup_ = false;
        }
        ImGui::SetNextWindowSize(ImVec2(620.0F, 240.0F), ImGuiCond_Always);
        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(28.0F, 24.0F));
        if (ImGui::BeginPopupModal("添加已有项目", nullptr, ImGuiWindowFlags_NoResize)) {
            const float popupInputWidth = ImGui::GetContentRegionAvail().x;

            ImGui::TextUnformatted("项目路径");
            const float browseButtonWidth = 88.0F;
            ImGui::SetNextItemWidth(std::max(1.0F, popupInputWidth - browseButtonWidth - ImGui::GetStyle().ItemSpacing.x));
            ImGui::InputText("##ExistingProjectPath", AddExistingPathBuffer_.data(), AddExistingPathBuffer_.size());
            ImGui::SameLine();
            if (ImGui::Button("选择...", ImVec2(browseButtonWidth, 0.0F))) {
                OpenPathPicker(MetaCoreLauncherPathPickerTarget::ExistingProject);
            }
            ImGui::Spacing();
            ImGui::Separator();
            ImGui::Spacing();

            ImGui::SetCursorPosX(std::max(28.0F, ImGui::GetWindowWidth() - 28.0F - 96.0F * 2.0F - ImGui::GetStyle().ItemSpacing.x));
            if (ImGui::Button("添加", ImVec2(96.0F, 32.0F))) {
                if (UpsertProject(std::filesystem::path(AddExistingPathBuffer_.data()))) {
                    StatusMessage_ = "已添加项目：" + Projects_[static_cast<std::size_t>(SelectedIndex_)].Name;
                    ImGui::CloseCurrentPopup();
                }
            }
            ImGui::SameLine();
            if (ImGui::Button("取消", ImVec2(96.0F, 32.0F))) {
                ImGui::CloseCurrentPopup();
            }
            DrawPathPickerPopup();
            ImGui::EndPopup();
        }
        ImGui::PopStyleVar();
    }

    void DrawPathPickerPopup() {
        if (OpenPathPickerPopup_) {
            ImGui::OpenPopup("选择路径");
            OpenPathPickerPopup_ = false;
        }

        ImGui::SetNextWindowSize(ImVec2(760.0F, 520.0F), ImGuiCond_Always);
        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(28.0F, 24.0F));
        if (ImGui::BeginPopupModal("选择路径", nullptr, ImGuiWindowFlags_NoResize)) {
            const bool pickingNewProjectParent = PathPickerTarget_ == MetaCoreLauncherPathPickerTarget::NewProjectParent;
            ImGui::TextUnformatted(pickingNewProjectParent ? "选择新项目父目录" : "选择已有项目");
            ImGui::TextDisabled(pickingNewProjectParent ? "选择项目将要创建到的父目录。" : "选择项目根目录，或选择 MetaCore.project.json。");
            ImGui::Spacing();

            const float popupWidth = ImGui::GetContentRegionAvail().x;
            const float actionButtonWidth = 76.0F;
            const float pathInputWidth = std::max(
                1.0F,
                popupWidth - actionButtonWidth * 3.0F - ImGui::GetStyle().ItemSpacing.x * 3.0F
            );
            ImGui::SetNextItemWidth(pathInputWidth);
            ImGui::InputText("##PathPickerPath", PathPickerPathBuffer_.data(), PathPickerPathBuffer_.size());
            ImGui::SameLine();
            if (ImGui::Button("前往", ImVec2(actionButtonWidth, 0.0F))) {
                (void)SetPathPickerDirectory(std::filesystem::path(PathPickerPathBuffer_.data()));
            }
            ImGui::SameLine();
            if (ImGui::Button("上一级", ImVec2(actionButtonWidth, 0.0F))) {
                const std::filesystem::path parentPath = PathPickerCurrentDirectory_.parent_path();
                if (!parentPath.empty() && parentPath != PathPickerCurrentDirectory_) {
                    (void)SetPathPickerDirectory(parentPath);
                }
            }
            ImGui::SameLine();
            if (ImGui::Button("主目录", ImVec2(actionButtonWidth, 0.0F))) {
                (void)SetPathPickerDirectory(MetaCoreGetHomeDirectory());
            }

            ImGui::Spacing();
            ImGui::TextDisabled("%s", PathPickerCurrentDirectory_.string().c_str());
            ImGui::Spacing();

            ImGui::BeginChild("PathPickerEntries", ImVec2(0.0F, 300.0F), true);
            const std::vector<MetaCoreLauncherPathPickerEntry> entries =
                MetaCoreCollectPathPickerEntries(PathPickerCurrentDirectory_, !pickingNewProjectParent);
            if (entries.empty()) {
                ImGui::TextDisabled("没有可选择的目录或项目文件。");
            }
            for (const auto& entry : entries) {
                const std::string label = entry.IsDirectory
                    ? std::string("[目录] ") + entry.Label
                    : std::string("[项目文件] ") + entry.Label;
                const bool selected = !PathPickerSelectedPath_.empty() && PathPickerSelectedPath_ == entry.Path;
                if (ImGui::Selectable(label.c_str(), selected)) {
                    PathPickerSelectedPath_ = entry.Path;
                }
                if (ImGui::IsItemHovered() && ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left)) {
                    if (entry.IsDirectory) {
                        (void)SetPathPickerDirectory(entry.Path);
                    } else {
                        ApplyPickedPath(entry.Path);
                        ImGui::CloseCurrentPopup();
                    }
                }
            }
            ImGui::EndChild();

            if (!PathPickerError_.empty()) {
                ImGui::TextColored(ImVec4(0.92F, 0.34F, 0.34F, 1.0F), "%s", PathPickerError_.c_str());
            } else if (!pickingNewProjectParent && std::filesystem::exists(PathPickerCurrentDirectory_ / "MetaCore.project.json")) {
                ImGui::TextDisabled("当前目录包含 MetaCore.project.json。");
            } else {
                ImGui::TextDisabled("双击目录进入，单击目录后可选择该目录。");
            }

            ImGui::Spacing();
            const float footerButtonWidth = 128.0F;
            ImGui::SetCursorPosX(std::max(
                28.0F,
                ImGui::GetWindowWidth() - 28.0F - footerButtonWidth * 2.0F - ImGui::GetStyle().ItemSpacing.x
            ));
            if (ImGui::Button(
                    PathPickerSelectedPath_.empty() ? "选择当前目录" : "选择选中项",
                    ImVec2(footerButtonWidth, 32.0F)
                )) {
                ApplyPickedPath(PathPickerSelectedPath_.empty() ? PathPickerCurrentDirectory_ : PathPickerSelectedPath_);
                ImGui::CloseCurrentPopup();
            }
            ImGui::SameLine();
            if (ImGui::Button("取消", ImVec2(footerButtonWidth, 32.0F))) {
                ImGui::CloseCurrentPopup();
            }
            ImGui::EndPopup();
        }
        ImGui::PopStyleVar();
    }

    MetaCore::MetaCoreWindow Window_{};
    MetaCore::MetaCoreRenderDevice RenderDevice_{};
    MetaCore::MetaCoreEditorViewportRenderer ViewportRenderer_{};
    std::vector<MetaCoreLauncherProjectRecord> Projects_{};
    std::array<char, 256> SearchBuffer_{};
    std::array<char, 128> NewProjectNameBuffer_{};
    std::array<char, 512> NewProjectParentBuffer_{};
    std::array<char, 512> AddExistingPathBuffer_{};
    std::array<char, 512> PathPickerPathBuffer_{};
    std::string StatusMessage_{};
    std::string PathPickerError_{};
    std::filesystem::path PathPickerCurrentDirectory_{};
    std::filesystem::path PathPickerSelectedPath_{};
    int SelectedIndex_ = -1;
    bool OpenNewProjectPopup_ = false;
    bool OpenAddExistingPopup_ = false;
    bool OpenPathPickerPopup_ = false;
    MetaCoreLauncherPathPickerTarget PathPickerTarget_ = MetaCoreLauncherPathPickerTarget::NewProjectParent;
    bool LauncherSetFilamentBackend_ = false;
    bool Initialized_ = false;
};

}  // namespace

int main() {
#if !defined(_WIN32)
    std::signal(SIGCHLD, SIG_IGN);
#endif

    MetaCoreLauncherApp app;
    if (!app.Initialize()) {
        std::cerr << "MetaCoreLauncher initialize failed\n";
        return 1;
    }
    return app.Run();
}