#include "Commands/EditorHostCommandBridge.h"

#include <string>
#include <utility>

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

void EditorHostCommandBridge::BindSession(EditorSession& session) {
    m_session = &session;
}

void EditorHostCommandBridge::BindCommandFocusService(
    const EditorCommandFocusService& commandFocusService) {
    m_commandFocusService = &commandFocusService;
}

void EditorHostCommandBridge::BindEditCommandRoutes(
    EditorEditCommandRoute* hierarchyRoute,
    EditorEditCommandRoute* projectRoute,
    EditorEditCommandRoute* sceneRoute,
    EditorEditCommandRoute* inspectorRoute) {
    m_hierarchyRoute = hierarchyRoute;
    m_projectRoute = projectRoute;
    m_sceneRoute = sceneRoute;
    m_inspectorRoute = inspectorRoute;
}

void EditorHostCommandBridge::SetExitRequestHandler(std::function<void()> handler) {
    m_requestExit = std::move(handler);
}

UIEditorHostCommandEvaluationResult EditorHostCommandBridge::EvaluateHostCommand(
    std::string_view commandId) const {
    if (commandId == "file.exit") {
        return BuildExecutableResult("Exit editor.");
    }

    if (commandId == "help.about") {
        return BuildDisabledResult("About dialog is unavailable in the current shell.");
    }

    if (commandId.rfind("edit.", 0u) == 0u) {
        return EvaluateEditCommand(commandId);
    }

    if (commandId.rfind("assets.", 0u) == 0u) {
        return EvaluateAssetCommand(commandId);
    }

    return EvaluateUnsupportedHostCommand(commandId);
}

UIEditorHostCommandDispatchResult EditorHostCommandBridge::DispatchHostCommand(
    std::string_view commandId) {
    UIEditorHostCommandDispatchResult result = {};

    if (commandId == "file.exit") {
        result.commandExecuted = true;
        result.message = "Exit requested.";
        if (m_requestExit) {
            m_requestExit();
        }
        return result;
    }

    if (commandId == "help.about") {
        result.message = EvaluateHostCommand(commandId).message;
        return result;
    }

    if (commandId.rfind("edit.", 0u) == 0u) {
        return DispatchEditCommand(commandId);
    }

    if (commandId.rfind("assets.", 0u) == 0u) {
        return DispatchAssetCommand(commandId);
    }

    result.message = EvaluateHostCommand(commandId).message;
    return result;
}

UIEditorHostCommandEvaluationResult EditorHostCommandBridge::BuildDisabledResult(
    std::string_view message) const {
    UIEditorHostCommandEvaluationResult result = {};
    result.executable = false;
    result.message = std::string(message);
    return result;
}

UIEditorHostCommandEvaluationResult EditorHostCommandBridge::BuildExecutableResult(
    std::string_view message) const {
    UIEditorHostCommandEvaluationResult result = {};
    result.executable = true;
    result.message = std::string(message);
    return result;
}

UIEditorHostCommandEvaluationResult EditorHostCommandBridge::EvaluateFileCommand(
    std::string_view commandId) const {
    if (commandId == "file.exit") {
        return BuildExecutableResult("Exit editor.");
    }

    return BuildDisabledResult(
        "Only file.exit has a bound host owner in the current shell.");
}

UIEditorHostCommandEvaluationResult EditorHostCommandBridge::EvaluateAssetCommand(
    std::string_view commandId) const {
    if (m_projectRoute == nullptr) {
        return BuildDisabledResult("Project command route is unavailable in the current window.");
    }

    return m_projectRoute->EvaluateAssetCommand(commandId);
}

UIEditorHostCommandEvaluationResult EditorHostCommandBridge::EvaluateRunCommand(
    std::string_view commandId) const {
    (void)commandId;
    return BuildDisabledResult(
        "Run commands have no bound play-mode owner in the current shell.");
}

UIEditorHostCommandEvaluationResult EditorHostCommandBridge::EvaluateScriptCommand(
    std::string_view commandId) const {
    (void)commandId;
    return BuildDisabledResult(
        "Script commands have no bound script-pipeline owner in the current shell.");
}

