unified_layout.cc

Go to the documentation of this file.

#include "cli/tui/unified_layout.h"
 
#include <ftxui/component/component.hpp>
#include <ftxui/component/screen_interactive.hpp>
#include <ftxui/dom/elements.hpp>
#include <ftxui/screen/terminal.hpp>
#include <numeric>
#include <utility>
 
#include "absl/strings/str_format.h"
#include "cli/service/agent/conversational_agent_service.h"
#include "cli/z3ed_ascii_logo.h"
 
namespace yaze {
namespace cli {
 
using namespace ftxui;
 
UnifiedLayout::UnifiedLayout(Rom* rom_context) 
    : screen_(ScreenInteractive::TerminalOutput()),
      rom_context_(rom_context) {
  // Initialize chat TUI
  chat_tui_ = std::make_unique<tui::ChatTUI>(rom_context_);
  
  // Set default configuration
  config_ = LayoutConfig{};
  
  // Initialize state
  state_ = PanelState{};
  if (rom_context_) {
    state_.current_rom_file = rom_context_->title();
  }
 
  state_.active_workflows = {
      "ROM Audit",
      "Dungeon QA",
      "Palette Polish"
  };
  
  InitializeTheme();
 
  status_provider_ = [this] {
    auto rom_loaded = rom_context_ && rom_context_->is_loaded();
    return vbox({
        text(rom_loaded ? "✅ Ready" : "⚠ Awaiting ROM") |
            color(rom_loaded ? Color::GreenLight : Color::YellowLight),
        text(absl::StrFormat("Focus: %s",
                             state_.command_palette_hint.empty() ?
                                 "Main Menu" : state_.command_palette_hint)) |
            dim
    });
  };
 
  command_summary_provider_ = [] {
    return std::vector<std::string>{
        "agent::chat — conversational ROM inspector",
        "rom::info — metadata & validation",
        "dungeon::list — dungeon manifest",
        "gfx::export — sprite/palette dump",
        "project::build — apply patches"
    };
  };
 
  todo_provider_ = [] {
    return std::vector<std::string>{
        "[pending] Implement dungeon diff visualizer",
        "[pending] Integrate context panes",
        "[todo] Hook TODO manager into project manifests"
    };
  };
 
  // Create components
  main_menu_panel_ = CreateMainMenuPanel();
  chat_panel_ = CreateChatPanel();
  status_panel_ = CreateStatusPanel();
  tools_panel_ = CreateToolsPanel();
  hex_viewer_panel_ = CreateHexViewerPanel();
  palette_editor_panel_ = CreatePaletteEditorPanel();
  todo_manager_panel_ = CreateTodoManagerPanel();
  rom_tools_panel_ = CreateRomToolsPanel();
  graphics_tools_panel_ = CreateGraphicsToolsPanel();
  settings_panel_ = CreateSettingsPanel();
  help_panel_ = CreateHelpPanel();
  
  // Create layout
  unified_layout_ = CreateUnifiedLayout();
  
  // Set up event handlers
  global_event_handler_ = [this](const Event& event) {
    return HandleGlobalEvents(event);
  };
  
  panel_event_handler_ = [this](const Event& event) {
    return HandlePanelEvents(event);
  };
}
 
void UnifiedLayout::Run() {
  // Wrap the layout with event handling
  auto event_handler = CatchEvent(unified_layout_, global_event_handler_);
  
  screen_.Loop(event_handler);
}
 
void UnifiedLayout::SetRomContext(Rom* rom_context) {
  rom_context_ = rom_context;
  if (chat_tui_) {
    chat_tui_->SetRomContext(rom_context_);
  }
  
  if (rom_context_) {
    state_.current_rom_file = rom_context_->title();
  } else {
    state_.current_rom_file.clear();
  }
}
 
void UnifiedLayout::SwitchMainPanel(PanelType panel) {
  state_.active_main_panel = panel;
  screen_.PostEvent(Event::Custom);  // Force screen refresh
}
 
void UnifiedLayout::SwitchToolPanel(PanelType panel) {
  state_.active_tool_panel = panel;
  screen_.PostEvent(Event::Custom);  // Force screen refresh
}
 
void UnifiedLayout::ToggleChat() {
  config_.show_chat = !config_.show_chat;
  screen_.PostEvent(Event::Custom);  // Force screen refresh
}
 
void UnifiedLayout::ToggleStatus() {
  config_.show_status = !config_.show_status;
  screen_.PostEvent(Event::Custom);  // Force screen refresh
}
 
void UnifiedLayout::ToggleTodoOverlay() {
  todo_overlay_visible_ = !todo_overlay_visible_;
  if (todo_overlay_visible_) {
    if (!todo_overlay_component_ && todo_provider_) {
      todo_overlay_component_ = Renderer([this] {
        Elements rows;
        if (todo_provider_) {
          auto items = todo_provider_();
          if (items.empty()) {
            rows.push_back(text("No TODOs available") | dim | center);
          } else {
            for (const auto& line : items) {
              rows.push_back(text(line));
            }
          }
        }
        return dbox({window(text("📝 TODO Overlay") | bold,
                            vbox({
                                separatorLight(),
                                vbox(rows) | frame | size(HEIGHT, LESS_THAN, 15) | size(WIDTH, LESS_THAN, 80),
                                separatorLight(),
                                text("Ctrl+T to close • Enter to jump via command palette") | dim | center
                            })) | center});
      });
    }
    screen_.PostEvent(Event::Custom);
  } else {
    screen_.PostEvent(Event::Custom);
  }
}
 
void UnifiedLayout::SetLayoutConfig(const LayoutConfig& config) {
  config_ = config;
}
 
void UnifiedLayout::SetStatusProvider(std::function<Element()> provider) {
  status_provider_ = std::move(provider);
}
 
void UnifiedLayout::SetCommandSummaryProvider(std::function<std::vector<std::string>()> provider) {
  command_summary_provider_ = std::move(provider);
}
 
void UnifiedLayout::SetTodoProvider(std::function<std::vector<std::string>()> provider) {
  todo_provider_ = std::move(provider);
}
 
void UnifiedLayout::InitializeTheme() {
  auto terminal = Terminal::Size();
  if (terminal.dimx < 120) {
    config_.right_panel_width = 30;
    config_.bottom_panel_height = 12;
  }
}
 
Component UnifiedLayout::CreateMainMenuPanel() {
  struct MenuState {
    int selected = 0;
    std::vector<std::string> items = {
      "🔍 Hex Viewer",
      "🎨 Palette Editor",
      "📝 TODO Manager",
      "🔧 ROM Tools",
      "🎮 Graphics Tools",
      "⚙️ Settings",
      "❓ Help",
      "🚪 Exit"
    };
  };
  
  auto state = std::make_shared<MenuState>();
  
  MenuOption option;
  option.focused_entry = &state->selected;
  option.on_enter = [this, state] {
    switch (state->selected) {
      case 0: SwitchMainPanel(PanelType::kHexViewer); break;
      case 1: SwitchMainPanel(PanelType::kPaletteEditor); break;
      case 2: SwitchMainPanel(PanelType::kTodoManager); break;
      case 3: SwitchMainPanel(PanelType::kRomTools); break;
      case 4: SwitchMainPanel(PanelType::kGraphicsTools); break;
      case 5: SwitchMainPanel(PanelType::kSettings); break;
      case 6: SwitchMainPanel(PanelType::kHelp); break;
      case 7: screen_.Exit(); break;
    }
  };
  
  auto menu = Menu(&state->items, &state->selected, option);
  
  return Renderer(menu, [this, menu, state] {
    auto banner = RenderAnimatedBanner();
    return vbox({
      banner,
      separator(),
      menu->Render(),
      separator(),
      RenderCommandHints(),
      separator(),
      RenderWorkflowLane(),
      separator(),
      text("↑/↓: Navigate | Enter: Select | q: Quit") | dim | center
    }) | borderRounded | bgcolor(Color::Black);
  });
}
 
Component UnifiedLayout::CreateChatPanel() {
  // Use the full-featured ChatTUI if available
  if (chat_tui_) {
    return Renderer([this] {
      std::vector<Element> cards;
      cards.push_back(vbox({
          text("🤖 Overview") | bold,
          text("AI assistant for ROM editing"),
          text("Press 'f' for fullscreen chat") | dim
      }) | borderRounded);
 
      if (rom_context_) {
        cards.push_back(vbox({
            text("📦 ROM Context") | bold,
            text(rom_context_->title()),
            text(absl::StrFormat("Size: %d bytes", rom_context_->size())) | dim
        }) | borderRounded | color(Color::GreenLight));
      } else {
        cards.push_back(vbox({
            text("⚠ No ROM loaded") | color(Color::Yellow),
            text("Use Load ROM from main menu") | dim
        }) | borderRounded);
      }
 
      cards.push_back(vbox({
          text("🛠 Integrations") | bold,
          text("• TODO manager status") | dim,
          text("• Command palette shortcuts") | dim,
          text("• Tool dispatcher metrics") | dim
      }) | borderRounded);
 
      return vbox({
        RenderPanelHeader(PanelType::kChat),
        separator(),
        RenderResponsiveGrid(cards),
        separator(),
        text("Shortcuts: f fullscreen | c toggle chat | /help commands") | dim | center
      }) | borderRounded | bgcolor(Color::Black);
    });
  }
  
  // Fallback simple chat interface
  auto input_message = std::make_shared<std::string>();
  auto input_component = Input(input_message.get(), "Type your message...");
  
  auto send_button = Button("Send", [this, input_message] {
    if (input_message->empty()) return;
    
    // Handle chat commands
    if (*input_message == "/exit") {
      screen_.Exit();
      return;
    }
    
    input_message->clear();
  });
  
  // Handle Enter key
  input_component = CatchEvent(input_component, [this, input_message](const Event& event) {
    if (event == Event::Return) {
      if (input_message->empty()) return true;
      
      if (*input_message == "/exit") {
        screen_.Exit();
        return true;
      }
      
      input_message->clear();
      return true;
    }
    return false;
  });
  
  auto container = Container::Vertical({
    input_component,
    send_button
  });
  
  return Renderer(container, [this, container, input_component, send_button] {
    return vbox({
      text("🤖 AI Chat") | bold | center,
      separator(),
      text("Chat functionality integrated into unified layout") | center | dim,
      separator(),
      hbox({
        text("You: ") | bold,
        input_component->Render() | flex,
        text(" "),
        send_button->Render()
      }),
      separator(),
      text("Commands: /exit, /clear, /help") | dim | center
    });
  });
}
 
Component UnifiedLayout::CreateStatusPanel() {
  return Renderer([this] {
    Element rom_info = rom_context_ ?
        text(absl::StrFormat("ROM: %s", rom_context_->title())) | color(Color::GreenLight) :
        text("ROM: none") | color(Color::RedLight);
 
    Element provider_status = status_provider_ ? status_provider_() : text("Ready") | color(Color::GrayLight);
    auto command_tiles = RenderCommandHints();
    auto todo_tiles = RenderTodoStack();
 
    std::vector<Element> sections = {
        RenderAnimatedBanner(),
        separatorLight(),
        rom_info,
        separatorLight(),
        provider_status,
        separatorLight(),
        command_tiles,
        separatorLight(),
        todo_tiles
    };
 
    if (!state_.current_error.empty()) {
      sections.push_back(separatorLight());
      sections.push_back(text(state_.current_error) | color(Color::Red) | bold);
    }
 
    return vbox(sections) | borderRounded | bgcolor(Color::Black);
  });
}
 
Component UnifiedLayout::CreateToolsPanel() {
  struct ToolsState {
    int selected = 0;
    std::vector<std::string> items = {
      "🔧 ROM Tools (press t)",
      "🎨 Graphics Tools (ref gfx::export)", 
      "📝 TODO Manager (ref todo::list)",
      "⚙️ Settings",
      "❓ Help"
    };
  };
  
  auto state = std::make_shared<ToolsState>();
  MenuOption option;
  option.on_change = [this, state] {
    if (!state->items.empty()) {
      state_.command_palette_hint = state->items[state->selected];
    }
  };
  auto menu = Menu(&state->items, &state->selected, option);
  
  return Renderer(menu, [this, menu, state] {
    return vbox({
      RenderPanelHeader(PanelType::kTools),
      separator(),
      menu->Render(),
      separator(),
      text("Select a tool category") | dim | center,
      separator(),
      RenderCommandHints(),
      separator(),
      RenderWorkflowLane()
    }) | borderRounded | bgcolor(Color::Black);
  });
}
 
Component UnifiedLayout::CreateHexViewerPanel() {
  auto offset = std::make_shared<int>(0);
  const int lines_to_show = 20;
  
  return Renderer([this, offset, lines_to_show] {
    if (!rom_context_) {
      return vbox({
        text("🔍 Hex Viewer") | bold | center,
        separator(),
        text("No ROM loaded") | center | color(Color::Red),
        separator(),
        text("Load a ROM to view hex data") | center | dim
      }) | border;
    }
    
    std::vector<Element> rows;
    for (int i = 0; i < lines_to_show; ++i) {
      int current_offset = *offset + (i * 16);
      if (current_offset >= static_cast<int>(rom_context_->size())) {
        break;
      }
      
      Elements row;
      row.push_back(text(absl::StrFormat("0x%08X: ", current_offset)) | color(Color::Yellow));
      
      for (int j = 0; j < 16; ++j) {
        if (current_offset + j < static_cast<int>(rom_context_->size())) {
          row.push_back(text(absl::StrFormat("%02X ", rom_context_->vector()[current_offset + j])));
        } else {
          row.push_back(text("   "));
        }
      }
      
      row.push_back(separator());
      
      for (int j = 0; j < 16; ++j) {
        if (current_offset + j < static_cast<int>(rom_context_->size())) {
          char c = rom_context_->vector()[current_offset + j];
          row.push_back(text(std::isprint(c) ? std::string(1, c) : "."));
        } else {
          row.push_back(text(" "));
        }
      }
      
      rows.push_back(hbox(row));
    }
    
    auto workflow = RenderWorkflowLane();
 
    return vbox({
      text("🔍 Hex Viewer") | bold | center,
      separator(),
      workflow,
      separator(),
      vbox(rows) | frame | flex,
      separator(),
      text(absl::StrFormat("Offset: 0x%08X", *offset)) | color(Color::Cyan),
      separator(),
      text("↑/↓: Scroll | q: Back") | dim | center
    }) | borderRounded | bgcolor(Color::Black);
  });
}
 
Component UnifiedLayout::CreatePaletteEditorPanel() {
  return Renderer([this] {
    return vbox({
      RenderPanelHeader(PanelType::kPaletteEditor),
      separator(),
      RenderResponsiveGrid({
          vbox({
              text("🌈 Overview") | bold,
              text("Preview palette indices and colors"),
              text("Highlight sprite-specific palettes") | dim
          }) | borderRounded | bgcolor(Color::Black),
          vbox({
              text("🧪 Roadmap") | bold,
              text("• Live recolor with undo stack"),
              text("• Sprite preview viewport"),
              text("• Export to .pal/.act")
          }) | borderRounded | bgcolor(Color::Black),
          vbox({
              text("🗒 TODO") | bold,
              text("Link to command palette"),
              text("Use animation timeline"),
              text("Add palette history panel") | dim
          }) | borderRounded | bgcolor(Color::Black)
      }),
      separator(),
      RenderWorkflowLane(),
      separator(),
      text("Press 'q' to go back") | dim | center
    }) | borderRounded;
  });
}
 
Component UnifiedLayout::CreateTodoManagerPanel() {
  return Renderer([this] {
    std::vector<Element> todo_cards;
    if (todo_provider_) {
      for (const auto& item : todo_provider_()) {
        todo_cards.push_back(text("• " + item));
      }
    }
    if (todo_cards.empty()) {
      todo_cards.push_back(text("No TODOs yet") | dim);
    }
 
    return vbox({
      RenderPanelHeader(PanelType::kTodoManager),
      separator(),
      vbox(todo_cards) | borderRounded | bgcolor(Color::Black),
      separator(),
      text("Press Ctrl+T anywhere to toggle the popup todo overlay.") | dim,
      separator(),
      RenderWorkflowLane(),
      separator(),
      text("Press 'q' to go back") | dim | center
    }) | borderRounded;
  });
}
 
Component UnifiedLayout::CreateRomToolsPanel() {
  struct ToolsState {
    int selected = 0;
    std::vector<std::string> items = {
      "Apply Asar Patch — todo#123",
      "Apply BPS Patch — todo#124", 
      "Extract Symbols — todo#098",
      "Validate Assembly — todo#087",
      "Generate Save File — todo#142",
      "Back"
    };
  };
  
  auto state = std::make_shared<ToolsState>();
  auto menu = Menu(&state->items, &state->selected);
  
  return Renderer(menu, [this, menu, state] {
    return vbox({
      text("🔧 ROM Tools") | bold | center,
      separator(),
      menu->Render(),
      separator(),
      text("Select a ROM tool") | dim | center
    }) | border;
  });
}
 
Component UnifiedLayout::CreateGraphicsToolsPanel() {
  struct ToolsState {
    int selected = 0;
    std::vector<std::string> items = {
      "Palette Editor — ref gfx::export",
      "Hex Viewer — ref rom::hex",
      "Back"
    };
  };
  
  auto state = std::make_shared<ToolsState>();
  auto menu = Menu(&state->items, &state->selected);
  
  return Renderer(menu, [this, menu, state] {
    return vbox({
      text("🎨 Graphics Tools") | bold | center,
      separator(),
      menu->Render(),
      separator(),
      text("Select a graphics tool") | dim | center
    }) | border;
  });
}
 
Component UnifiedLayout::CreateSettingsPanel() {
  struct SettingsState {
    int left_width_slider;
    int right_width_slider;
    int bottom_height_slider;
  };
  
  auto state = std::make_shared<SettingsState>();
  state->left_width_slider = config_.left_panel_width;
  state->right_width_slider = config_.right_panel_width;
  state->bottom_height_slider = config_.bottom_panel_height;
  
  auto left_width_control = Slider("Left Panel Width: ", &state->left_width_slider, 20, 60, 1);
  auto right_width_control = Slider("Right Panel Width: ", &state->right_width_slider, 30, 60, 1);
  auto bottom_height_control = Slider("Bottom Panel Height: ", &state->bottom_height_slider, 10, 30, 1);
  
  auto apply_button = Button("Apply Changes", [this, state] {
    config_.left_panel_width = state->left_width_slider;
    config_.right_panel_width = state->right_width_slider;
    config_.bottom_panel_height = state->bottom_height_slider;
    screen_.PostEvent(Event::Custom);
  });
  
  auto reset_button = Button("Reset to Defaults", [this, state] {
    state->left_width_slider = 30;
    state->right_width_slider = 40;
    state->bottom_height_slider = 15;
    config_.left_panel_width = 30;
    config_.right_panel_width = 40;
    config_.bottom_panel_height = 15;
    screen_.PostEvent(Event::Custom);
  });
  
  auto controls = Container::Vertical({
    left_width_control,
    right_width_control,
    bottom_height_control,
    Container::Horizontal({
      apply_button,
      reset_button
    })
  });
  
  return Renderer(controls, [this, controls, state, left_width_control, right_width_control, 
                              bottom_height_control, apply_button, reset_button] {
    return vbox({
      RenderPanelHeader(PanelType::kSettings) | color(Color::Cyan),
      separator(),
      text("Customize the TUI layout") | center | dim,
      separator(),
      hbox({
        text("Left Panel Width: ") | bold,
        text(absl::StrFormat("%d", state->left_width_slider))
      }),
      left_width_control->Render(),
      separator(),
      hbox({
        text("Right Panel Width: ") | bold,
        text(absl::StrFormat("%d", state->right_width_slider))
      }),
      right_width_control->Render(),
      separator(),
      hbox({
        text("Bottom Panel Height: ") | bold,
        text(absl::StrFormat("%d", state->bottom_height_slider))
      }),
      bottom_height_control->Render(),
      separator(),
      hbox({
        apply_button->Render(),
        text("  "),
        reset_button->Render()
      }) | center,
      separator(),
      text("Panel Visibility:") | bold,
      hbox({
        text("Chat: ") | bold,
        text(config_.show_chat ? "ON ✓" : "OFF ✗") | 
          color(config_.show_chat ? Color::Green : Color::Red),
        text("  "),
        text("Status: ") | bold,
        text(config_.show_status ? "ON ✓" : "OFF ✗") | 
          color(config_.show_status ? Color::Green : Color::Red)
      }) | center,
      separator(),
      text("Keyboard Shortcuts:") | bold,
      text("  c - Toggle chat panel") | dim,
      text("  s - Toggle status panel") | dim,
      text("  Esc/b - Back to menu") | dim,
      separator(),
      text("Changes apply immediately") | center | dim
    });
  });
}
 
Component UnifiedLayout::CreateHelpPanel() {
  return Renderer([this] {
    return vbox({
      RenderPanelHeader(PanelType::kHelp) | color(Color::Cyan),
      separator(),
      text("Unified TUI Layout - ROM Editor & AI Agent") | center | dim,
      separator(),
      text("Global Shortcuts:") | bold | color(Color::Yellow),
      text("  q       - Quit application"),
      text("  h       - Show this help"),
      text("  m       - Main menu"),
      text("  Esc/b   - Back to previous panel"),
      separator(),
      text("Panel Controls:") | bold | color(Color::Yellow),
      text("  c       - Toggle chat panel"),
      text("  s       - Toggle status panel"),
      text("  f       - Open full chat interface"),
      text("  t       - ROM tools"),
      separator(),
      text("Navigation:") | bold | color(Color::Yellow),
      text("  ↑/↓     - Navigate menus"),
      text("  Enter   - Select item"),
      text("  Tab     - Switch focus"),
      separator(),
      text("Chat Commands:") | bold | color(Color::Yellow),
      text("  /exit   - Exit chat"),
      text("  /clear  - Clear history"),
      text("  /help   - Show chat help"),
      separator(),
      text("Available Tools:") | bold | color(Color::Green),
      text("  • Hex Viewer - Inspect ROM data"),
      text("  • Palette Editor - Edit color palettes"),
      text("  • TODO Manager - Track tasks"),
      text("  • AI Chat - Natural language ROM queries"),
      text("  • Dungeon Tools - Room inspection & editing"),
      text("  • Graphics Tools - Sprite & tile editing"),
      separator(),
      text("Press 'Esc' or 'b' to go back") | dim | center
    });
  });
}
 
Component UnifiedLayout::CreateUnifiedLayout() {
  // Create a container that holds all panels
  auto all_panels = Container::Tab({
    main_menu_panel_,
    chat_panel_,
    status_panel_,
    tools_panel_,
    hex_viewer_panel_,
    palette_editor_panel_,
    todo_manager_panel_,
    rom_tools_panel_,
    graphics_tools_panel_,
    settings_panel_,
    help_panel_
  }, nullptr);
  
  // Create a renderer that dynamically shows the right panels based on state
  return Renderer(all_panels, [this, all_panels] {
    // Dynamically select left panel based on current state
    Component left_panel;
    switch (state_.active_main_panel) {
      case PanelType::kMainMenu:
        left_panel = main_menu_panel_;
        break;
      case PanelType::kHexViewer:
        left_panel = hex_viewer_panel_;
        break;
      case PanelType::kPaletteEditor:
        left_panel = palette_editor_panel_;
        break;
      case PanelType::kTodoManager:
        left_panel = todo_manager_panel_;
        break;
      case PanelType::kRomTools:
        left_panel = rom_tools_panel_;
        break;
      case PanelType::kGraphicsTools:
        left_panel = graphics_tools_panel_;
        break;
      case PanelType::kSettings:
        left_panel = settings_panel_;
        break;
      case PanelType::kHelp:
        left_panel = help_panel_;
        break;
      default:
        left_panel = main_menu_panel_;
        break;
    }
    
    // Dynamically select right panel
    Component right_panel;
    if (config_.show_status) {
      right_panel = status_panel_;
    } else {
      right_panel = tools_panel_;
    }
    
    // Create horizontal layout
    auto top_section = hbox({
      left_panel->Render() | flex,
      separatorLight(),
      right_panel->Render() | size(WIDTH, LESS_THAN, config_.right_panel_width)
    });
    
    // Add chat panel if enabled
    if (config_.show_chat) {
      Element stacked = vbox({
          top_section | flex,
          separatorLight(),
          chat_panel_->Render() | size(HEIGHT, EQUAL, config_.bottom_panel_height)
        }) | bgcolor(Color::Black);
 
      if (todo_overlay_visible_ && todo_overlay_component_) {
        stacked = dbox({stacked, todo_overlay_component_->Render()});
      }
      return stacked;
    }
 
    Element content = top_section | bgcolor(Color::Black);
    if (todo_overlay_visible_ && todo_overlay_component_) {
      content = dbox({content, todo_overlay_component_->Render()});
    }
    return content;
  });
}
 
 
bool UnifiedLayout::HandleGlobalEvents(const Event& event) {
  // Back to main menu
  if (event == Event::Escape || event == Event::Character('b')) {
    if (state_.active_main_panel != PanelType::kMainMenu) {
      SwitchMainPanel(PanelType::kMainMenu);
      return true;
    }
  }
  
  // Global shortcuts
  if (event == Event::Special({20})) {  // Ctrl+T
    ToggleTodoOverlay();
    return true;
  }
 
  if (event == Event::Character('q') || 
      (event == Event::Character('q') && state_.active_main_panel == PanelType::kMainMenu)) {
    screen_.Exit();
    return true;
  }
  
  if (event == Event::Character('h')) {
    SwitchMainPanel(PanelType::kHelp);
    return true;
  }
  
  if (event == Event::Character('c')) {
    ToggleChat();
    return true;
  }
  
  if (event == Event::Character('s')) {
    ToggleStatus();
    return true;
  }
  
  if (event == Event::Character('t')) {
    SwitchMainPanel(PanelType::kRomTools);
    return true;
  }
  
  if (event == Event::Character('m')) {
    SwitchMainPanel(PanelType::kMainMenu);
    return true;
  }
  
  if (event == Event::Character('f')) {
    // Launch full chat interface
    if (chat_tui_) {
      screen_.ExitLoopClosure()();  // Exit current loop
      chat_tui_->Run();  // Run full chat
      screen_.PostEvent(Event::Custom);  // Refresh when we return
    }
    return true;
  }
  
  return false;
}
 
bool UnifiedLayout::HandlePanelEvents(const Event& /* event */) {
  // Panel-specific event handling
  return false;
}
 
Element UnifiedLayout::RenderPanelHeader(PanelType panel) {
  std::string title;
  switch (panel) {
    case PanelType::kMainMenu:
      title = "🎮 Main Menu";
      break;
    case PanelType::kChat:
      title = "🤖 AI Chat";
      break;
    case PanelType::kStatus:
      title = "📊 Status";
      break;
    case PanelType::kTools:
      title = "🛠️ Tools";
      break;
    case PanelType::kHexViewer:
      title = "🔍 Hex Viewer";
      break;
    case PanelType::kPaletteEditor:
      title = "🎨 Palette Editor";
      break;
    case PanelType::kTodoManager:
      title = "📝 TODO Manager";
      break;
    case PanelType::kRomTools:
      title = "🔧 ROM Tools";
      break;
    case PanelType::kGraphicsTools:
      title = "🎨 Graphics Tools";
      break;
    case PanelType::kSettings:
      title = "⚙️ Settings";
      break;
    case PanelType::kHelp:
      title = "❓ Help";
      break;
  }
  
  return text(title) | bold | center;
}
 
Element UnifiedLayout::RenderStatusBar() {
  return hbox({
    text(absl::StrFormat("Panel: %s", 
      state_.active_main_panel == PanelType::kMainMenu ? "Main" : "Other")) | color(Color::Cyan),
    filler(),
    text(absl::StrFormat("ROM: %s", 
      state_.current_rom_file.empty() ? "None" : state_.current_rom_file)) | color(Color::Green),
    filler(),
    text("Shortcuts: Ctrl+T TODO Overlay | f Full Chat | m Main Menu") | dim
  });
}
 
Element UnifiedLayout::RenderAnimatedBanner() {
  return text("🎮 Z3ED CLI") | bold | center;
}
 
Element UnifiedLayout::RenderWorkflowLane() {
  return text("Workflow: Active") | color(Color::Green);
}
 
Element UnifiedLayout::RenderCommandHints() {
  return vbox({
    text("Command Hints:") | bold,
    text("  Ctrl+T - Toggle TODO overlay"),
    text("  f - Full chat mode"),
    text("  m - Main menu")
  });
}
 
Element UnifiedLayout::RenderTodoStack() {
  return text("TODO Stack: Empty") | dim;
}
 
Element UnifiedLayout::RenderResponsiveGrid(const std::vector<Element>& tiles) {
  if (tiles.empty()) {
    return text("No items") | center | dim;
  }
  return vbox(tiles);
}
 
}  // namespace cli
}  // namespace yaze