command_palette.cc

Go to the documentation of this file.

#include "cli/tui/command_palette.h"
 
#include <algorithm>
#include <ftxui/component/component.hpp>
#include <ftxui/component/screen_interactive.hpp>
#include <ftxui/dom/elements.hpp>
 
#include "cli/tui/tui.h"
// #include "cli/handlers/graphics/hex_commands.h"
// #include "cli/handlers/graphics/palette_commands.h"
 
namespace yaze {
namespace cli {
 
using namespace ftxui;
 
namespace {
// A simple fuzzy search implementation
int fuzzy_match(const std::string& query, const std::string& target) {
  if (query.empty())
    return 1;
  if (target.empty())
    return 0;
 
  int score = 0;
  int query_idx = 0;
  int target_idx = 0;
  int consecutive_matches = 0;
 
  while (query_idx < query.length() && target_idx < target.length()) {
    if (std::tolower(query[query_idx]) == std::tolower(target[target_idx])) {
      score += 1 + consecutive_matches;
      consecutive_matches++;
      query_idx++;
    } else {
      consecutive_matches = 0;
    }
    target_idx++;
  }
 
  return (query_idx == query.length()) ? score : 0;
}
}  // namespace
 
Component CommandPaletteComponent::Render() {
  struct PaletteState {
    std::string query;
    int selected = 0;
    std::string status_msg;
  };
 
  struct Cmd {
    std::string name;
    std::string cat;
    std::string desc;
    std::string usage;
    std::function<absl::Status()> exec;
    int score = 0;
  };
 
  auto state = std::make_shared<PaletteState>();
 
  static std::vector<Cmd> cmds = {
      {"hex-read", "🔢 Hex", "Read ROM bytes",
       "--address=0x1C800 --length=16 --format=both",
       []() {
         return absl::OkStatus();
       }},
 
      {"hex-write", "🔢 Hex", "Write ROM bytes",
       "--address=0x1C800 --data=\"FF 00\"",
       []() {
         return absl::OkStatus();
       }},
 
      {"hex-search", "🔢 Hex", "Search byte pattern",
       "--pattern=\"FF 00 ?? 12\"",
       []() {
         return absl::OkStatus();
       }},
 
      {"palette-get", "🎨 Palette", "Get palette colors",
       "--group=0 --palette=0 --format=hex",
       []() {
         return absl::OkStatus();
       }},
 
      {"palette-set", "🎨 Palette", "Set palette color",
       "--group=0 --palette=0 --index=5 --color=FF0000",
       []() {
         return absl::OkStatus();
       }},
 
      {"palette-analyze", "🎨 Palette", "Analyze palette",
       "--type=palette --id=0/0",
       []() {
         return absl::OkStatus();
       }},
  };
 
  auto search_input = Input(&state->query, "Search commands...");
 
  auto menu = Renderer([state] {
    std::vector<int> filtered_idx;
    if (state->query.empty()) {
      for (size_t i = 0; i < cmds.size(); ++i) {
        filtered_idx.push_back(i);
      }
    } else {
      for (size_t i = 0; i < cmds.size(); ++i) {
        cmds[i].score = fuzzy_match(state->query, cmds[i].name);
        if (cmds[i].score > 0) {
          filtered_idx.push_back(i);
        }
      }
      std::sort(filtered_idx.begin(), filtered_idx.end(),
                [](int a, int b) { return cmds[a].score > cmds[b].score; });
    }
    Elements items;
    for (size_t i = 0; i < filtered_idx.size(); ++i) {
      int idx = filtered_idx[i];
      auto item = hbox({
          text(cmds[idx].cat) | color(Color::GrayLight),
          text(" "),
          text(cmds[idx].name) | bold,
      });
      if (static_cast<int>(i) == state->selected) {
        item = item | inverted | focus;
      }
      items.push_back(item);
    }
    return vbox(items) | vscroll_indicator | frame;
  });
 
  auto execute_command = [state] {
    std::vector<int> filtered_idx;
    if (state->query.empty()) {
      for (size_t i = 0; i < cmds.size(); ++i) {
        filtered_idx.push_back(i);
      }
    } else {
      for (size_t i = 0; i < cmds.size(); ++i) {
        cmds[i].score = fuzzy_match(state->query, cmds[i].name);
        if (cmds[i].score > 0) {
          filtered_idx.push_back(i);
        }
      }
      std::sort(filtered_idx.begin(), filtered_idx.end(),
                [](int a, int b) { return cmds[a].score > cmds[b].score; });
    }
 
    if (state->selected < static_cast<int>(filtered_idx.size())) {
      int cmd_idx = filtered_idx[state->selected];
      auto status = cmds[cmd_idx].exec();
      state->status_msg = status.ok()
                              ? "✓ Success: Command executed."
                              : "✗ Error: " + std::string(status.message().data(), status.message().size());
    }
  };
 
  auto back_btn = Button("Back", [] {
    app_context.current_layout = LayoutID::kMainMenu;
    ScreenInteractive::Active()->ExitLoopClosure()();
  });
 
  auto container = Container::Vertical({search_input, menu, back_btn});
 
  return Renderer(
             container,
             [container, search_input, menu, back_btn, state] {
               std::vector<int> filtered_idx;
               if (state->query.empty()) {
                 for (size_t i = 0; i < cmds.size(); ++i) {
                   filtered_idx.push_back(i);
                 }
               } else {
                 for (size_t i = 0; i < cmds.size(); ++i) {
                   cmds[i].score = fuzzy_match(state->query, cmds[i].name);
                   if (cmds[i].score > 0) {
                     filtered_idx.push_back(i);
                   }
                 }
                 std::sort(filtered_idx.begin(), filtered_idx.end(),
                           [](int a, int b) {
                             return cmds[a].score > cmds[b].score;
                           });
               }
 
               Element details = text("Select a command to see details.") | dim;
               if (state->selected < static_cast<int>(filtered_idx.size())) {
                 int idx = filtered_idx[state->selected];
                 details = vbox({
                     text(cmds[idx].desc) | bold,
                     separator(),
                     text("Usage: " + cmds[idx].name + " " + cmds[idx].usage) |
                         color(Color::Cyan),
                 });
               }
 
               return vbox({
                          text("⚡ Command Palette") | bold | center |
                              color(Color::Cyan),
                          text(app_context.rom.is_loaded()
                                   ? "ROM: " + app_context.rom.title()
                                   : "No ROM loaded") |
                              center | dim,
                          separator(),
                          hbox({text("🔍 "), search_input->Render() | flex}),
                          separator(),
                          hbox({
                              menu->Render() | flex,
                              separator(),
                              details | flex,
                          }),
                          separator(),
                          hbox({back_btn->Render()}) | center,
                          separator(),
                          text(state->status_msg) | center |
                              (state->status_msg.find("✓") != 0
                                   ? color(Color::Green)
                                   : color(Color::Red)),
                          text("↑↓: Navigate | Enter: Execute | Esc: Back") |
                              center | dim,
                      }) |
                      border | flex;
             }) |
         CatchEvent([state, execute_command](const Event& e) {
           if (e == Event::Return) {
             execute_command();
             return true;
           }
           if (e == Event::ArrowUp) {
             if (state->selected > 0)
               state->selected--;
             return true;
           }
           if (e == Event::ArrowDown) {
             // Calculate filtered_idx size
             std::vector<int> filtered_idx;
             if (state->query.empty()) {
               for (size_t i = 0; i < cmds.size(); ++i) {
                 filtered_idx.push_back(i);
               }
             } else {
               for (size_t i = 0; i < cmds.size(); ++i) {
                 cmds[i].score = fuzzy_match(state->query, cmds[i].name);
                 if (cmds[i].score > 0) {
                   filtered_idx.push_back(i);
                 }
               }
             }
             if (state->selected < static_cast<int>(filtered_idx.size()) - 1)
               state->selected++;
             return true;
           }
           return false;
         });
}
 
}  // namespace cli
}  // namespace yaze