#include "Workspace/ProductEditorWorkspaceEventRouter.h"

#include "Core/ProductEditorContext.h"
#include "Panels/ProductHierarchyPanel.h"
#include "Panels/ProductProjectPanel.h"
#include "Workspace/ProductEditorWorkspace.h"

#include <sstream>
#include <utility>

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

namespace {

std::string DescribeProjectPanelEvent(const ProductProjectPanel::Event& event) {
    std::ostringstream stream = {};
    switch (event.kind) {
    case ProductProjectPanel::EventKind::AssetSelected:
        stream << "AssetSelected";
        break;
    case ProductProjectPanel::EventKind::AssetSelectionCleared:
        stream << "AssetSelectionCleared";
        break;
    case ProductProjectPanel::EventKind::FolderNavigated:
        stream << "FolderNavigated";
        break;
    case ProductProjectPanel::EventKind::AssetOpened:
        stream << "AssetOpened";
        break;
    case ProductProjectPanel::EventKind::ContextMenuRequested:
        stream << "ContextMenuRequested";
        break;
    case ProductProjectPanel::EventKind::None:
    default:
        stream << "None";
        break;
    }

    stream << " source=";
    switch (event.source) {
    case ProductProjectPanel::EventSource::Tree:
        stream << "Tree";
        break;
    case ProductProjectPanel::EventSource::Breadcrumb:
        stream << "Breadcrumb";
        break;
    case ProductProjectPanel::EventSource::GridPrimary:
        stream << "GridPrimary";
        break;
    case ProductProjectPanel::EventSource::GridDoubleClick:
        stream << "GridDoubleClick";
        break;
    case ProductProjectPanel::EventSource::GridSecondary:
        stream << "GridSecondary";
        break;
    case ProductProjectPanel::EventSource::Background:
        stream << "Background";
        break;
    case ProductProjectPanel::EventSource::None:
    default:
        stream << "None";
        break;
    }

    if (!event.itemId.empty()) {
        stream << " item=" << event.itemId;
    }
    if (!event.displayName.empty()) {
        stream << " label=" << event.displayName;
    }
    return stream.str();
}

std::string DescribeHierarchyPanelEvent(const ProductHierarchyPanel::Event& event) {
    std::ostringstream stream = {};
    switch (event.kind) {
    case ProductHierarchyPanel::EventKind::SelectionChanged:
        stream << "SelectionChanged";
        break;
    case ProductHierarchyPanel::EventKind::Reparented:
        stream << "Reparented";
        break;
    case ProductHierarchyPanel::EventKind::MovedToRoot:
        stream << "MovedToRoot";
        break;
    case ProductHierarchyPanel::EventKind::RenameRequested:
        stream << "RenameRequested";
        break;
    case ProductHierarchyPanel::EventKind::None:
    default:
        stream << "None";
        break;
    }

    if (!event.itemId.empty()) {
        stream << " item=" << event.itemId;
    }
    if (!event.targetItemId.empty()) {
        stream << " target=" << event.targetItemId;
    }
    if (!event.label.empty()) {
        stream << " label=" << event.label;
    }
    return stream.str();
}

void ApplyHierarchySelection(
    ProductEditorContext& context,
    const ProductHierarchyPanel::Event& event) {
    if (event.kind != ProductHierarchyPanel::EventKind::SelectionChanged) {
        return;
    }

    if (event.itemId.empty()) {
        context.ClearSelection();
        return;
    }

    ProductEditorSelectionState selection = {};
    selection.kind = ProductEditorSelectionKind::HierarchyNode;
    selection.itemId = event.itemId;
    selection.displayName = event.label.empty() ? event.itemId : event.label;
    context.SetSelection(std::move(selection));
}

void ApplyProjectSelection(
    ProductEditorContext& context,
    const ProductProjectPanel::Event& event) {
    switch (event.kind) {
    case ProductProjectPanel::EventKind::AssetSelected: {
        ProductEditorSelectionState selection = {};
        selection.kind = ProductEditorSelectionKind::ProjectItem;
        selection.itemId = event.itemId;
        selection.displayName = event.displayName.empty() ? event.itemId : event.displayName;
        selection.absolutePath = event.absolutePath;
        selection.directory = event.directory;
        context.SetSelection(std::move(selection));
        return;
    }
    case ProductProjectPanel::EventKind::AssetSelectionCleared:
    case ProductProjectPanel::EventKind::FolderNavigated:
        if (context.GetSession().selection.kind == ProductEditorSelectionKind::ProjectItem) {
            context.ClearSelection();
        }
        return;
    case ProductProjectPanel::EventKind::AssetOpened:
    case ProductProjectPanel::EventKind::ContextMenuRequested:
    case ProductProjectPanel::EventKind::None:
    default:
        return;
    }
}

} // namespace

std::vector<ProductEditorWorkspaceTraceEntry> ConsumeProductEditorWorkspaceEvents(
    ProductEditorContext& context,
    const ProductEditorWorkspace& workspace) {
    std::vector<ProductEditorWorkspaceTraceEntry> entries = {};

    for (const ProductHierarchyPanel::Event& event : workspace.GetHierarchyPanelEvents()) {
        ApplyHierarchySelection(context, event);
        const std::string message = DescribeHierarchyPanelEvent(event);
        context.SetStatus("Hierarchy", message);
        entries.push_back(ProductEditorWorkspaceTraceEntry{ "hierarchy", std::move(message) });
    }

    for (const ProductProjectPanel::Event& event : workspace.GetProjectPanelEvents()) {
        ApplyProjectSelection(context, event);
        const std::string message = DescribeProjectPanelEvent(event);
        context.SetStatus("Project", message);
        entries.push_back(ProductEditorWorkspaceTraceEntry{ "project", std::move(message) });
    }

    return entries;
}

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