command_context.cc

Go to the documentation of this file.

#include "cli/service/resources/command_context.h"
 
#include <filesystem>
#include <fstream>
#include <iostream>
 
#include "absl/flags/declare.h"
#include "absl/flags/flag.h"
#include "absl/strings/ascii.h"
#include "absl/strings/match.h"
#include "absl/strings/str_format.h"
#include "absl/strings/str_join.h"
#include "cli/handlers/rom/mock_rom.h"
#include "cli/util/hex_util.h"
#include "core/project.h"
#include "zelda3/dungeon/draw_routines/draw_routine_registry.h"
#include "zelda3/resource_labels.h"
#include "zelda3/zelda3_labels.h"
 
using yaze::cli::util::ParseHexString;
 
ABSL_DECLARE_FLAG(std::string, rom);
ABSL_DECLARE_FLAG(bool, mock_rom);
 
namespace yaze {
namespace cli {
namespace resources {
 
namespace {
 
constexpr int kTrackCustomObjectId = 0x31;
 
bool ProjectUsesCustomObjects(const project::YazeProject& project) {
  return !project.custom_objects_folder.empty() ||
         !project.custom_object_files.empty();
}
 
bool SeedLegacyTrackObjectMapping(project::YazeProject* project,
                                  std::string* warning) {
  if (project == nullptr) {
    return false;
  }
  if (project->custom_objects_folder.empty()) {
    return false;
  }
  if (project->custom_object_files.find(kTrackCustomObjectId) !=
      project->custom_object_files.end()) {
    return false;
  }
 
  const auto& defaults =
      zelda3::CustomObjectManager::DefaultSubtypeFilenamesForObject(
          kTrackCustomObjectId);
  if (defaults.empty()) {
    return false;
  }
 
  project->custom_object_files[kTrackCustomObjectId] = defaults;
  if (warning != nullptr) {
    *warning = absl::StrFormat(
        "project context defines custom_objects_folder but is missing "
        "custom_object_files[0x%02X]. Seeded default mapping (%d entries); "
        "save project to persist.",
        kTrackCustomObjectId, static_cast<int>(defaults.size()));
  }
  return true;
}
 
}  // namespace
 
// ============================================================================
// CommandContext Implementation
// ============================================================================
 
CommandContext::CommandContext(const Config& config) : config_(config) {}
 
CommandContext::~CommandContext() {
  RestoreProjectRuntimeContext();
}
 
absl::Status CommandContext::Initialize() {
  if (initialized_) {
    return absl::OkStatus();
  }
 
  // Determine ROM source
  std::string rom_path = config_.rom_path.has_value()
                             ? *config_.rom_path
                             : absl::GetFlag(FLAGS_rom);
 
  if (config_.external_rom_context != nullptr &&
      config_.external_rom_context->is_loaded()) {
    active_rom_ = config_.external_rom_context;
  } else if (config_.use_mock_rom) {
    auto status = cli::InitializeMockRom(rom_storage_);
    if (!status.ok()) {
      return status;
    }
    active_rom_ = &rom_storage_;
  } else if (!rom_path.empty()) {
    auto status = rom_storage_.LoadFromFile(rom_path);
    if (!status.ok()) {
      return absl::FailedPreconditionError(absl::StrFormat(
          "Failed to load ROM from '%s': %s", rom_path, status.message()));
    }
    active_rom_ = &rom_storage_;
  }
 
  if (active_rom_ == nullptr) {
    return absl::FailedPreconditionError(
        "No ROM loaded. Use --rom=<path> or --mock-rom for testing.");
  }
 
  auto project_status = ApplyProjectRuntimeContext();
  if (!project_status.ok()) {
    return project_status;
  }
 
  // Auto-load symbols if available
  std::string symbols_path =
      config_.symbols_path.has_value() ? *config_.symbols_path : "";
  if (symbols_path.empty() && !rom_path.empty()) {
    // Try ROM name with .mlb or .sym
    std::string base = rom_path;
    size_t last_dot = base.find_last_of('.');
    if (last_dot != std::string::npos) {
      base = base.substr(0, last_dot);
    }
 
    // Try common extensions
    std::vector<std::string> exts = {".mlb", ".sfc.mlb", ".sym", ".cpu.sym",
                                     "sourcemap.json"};
    for (const auto& ext : exts) {
      std::string path = base + ext;
      if (std::ifstream(path).good()) {
        auto sym_status = symbol_provider_.LoadSymbolFile(path);
        if (sym_status.ok() && symbol_provider_.HasSymbols()) {
          symbols_path = path;
          break;
        }
      }
    }
  } else if (!symbols_path.empty()) {
    auto sym_status = symbol_provider_.LoadSymbolFile(symbols_path);
    if (!sym_status.ok() && config_.verbose) {
      std::cerr << "Warning: Failed to load symbols from " << symbols_path
                << ": " << sym_status.message() << std::endl;
    }
  }
 
  initialized_ = true;
  return absl::OkStatus();
}
 
absl::StatusOr<Rom*> CommandContext::GetRom() {
  if (!initialized_) {
    auto status = Initialize();
    if (!status.ok()) {
      return status;
    }
  }
 
  if (active_rom_ == nullptr) {
    return absl::FailedPreconditionError("ROM not loaded");
  }
 
  return active_rom_;
}
 
emu::debug::SymbolProvider* CommandContext::GetSymbolProvider() {
  if (!initialized_) {
    Initialize().IgnoreError();
  }
  return &symbol_provider_;
}
 
absl::Status CommandContext::EnsureLabelsLoaded(Rom* rom) {
  if (!rom->resource_label()) {
    return absl::FailedPreconditionError("ROM has no resource label manager");
  }
 
  if (!rom->resource_label()->labels_loaded_ ||
      rom->resource_label()->labels_.empty()) {
    project::YazeProject project;
    project.use_embedded_labels = true;
    auto labels_status = project.InitializeEmbeddedLabels(
        zelda3::Zelda3Labels::ToResourceLabels());
    if (labels_status.ok()) {
      rom->resource_label()->labels_ = project.resource_labels;
      rom->resource_label()->labels_loaded_ = true;
    } else {
      return labels_status;
    }
  }
 
  return absl::OkStatus();
}
 
absl::Status CommandContext::ApplyProjectRuntimeContext() {
  if (project_runtime_applied_) {
    return absl::OkStatus();
  }
  if (!config_.project_context_path.has_value()) {
    return absl::OkStatus();
  }
  if (config_.project_context_path->empty()) {
    return absl::InvalidArgumentError("--project-context cannot be empty");
  }
 
  project::YazeProject project;
  auto open_status = project.Open(*config_.project_context_path);
  if (!open_status.ok()) {
    return absl::FailedPreconditionError(
        absl::StrFormat("Failed to open project context '%s': %s",
                        *config_.project_context_path, open_status.message()));
  }
 
  // Keep editor parity by auto-enabling custom objects when project config
  // defines custom object data but stale feature flags are still disabled.
  if (ProjectUsesCustomObjects(project) &&
      !project.feature_flags.kEnableCustomObjects) {
    project.feature_flags.kEnableCustomObjects = true;
    if (config_.verbose) {
      std::cerr
          << "Warning: project context has custom object data but "
             "kEnableCustomObjects was disabled. Enabling for this command.\n";
    }
  }
  std::string legacy_mapping_warning;
  if (SeedLegacyTrackObjectMapping(&project, &legacy_mapping_warning) &&
      config_.verbose) {
    std::cerr << "Warning: " << legacy_mapping_warning << '\n';
  }
 
  loaded_project_ = std::move(project);
  previous_feature_flags_ = core::FeatureFlags::get();
  previous_custom_object_state_ =
      zelda3::CustomObjectManager::Get().SnapshotState();
 
  auto& active_project = loaded_project_.value();
  // Open() bound the label provider to the moved-from local above.
  zelda3::GetResourceLabels().SetHackManifest(
      active_project.hack_manifest.loaded() ? &active_project.hack_manifest
                                            : nullptr);
  core::FeatureFlags::get() = active_project.feature_flags;
  zelda3::DrawRoutineRegistry::Get().RefreshFeatureFlagMappings();
 
  if (!active_project.custom_object_files.empty()) {
    zelda3::CustomObjectManager::Get().SetObjectFileMap(
        active_project.custom_object_files);
  } else {
    zelda3::CustomObjectManager::Get().ClearObjectFileMap();
  }
 
  if (!active_project.custom_objects_folder.empty()) {
    zelda3::CustomObjectManager::Get().Initialize(
        active_project.GetAbsolutePath(active_project.custom_objects_folder));
  } else {
    // Avoid inheriting a stale base path from a previous singleton state.
    zelda3::CustomObjectManager::Get().Initialize("");
  }
 
  zelda3::CustomObjectManager::Get().SetTilePatternsSource(
      active_project.dungeon_tile_patterns.empty()
          ? ""
          : active_project.GetAbsolutePath(
                active_project.dungeon_tile_patterns));
  project_runtime_applied_ = true;
  // Do not render a partial preview when an explicitly configured source is
  // invalid. Restore immediately so a retry cannot skip the failed load.
  const auto patterns = zelda3::CustomObjectManager::Get().GetTilePatterns();
  if (!patterns.ok()) {
    RestoreProjectRuntimeContext();
    return patterns.status();
  }
  return absl::OkStatus();
}
 
void CommandContext::RestoreProjectRuntimeContext() {
  if (!project_runtime_applied_) {
    return;
  }
 
  if (previous_custom_object_state_.has_value()) {
    zelda3::CustomObjectManager::Get().RestoreState(
        *previous_custom_object_state_);
  }
 
  if (previous_feature_flags_.has_value()) {
    core::FeatureFlags::get() = *previous_feature_flags_;
    zelda3::DrawRoutineRegistry::Get().RefreshFeatureFlagMappings();
  }
 
  previous_custom_object_state_.reset();
  previous_feature_flags_.reset();
  loaded_project_.reset();
  project_runtime_applied_ = false;
}
 
// ============================================================================
// ArgumentParser Implementation
// ============================================================================
 
ArgumentParser::ArgumentParser(const std::vector<std::string>& args)
    : args_(args) {}
 
std::optional<std::string> ArgumentParser::FindArgValue(
    const std::string& name) const {
  std::string flag = "--" + name;
  std::string equals_form = flag + "=";
 
  for (size_t i = 0; i < args_.size(); ++i) {
    const std::string& arg = args_[i];
 
    // Check for --name=value form
    if (absl::StartsWith(arg, equals_form)) {
      return arg.substr(equals_form.length());
    }
 
    // Check for --name value form
    if (arg == flag && i + 1 < args_.size()) {
      return args_[i + 1];
    }
  }
 
  return std::nullopt;
}
 
std::optional<std::string> ArgumentParser::GetString(
    const std::string& name) const {
  return FindArgValue(name);
}
 
absl::StatusOr<int> ArgumentParser::GetInt(const std::string& name) const {
  auto value = FindArgValue(name);
  if (!value.has_value()) {
    return absl::NotFoundError(
        absl::StrFormat("Argument '--%s' not found", name));
  }
 
  // Try hex first (with 0x prefix)
  if (absl::StartsWith(*value, "0x") || absl::StartsWith(*value, "0X")) {
    int result;
    if (ParseHexString(value->substr(2), &result)) {
      return result;
    }
    return absl::InvalidArgumentError(
        absl::StrFormat("Invalid hex integer for '--%s': %s", name, *value));
  }
 
  // Try decimal
  int result;
  if (absl::SimpleAtoi(*value, &result)) {
    return result;
  }
 
  return absl::InvalidArgumentError(
      absl::StrFormat("Invalid integer for '--%s': %s", name, *value));
}
 
absl::StatusOr<int> ArgumentParser::GetHex(const std::string& name) const {
  auto value = FindArgValue(name);
  if (!value.has_value()) {
    return absl::NotFoundError(
        absl::StrFormat("Argument '--%s' not found", name));
  }
 
  // Strip 0x prefix if present
  std::string hex_str = *value;
  if (absl::StartsWith(hex_str, "0x") || absl::StartsWith(hex_str, "0X")) {
    hex_str = hex_str.substr(2);
  }
 
  int result;
  if (ParseHexString(hex_str, &result)) {
    return result;
  }
 
  return absl::InvalidArgumentError(
      absl::StrFormat("Invalid hex value for '--%s': %s", name, *value));
}
 
bool ArgumentParser::HasFlag(const std::string& name) const {
  std::string flag = "--" + name;
  for (const auto& arg : args_) {
    if (arg == flag) {
      return true;
    }
  }
  return false;
}
 
std::vector<std::string> ArgumentParser::GetPositional() const {
  std::vector<std::string> positional;
  for (size_t i = 0; i < args_.size(); ++i) {
    const std::string& arg = args_[i];
    if (!absl::StartsWith(arg, "--")) {
      positional.push_back(arg);
    } else if (arg.find('=') == std::string::npos && i + 1 < args_.size()) {
      // Skip the next argument as it's the value for this flag
      ++i;
    }
  }
  return positional;
}
 
absl::Status ArgumentParser::RequireArgs(
    const std::vector<std::string>& required) const {
  std::vector<std::string> missing;
  for (const auto& arg : required) {
    if (!FindArgValue(arg).has_value()) {
      missing.push_back("--" + arg);
    }
  }
 
  if (!missing.empty()) {
    return absl::InvalidArgumentError(absl::StrFormat(
        "Missing required arguments: %s", absl::StrJoin(missing, ", ")));
  }
 
  return absl::OkStatus();
}
 
// ============================================================================
// OutputFormatter Implementation
// ============================================================================
 
absl::StatusOr<OutputFormatter> OutputFormatter::FromString(
    const std::string& format) {
  std::string lower = absl::AsciiStrToLower(format);
  if (lower == "json") {
    return OutputFormatter(Format::kJson);
  } else if (lower == "text" || lower == "table") {
    // "table" is text output; commands that support it print aligned rows.
    return OutputFormatter(Format::kText);
  } else {
    return absl::InvalidArgumentError(absl::StrFormat(
        "Unknown format: %s (expected 'json', 'text' or 'table')", format));
  }
}
 
void OutputFormatter::BeginObject(const std::string& title) {
  if (IsJson()) {
    if (!json_stack_.empty()) {
      if (json_stack_.back().type == JsonContext::Type::kArray) {
        AddJsonValueSeparator();
      } else {
        AddJsonFieldPrefix(title);
      }
    } else {
      AddIndent();
    }
    buffer_ += "{\n";
    indent_level_++;
    json_stack_.push_back({JsonContext::Type::kObject});
  } else if (IsText() && !title.empty()) {
    buffer_ += absl::StrFormat("=== %s ===\n", title);
  }
}
 
void OutputFormatter::EndObject() {
  if (IsJson()) {
    if (json_stack_.empty()) {
      return;
    }
    const bool empty = json_stack_.back().first;
    json_stack_.pop_back();
    indent_level_--;
    if (empty) {
      if (!buffer_.empty() && buffer_.back() == '\n') {
        buffer_.pop_back();
      }
      buffer_ += "}";
      return;
    }
    buffer_ += "\n";
    AddIndent();
    buffer_ += "}";
  }
}
 
void OutputFormatter::AddField(const std::string& key,
                               const std::string& value) {
  if (IsJson()) {
    AddJsonFieldPrefix(key);
    buffer_ += absl::StrFormat("\"%s\"", EscapeJson(value));
  } else {
    buffer_ += absl::StrFormat("  %-20s : %s\n", key, value);
  }
}
 
void OutputFormatter::AddField(const std::string& key, const char* value) {
  AddField(key, value != nullptr ? std::string(value) : std::string());
}
 
void OutputFormatter::AddField(const std::string& key, int value) {
  if (IsJson()) {
    AddJsonFieldPrefix(key);
    buffer_ += absl::StrFormat("%d", value);
  } else {
    buffer_ += absl::StrFormat("  %-20s : %d\n", key, value);
  }
}
 
void OutputFormatter::AddField(const std::string& key, uint64_t value) {
  if (IsJson()) {
    AddJsonFieldPrefix(key);
    buffer_ += absl::StrFormat("%llu", value);
  } else {
    buffer_ += absl::StrFormat("  %-20s : %llu\n", key, value);
  }
}
 
void OutputFormatter::AddField(const std::string& key, bool value) {
  if (IsJson()) {
    AddJsonFieldPrefix(key);
    buffer_ += value ? "true" : "false";
  } else {
    buffer_ += absl::StrFormat("  %-20s : %s\n", key, value ? "yes" : "no");
  }
}
 
void OutputFormatter::AddHexField(const std::string& key, uint64_t value,
                                  int width) {
  if (IsJson()) {
    AddJsonFieldPrefix(key);
    buffer_ += absl::StrFormat("\"0x%0*X\"", width, value);
  } else {
    buffer_ += absl::StrFormat("  %-20s : 0x%0*X\n", key, width, value);
  }
}
 
void OutputFormatter::BeginArray(const std::string& key) {
  if (IsJson()) {
    if (!json_stack_.empty()) {
      if (json_stack_.back().type == JsonContext::Type::kArray) {
        AddJsonValueSeparator();
      } else {
        AddJsonFieldPrefix(key);
      }
    } else {
      AddIndent();
    }
    buffer_ += "[\n";
    indent_level_++;
    json_stack_.push_back({JsonContext::Type::kArray});
  } else {
    buffer_ += absl::StrFormat("  %s:\n", key);
  }
}
 
void OutputFormatter::EndArray() {
  if (IsJson()) {
    if (json_stack_.empty()) {
      return;
    }
    const int item_count = json_stack_.back().item_count;
    json_stack_.pop_back();
    indent_level_--;
    if (item_count == 0) {
      if (!buffer_.empty() && buffer_.back() == '\n') {
        buffer_.pop_back();
      }
      buffer_ += "]";
    } else {
      buffer_ += "\n";
      AddIndent();
      buffer_ += "]";
    }
  }
}
 
void OutputFormatter::AddArrayItem(const std::string& item) {
  if (IsJson()) {
    AddJsonValueSeparator();
    buffer_ += absl::StrFormat("\"%s\"", EscapeJson(item));
  } else {
    buffer_ += absl::StrFormat("    - %s\n", item);
  }
}
 
void OutputFormatter::AddRawJsonField(const std::string& key,
                                      const std::string& json) {
  if (!IsJson()) {
    return;
  }
  AddJsonFieldPrefix(key);
  buffer_ += json;
}
 
void OutputFormatter::AddRawText(const std::string& text) {
  if (IsText()) {
    buffer_ += text;
  }
}
 
std::string OutputFormatter::GetOutput() const {
  return buffer_;
}
 
void OutputFormatter::Print() const {
  std::cout << buffer_;
  if (IsJson()) {
    std::cout << "\n";
  }
}
 
void OutputFormatter::AddIndent() {
  for (int i = 0; i < indent_level_; ++i) {
    buffer_ += "  ";
  }
}
 
void OutputFormatter::AddJsonValueSeparator() {
  if (json_stack_.empty()) {
    return;
  }
  auto& context = json_stack_.back();
  if (context.type == JsonContext::Type::kArray) {
    if (context.item_count > 0) {
      buffer_ += ",\n";
    }
    AddIndent();
    ++context.item_count;
  }
}
 
void OutputFormatter::AddJsonFieldPrefix(const std::string& key) {
  if (!json_stack_.empty()) {
    auto& context = json_stack_.back();
    if (context.type == JsonContext::Type::kObject) {
      if (!context.first) {
        buffer_ += ",\n";
      }
      context.first = false;
    }
  }
  AddIndent();
  buffer_ += absl::StrFormat("\"%s\": ", EscapeJson(key));
}
 
std::string OutputFormatter::EscapeJson(const std::string& str) const {
  std::string result;
  result.reserve(str.size() + 10);
 
  for (char c : str) {
    switch (c) {
      case '"':
        result += "\\\"";
        break;
      case '\\':
        result += "\\\\";
        break;
      case '\b':
        result += "\\b";
        break;
      case '\f':
        result += "\\f";
        break;
      case '\n':
        result += "\\n";
        break;
      case '\r':
        result += "\\r";
        break;
      case '\t':
        result += "\\t";
        break;
      default:
        if (static_cast<unsigned char>(c) < 0x20) {
          result += absl::StrFormat("\\u%04x", static_cast<int>(c));
        } else {
          result += c;
        }
    }
  }
 
  return result;
}
 
}  // namespace resources
}  // namespace cli
}  // namespace yaze