UIEditorHostCommandEvaluationResult EditorHostCommandBridge::EvaluateEditCommand(
    std::string_view commandId) const {
    if (m_session == nullptr) {
        return BuildDisabledResult("Editor session is unavailable.");
    }

    const EditorActionRoute route = ResolveActiveEditRoute();
    if (route == EditorActionRoute::None) {
        return BuildDisabledResult("No active edit route.");
    }

    EditorEditCommandRoute* editRoute = ResolveEditCommandRoute(route);
    if (editRoute == nullptr) {
        switch (route) {
        case EditorActionRoute::Hierarchy:
            return BuildDisabledResult("Hierarchy command route is unavailable in the current window.");
        case EditorActionRoute::Project:
            return BuildDisabledResult("Project command route is unavailable in the current window.");
        case EditorActionRoute::Inspector:
            return BuildDisabledResult("Inspector command route is unavailable in the current window.");
        case EditorActionRoute::Console:
            return BuildDisabledResult("Console does not expose edit commands yet.");
        case EditorActionRoute::Scene:
            return BuildDisabledResult("Scene command route is unavailable in the current window.");
        case EditorActionRoute::Game:
            return BuildDisabledResult("Viewport panels do not expose edit commands yet.");
        case EditorActionRoute::None:
        default:
            return BuildDisabledResult("Current panel does not expose edit commands.");
        }
    }

    return editRoute->EvaluateEditCommand(commandId);
}

UIEditorHostCommandDispatchResult EditorHostCommandBridge::DispatchEditCommand(
    std::string_view commandId) {
    UIEditorHostCommandDispatchResult result = {};
    const UIEditorHostCommandEvaluationResult evaluation = EvaluateEditCommand(commandId);
    if (!evaluation.executable) {
        result.message = evaluation.message;
        return result;
    }

    EditorEditCommandRoute* route = ResolveEditCommandRoute(ResolveActiveEditRoute());
    if (route == nullptr) {
        result.message = "Edit command route is unavailable.";
        return result;
    }

    return route->DispatchEditCommand(commandId);
}

UIEditorHostCommandDispatchResult EditorHostCommandBridge::DispatchAssetCommand(
    std::string_view commandId) {
    UIEditorHostCommandDispatchResult result = {};
    const UIEditorHostCommandEvaluationResult evaluation = EvaluateAssetCommand(commandId);
    if (!evaluation.executable) {
        result.message = evaluation.message;
        return result;
    }

    if (m_projectRoute == nullptr) {
        result.message = "Project command route is unavailable.";
        return result;
    }

    return m_projectRoute->DispatchAssetCommand(commandId);
}

UIEditorHostCommandEvaluationResult EditorHostCommandBridge::EvaluateUnsupportedHostCommand(
    std::string_view commandId) const {
    if (commandId.rfind("file.", 0u) == 0u) {
        return EvaluateFileCommand(commandId);
    }

    if (commandId.rfind("assets.", 0u) == 0u) {
        return EvaluateAssetCommand(commandId);
    }

    if (commandId.rfind("run.", 0u) == 0u) {
        return EvaluateRunCommand(commandId);
    }

    if (commandId.rfind("scripts.", 0u) == 0u) {
        return EvaluateScriptCommand(commandId);
    }

    return BuildDisabledResult("Host command has no owner in the current shell.");
}

EditorActionRoute EditorHostCommandBridge::ResolveActiveEditRoute() const {
    if (m_session == nullptr) {
        return EditorActionRoute::None;
    }

    const EditorActionRoute fallbackRoute =
        ResolveEditorActionRoute(m_session->activePanelId);
    if (m_commandFocusService != nullptr) {
        return m_commandFocusService->ResolveRoute(fallbackRoute);
    }

    return m_session->activeRoute != EditorActionRoute::None
        ? m_session->activeRoute
        : fallbackRoute;
}

EditorEditCommandRoute* EditorHostCommandBridge::ResolveEditCommandRoute(
    EditorActionRoute route) const {
    switch (route) {
    case EditorActionRoute::Hierarchy:
        return m_hierarchyRoute;
    case EditorActionRoute::Project:
        return m_projectRoute;
    case EditorActionRoute::Inspector:
        return m_inspectorRoute;
    case EditorActionRoute::Scene:
        return m_sceneRoute;
    default:
        return nullptr;
    }
}

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