project_management_panel.cc

Go to the documentation of this file.

#include "app/editor/shell/windows/project_management_panel.h"
#include "util/i18n/tr.h"
 
#include <algorithm>
 
#include "absl/strings/str_format.h"
#include "app/editor/shell/feedback/toast_manager.h"
#include "app/gui/core/icons.h"
#include "app/gui/core/style_guard.h"
#include "app/gui/core/theme_manager.h"
#include "app/gui/core/ui_helpers.h"
#include "imgui/imgui.h"
#include "rom/rom.h"
#include "util/platform_paths.h"
#include "yaze_config.h"
 
namespace yaze {
namespace editor {
 
namespace {
 
template <size_t N>
void CopyToBuffer(std::array<char, N>* buffer, const std::string& value) {
  buffer->fill('\0');
  const size_t length = std::min(value.size(), N - 1);
  std::copy_n(value.data(), length, buffer->data());
}
 
ImVec4 WorkflowColor(ProjectWorkflowState state) {
  switch (state) {
    case ProjectWorkflowState::kRunning:
      return ImVec4(0.45f, 0.70f, 0.95f, 1.0f);
    case ProjectWorkflowState::kSuccess:
      return ImVec4(0.35f, 0.80f, 0.45f, 1.0f);
    case ProjectWorkflowState::kFailure:
      return ImVec4(0.90f, 0.35f, 0.35f, 1.0f);
    case ProjectWorkflowState::kIdle:
    default:
      return gui::GetTextSecondaryVec4();
  }
}
 
const char* WorkflowIcon(ProjectWorkflowState state, const char* fallback) {
  switch (state) {
    case ProjectWorkflowState::kRunning:
      return ICON_MD_SYNC;
    case ProjectWorkflowState::kSuccess:
      return ICON_MD_CHECK_CIRCLE;
    case ProjectWorkflowState::kFailure:
      return ICON_MD_ERROR;
    case ProjectWorkflowState::kIdle:
    default:
      return fallback;
  }
}
 
void DrawWorkflowCard(const ProjectWorkflowStatus& status,
                      const char* fallback_icon) {
  if (!status.visible) {
    return;
  }
 
  gui::ColoredTextF(
      WorkflowColor(status.state), "%s %s",
      WorkflowIcon(status.state, fallback_icon),
      status.summary.empty() ? status.label.c_str() : status.summary.c_str());
  if (!status.detail.empty()) {
    ImGui::TextWrapped("%s", status.detail.c_str());
  }
  if (!status.output_tail.empty()) {
    ImGui::TextWrapped("%s", status.output_tail.c_str());
  }
}
 
}  // namespace
 
void ProjectManagementPanel::SetProject(project::YazeProject* project,
                                        bool dirty) {
  project_ = project;
  project_dirty_ = dirty;
  history_cache_.clear();
  history_dirty_ = true;
  ReloadProjectBuffers();
}
 
void ProjectManagementPanel::ReloadProjectBuffers() {
  if (!project_) {
    name_buffer_.fill('\0');
    author_buffer_.fill('\0');
    description_buffer_.fill('\0');
    code_buffer_.fill('\0');
    assets_buffer_.fill('\0');
    build_buffer_.fill('\0');
    script_buffer_.fill('\0');
    return;
  }
 
  CopyToBuffer(&name_buffer_, project_->name);
  CopyToBuffer(&author_buffer_, project_->metadata.author);
  CopyToBuffer(&description_buffer_, project_->metadata.description);
  CopyToBuffer(&code_buffer_, project_->code_folder);
  CopyToBuffer(&assets_buffer_, project_->assets_folder);
  CopyToBuffer(&build_buffer_, project_->build_target);
  CopyToBuffer(&script_buffer_, project_->build_script);
}
 
absl::Status ProjectManagementPanel::SaveProjectEdits() {
  if (!save_project_callback_) {
    return absl::FailedPreconditionError("Project save callback unavailable");
  }
  auto status = save_project_callback_();
  if (status.ok()) {
    project_dirty_ = false;
  }
  return status;
}
 
void ProjectManagementPanel::Draw() {
  if (!project_) {
    ImGui::TextDisabled(tr("No project loaded"));
    ImGui::Spacing();
    ImGui::TextWrapped(
        tr("Open a .yaze project file or create a new project to access "
           "project management features."));
    return;
  }
 
  DrawProjectOverview();
  ImGui::Separator();
  DrawStorageLocations();
  ImGui::Separator();
  DrawRomManagement();
  ImGui::Separator();
  DrawVersionControl();
  ImGui::Separator();
  DrawQuickActions();
}
 
void ProjectManagementPanel::DrawProjectOverview() {
  // Section header
  gui::ColoredTextF(gui::GetPrimaryVec4(), "%s Project",
                    ICON_MD_FOLDER_SPECIAL);
  ImGui::Spacing();
 
  ImGui::TextColored(gui::GetTextSecondaryVec4(), tr("Project Format:"));
  ImGui::SameLine();
  ImGui::Text("%s", project_->format == project::ProjectFormat::kYazeNative
                        ? ".yaze"
                        : ".zsproj");
 
  ImGui::TextColored(gui::GetTextSecondaryVec4(), tr("Project YAZE Version:"));
  ImGui::SameLine();
  const std::string& project_version = project_->metadata.yaze_version;
  if (project_version.empty()) {
    const auto& theme = gui::ThemeManager::Get().GetCurrentTheme();
    ImGui::TextColored(gui::ConvertColorToImVec4(theme.warning), tr("Unknown"));
  } else if (project_version != YAZE_VERSION_STRING) {
    const auto& theme = gui::ThemeManager::Get().GetCurrentTheme();
    ImGui::TextColored(gui::ConvertColorToImVec4(theme.warning), "%s",
                       project_version.c_str());
    if (ImGui::IsItemHovered()) {
      ImGui::SetTooltip(tr("Project saved with v%s; running v%s"),
                        project_version.c_str(), YAZE_VERSION_STRING);
    }
  } else {
    ImGui::Text("%s", project_version.c_str());
  }
 
  ImGui::TextColored(gui::GetTextSecondaryVec4(), tr("Running YAZE:"));
  ImGui::SameLine();
  ImGui::Text("%s", YAZE_VERSION_STRING);
 
  // Project file path (read-only, click to copy)
  ImGui::TextColored(gui::GetTextSecondaryVec4(), tr("Path:"));
  ImGui::SameLine();
  const bool has_project_path = !project_->filepath.empty();
  ImGui::BeginDisabled(!has_project_path);
  const std::string project_path_label =
      has_project_path ? project_->filepath + "##project_path"
                       : std::string("(no project file)##project_path");
  if (ImGui::Selectable(project_path_label.c_str(), false,
                        ImGuiSelectableFlags_None,
                        ImVec2(ImGui::GetContentRegionAvail().x, 0)) &&
      has_project_path) {
    ImGui::SetClipboardText(project_->filepath.c_str());
    if (toast_manager_) {
      toast_manager_->Show("Path copied to clipboard", ToastType::kInfo);
    }
  }
  if (has_project_path && ImGui::IsItemHovered()) {
    ImGui::SetTooltip(tr("Click to copy path"));
  }
  ImGui::EndDisabled();
 
  ImGui::Spacing();
 
  // Editable Project Name
  ImGui::TextColored(gui::GetTextSecondaryVec4(), tr("Project Name:"));
  ImGui::SetNextItemWidth(ImGui::GetContentRegionAvail().x);
  if (ImGui::InputText("##project_name", name_buffer_.data(),
                       name_buffer_.size())) {
    project_->name = name_buffer_.data();
    project_dirty_ = true;
  }
 
  // Editable Author
  ImGui::TextColored(gui::GetTextSecondaryVec4(), tr("Author:"));
  ImGui::SetNextItemWidth(ImGui::GetContentRegionAvail().x);
  if (ImGui::InputText("##author", author_buffer_.data(),
                       author_buffer_.size())) {
    project_->metadata.author = author_buffer_.data();
    project_dirty_ = true;
  }
 
  // Editable Description
  ImGui::TextColored(gui::GetTextSecondaryVec4(), tr("Description:"));
  ImGui::SetNextItemWidth(ImGui::GetContentRegionAvail().x);
  if (ImGui::InputTextMultiline("##description", description_buffer_.data(),
                                description_buffer_.size(), ImVec2(0, 60))) {
    project_->metadata.description = description_buffer_.data();
    project_dirty_ = true;
  }
 
  ImGui::Spacing();
}
 
void ProjectManagementPanel::DrawStorageLocations() {
  gui::ColoredTextF(gui::GetPrimaryVec4(), "%s Storage", ICON_MD_STORAGE);
  ImGui::Spacing();
 
  ImGui::TextWrapped(tr(
      "Primary data lives under the .yaze root. Click any path to copy it."));
  ImGui::Spacing();
 
  auto app_root = util::PlatformPaths::GetAppDataDirectory();
  if (!app_root.ok()) {
    const auto& theme = gui::ThemeManager::Get().GetCurrentTheme();
    ImGui::TextColored(gui::ConvertColorToImVec4(theme.error),
                       tr("Storage unavailable: %s"),
                       std::string(app_root.status().message()).c_str());
    return;
  }
 
  std::vector<std::pair<const char*, std::filesystem::path>> locations = {
      {"Root", *app_root},
      {"Projects", *app_root / "projects"},
      {"Layouts", *app_root / "layouts"},
      {"Workspaces", *app_root / "workspaces"},
      {"Logs", *app_root / "logs"},
      {"Agent", *app_root / "agent"}};
 
  auto temp_root = util::PlatformPaths::GetTempDirectory();
  if (temp_root.ok()) {
    locations.emplace_back("Temp", *temp_root);
  }
 
  if (ImGui::BeginTable("##storage_locations", 2,
                        ImGuiTableFlags_RowBg | ImGuiTableFlags_BordersInnerV |
                            ImGuiTableFlags_SizingStretchProp)) {
    ImGui::TableSetupColumn("Location", ImGuiTableColumnFlags_WidthFixed,
                            110.0f);
    ImGui::TableSetupColumn("Path", ImGuiTableColumnFlags_WidthStretch);
    for (const auto& entry : locations) {
      ImGui::TableNextRow();
      ImGui::TableNextColumn();
      ImGui::TextColored(gui::GetTextSecondaryVec4(), "%s", entry.first);
      ImGui::TableNextColumn();
      const std::string display_path =
          util::PlatformPaths::NormalizePathForDisplay(entry.second);
      ImGui::PushID(entry.first);
      if (ImGui::Selectable(display_path.c_str(), false,
                            ImGuiSelectableFlags_SpanAllColumns)) {
        ImGui::SetClipboardText(display_path.c_str());
        if (toast_manager_) {
          toast_manager_->Show("Path copied to clipboard", ToastType::kInfo);
        }
      }
      if (ImGui::IsItemHovered()) {
        ImGui::SetTooltip(tr("Click to copy"));
      }
      ImGui::PopID();
    }
    ImGui::EndTable();
  }
 
  ImGui::Spacing();
}
 
void ProjectManagementPanel::DrawRomManagement() {
  gui::ColoredTextF(gui::GetPrimaryVec4(), "%s ROM File", ICON_MD_MEMORY);
  ImGui::Spacing();
 
  // Current ROM
  ImGui::TextColored(gui::GetTextSecondaryVec4(), tr("Current ROM:"));
  if (project_->rom_filename.empty()) {
    const auto& theme = gui::ThemeManager::Get().GetCurrentTheme();
    ImGui::TextColored(gui::ConvertColorToImVec4(theme.warning),
                       tr("Not configured"));
  } else {
    // Show just the filename, full path on hover
    std::string filename = project_->rom_filename;
    size_t pos = filename.find_last_of("/\\");
    if (pos != std::string::npos) {
      filename = filename.substr(pos + 1);
    }
    ImGui::Text("%s", filename.c_str());
    if (ImGui::IsItemHovered()) {
      ImGui::SetTooltip("%s", project_->rom_filename.c_str());
    }
  }
 
  // ROM status
  if (rom_ && rom_->is_loaded()) {
    ImGui::TextColored(gui::GetTextSecondaryVec4(), tr("Title:"));
    ImGui::SameLine();
    ImGui::Text("%s", rom_->title().c_str());
 
    ImGui::TextColored(gui::GetTextSecondaryVec4(), tr("Size:"));
    ImGui::SameLine();
    ImGui::Text(tr("%.2f MB"),
                static_cast<float>(rom_->size()) / (1024 * 1024));
 
    if (rom_->dirty()) {
      const auto& theme2 = gui::ThemeManager::Get().GetCurrentTheme();
      ImGui::TextColored(gui::ConvertColorToImVec4(theme2.warning),
                         tr("%s Unsaved changes"), ICON_MD_WARNING);
    }
  }
 
  ImGui::Spacing();
 
  // Action buttons
  float button_width = (ImGui::GetContentRegionAvail().x - 8) / 2;
 
  if (ImGui::Button(ICON_MD_SWAP_HORIZ " Swap ROM", ImVec2(button_width, 0))) {
    if (swap_rom_callback_) {
      swap_rom_callback_();
    }
  }
  if (ImGui::IsItemHovered()) {
    ImGui::SetTooltip(tr("Replace the ROM file for this project"));
  }
 
  ImGui::SameLine();
 
  if (ImGui::Button(ICON_MD_REFRESH " Reload", ImVec2(button_width, 0))) {
    if (reload_rom_callback_) {
      reload_rom_callback_();
    }
  }
  if (ImGui::IsItemHovered()) {
    ImGui::SetTooltip(tr("Reload ROM from disk"));
  }
 
  ImGui::Spacing();
}
 
void ProjectManagementPanel::DrawVersionControl() {
  gui::ColoredTextF(gui::GetPrimaryVec4(), "%s Version Control",
                    ICON_MD_HISTORY);
  ImGui::Spacing();
 
  if (!version_manager_) {
    ImGui::TextDisabled(tr("Version manager not available"));
    return;
  }
 
  bool git_initialized = version_manager_->IsGitInitialized();
 
  if (!git_initialized) {
    ImGui::TextWrapped(
        tr("Git is not initialized for this project. Initialize Git to enable "
           "version control and snapshots."));
    ImGui::Spacing();
 
    if (ImGui::Button(ICON_MD_ADD " Initialize Git",
                      ImVec2(ImGui::GetContentRegionAvail().x, 0))) {
      auto status = version_manager_->InitializeGit();
      if (status.ok()) {
        if (toast_manager_) {
          toast_manager_->Show("Git repository initialized",
                               ToastType::kSuccess);
        }
      } else {
        if (toast_manager_) {
          toast_manager_->Show(
              absl::StrFormat("Failed to initialize Git: %s", status.message()),
              ToastType::kError);
        }
      }
    }
    return;
  }
 
  // Show current commit
  std::string current_hash = version_manager_->GetCurrentHash();
  if (!current_hash.empty()) {
    ImGui::TextColored(gui::GetTextSecondaryVec4(), tr("Current:"));
    ImGui::SameLine();
    ImGui::Text("%s", current_hash.substr(0, 7).c_str());
  }
 
  ImGui::Spacing();
 
  // Create snapshot section
  ImGui::Text(tr("Create Snapshot:"));
  ImGui::SetNextItemWidth(ImGui::GetContentRegionAvail().x);
  ImGui::InputTextWithHint("##snapshot_msg", "Snapshot message...",
                           snapshot_message_, sizeof(snapshot_message_));
 
  if (ImGui::Button(ICON_MD_CAMERA_ALT " Create Snapshot",
                    ImVec2(ImGui::GetContentRegionAvail().x, 0))) {
    std::string msg =
        snapshot_message_[0] ? snapshot_message_ : "Manual snapshot";
    auto result = version_manager_->CreateSnapshot(msg);
    if (result.ok()) {
      if (toast_manager_) {
        toast_manager_->Show(
            absl::StrFormat("Snapshot created: %s", result->commit_hash),
            ToastType::kSuccess);
      }
      snapshot_message_[0] = '\0';
      history_dirty_ = true;
    } else {
      if (toast_manager_) {
        toast_manager_->Show(
            absl::StrFormat("Snapshot failed: %s", result.status().message()),
            ToastType::kError);
      }
    }
  }
  if (ImGui::IsItemHovered()) {
    ImGui::SetTooltip(
        tr("Create a snapshot of your project (Git commit + ROM backup)"));
  }
 
  // Show recent history
  DrawSnapshotHistory();
}
 
void ProjectManagementPanel::DrawSnapshotHistory() {
  if (!version_manager_ || !version_manager_->IsGitInitialized()) {
    return;
  }
 
  ImGui::Spacing();
  if (ImGui::CollapsingHeader(ICON_MD_LIST " Recent Snapshots",
                              ImGuiTreeNodeFlags_DefaultOpen)) {
    // Refresh history if needed
    if (history_dirty_) {
      history_cache_ = version_manager_->GetHistory(5);
      history_dirty_ = false;
    }
 
    if (history_cache_.empty()) {
      ImGui::TextDisabled(tr("No snapshots yet"));
    } else {
      for (const auto& entry : history_cache_) {
        // Format: "hash message"
        size_t space_pos = entry.find(' ');
        std::string hash =
            space_pos != std::string::npos ? entry.substr(0, 7) : entry;
        std::string message =
            space_pos != std::string::npos ? entry.substr(space_pos + 1) : "";
 
        gui::ColoredText(hash.c_str(), gui::GetTextSecondaryVec4());
        ImGui::SameLine();
        ImGui::TextWrapped("%s", message.c_str());
      }
    }
  }
}
 
void ProjectManagementPanel::DrawQuickActions() {
  gui::ColoredTextF(gui::GetPrimaryVec4(), "%s Quick Actions", ICON_MD_BOLT);
  ImGui::Spacing();
 
  float button_width = ImGui::GetContentRegionAvail().x;
 
  // Show unsaved indicator
  if (project_dirty_) {
    const auto& theme = gui::ThemeManager::Get().GetCurrentTheme();
    ImGui::TextColored(gui::ConvertColorToImVec4(theme.warning),
                       tr("%s Project has unsaved changes"), ICON_MD_EDIT);
    ImGui::Spacing();
  }
 
  if (ImGui::Button(ICON_MD_SAVE " Save Project", ImVec2(button_width, 0))) {
    (void)SaveProjectEdits();
  }
 
  if (ImGui::Button(ICON_MD_BUILD " Build Project", ImVec2(button_width, 0))) {
    if (build_project_callback_) {
      build_project_callback_();
    }
  }
 
  if (build_status_.state == ProjectWorkflowState::kRunning &&
      cancel_build_callback_) {
    if (ImGui::Button(ICON_MD_CANCEL " Cancel Build",
                      ImVec2(button_width, 0))) {
      cancel_build_callback_();
    }
  }
 
  if (ImGui::Button(ICON_MD_PLAY_ARROW " Run Project Output",
                    ImVec2(button_width, 0))) {
    if (run_project_callback_) {
      run_project_callback_();
    }
  }
 
  if (build_status_.visible || run_status_.visible) {
    ImGui::Spacing();
    gui::ColoredTextF(gui::GetPrimaryVec4(), "%s Build & Run", ICON_MD_ROUTE);
    if (build_status_.visible) {
      DrawWorkflowCard(build_status_, ICON_MD_BUILD);
    }
    if (!build_log_output_.empty()) {
      ImGui::Spacing();
      ImGui::TextColored(gui::GetTextSecondaryVec4(), tr("Build Output:"));
      ImGui::BeginChild("##build_output_log", ImVec2(0, 140), true,
                        ImGuiWindowFlags_HorizontalScrollbar);
      ImGui::TextUnformatted(build_log_output_.c_str());
      if (ImGui::GetScrollY() >= ImGui::GetScrollMaxY()) {
        ImGui::SetScrollHereY(1.0f);
      }
      ImGui::EndChild();
    }
    if (run_status_.visible) {
      DrawWorkflowCard(run_status_, ICON_MD_PLAY_ARROW);
    }
    ImGui::Spacing();
  }
 
  ImGui::Spacing();
 
  // Editable Code folder
  ImGui::TextColored(gui::GetTextSecondaryVec4(), tr("Code Folder:"));
  ImGui::SetNextItemWidth(ImGui::GetContentRegionAvail().x - 32);
  if (ImGui::InputText("##code_folder", code_buffer_.data(),
                       code_buffer_.size())) {
    project_->code_folder = code_buffer_.data();
    project_dirty_ = true;
  }
  ImGui::SameLine();
  if (ImGui::Button(ICON_MD_FOLDER_OPEN "##browse_code")) {
    if (browse_folder_callback_) {
      browse_folder_callback_("code");
    }
  }
  if (ImGui::IsItemHovered()) {
    ImGui::SetTooltip(tr("Browse for code folder"));
  }
 
  // Editable Assets folder
  ImGui::TextColored(gui::GetTextSecondaryVec4(), tr("Assets Folder:"));
  ImGui::SetNextItemWidth(ImGui::GetContentRegionAvail().x - 32);
  if (ImGui::InputText("##assets_folder", assets_buffer_.data(),
                       assets_buffer_.size())) {
    project_->assets_folder = assets_buffer_.data();
    project_dirty_ = true;
  }
  ImGui::SameLine();
  if (ImGui::Button(ICON_MD_FOLDER_OPEN "##browse_assets")) {
    if (browse_folder_callback_) {
      browse_folder_callback_("assets");
    }
  }
  if (ImGui::IsItemHovered()) {
    ImGui::SetTooltip(tr("Browse for assets folder"));
  }
 
  // Editable Build target
  ImGui::TextColored(gui::GetTextSecondaryVec4(), tr("Build Target:"));
  ImGui::SetNextItemWidth(ImGui::GetContentRegionAvail().x);
  if (ImGui::InputText("##build_target", build_buffer_.data(),
                       build_buffer_.size())) {
    project_->build_target = build_buffer_.data();
    project_dirty_ = true;
  }
 
  // Build script
  ImGui::TextColored(gui::GetTextSecondaryVec4(), tr("Build Script:"));
  ImGui::SetNextItemWidth(ImGui::GetContentRegionAvail().x);
  if (ImGui::InputText("##build_script", script_buffer_.data(),
                       script_buffer_.size())) {
    project_->build_script = script_buffer_.data();
    project_dirty_ = true;
  }
}
 
}  // namespace editor
}  // namespace yaze