#include "panels.h"
#include "../core.h"
#include "../../icons.h"
#include "core/filesystem.h"
#include <implot.h>
#include <algorithm>
#include <array>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <filesystem>
#include <iomanip>
#include <sstream>
#include <unordered_map>
#include <vector>
#include <GLFW/glfw3.h>

namespace afs {
namespace viz {

std::filesystem::path ResolveHafsScawfulRoot() {
  const char* env_root = std::getenv("AFS_SCAWFUL_ROOT");
  if (env_root && env_root[0] != '\0') {
    auto path = studio::core::FileSystem::ResolvePath(env_root);
    if (studio::core::FileSystem::Exists(path)) {
      return path;
    }
  }

  auto plugin_path = studio::core::FileSystem::ResolvePath("~/.config/afs/plugins/afs_scawful");
  if (studio::core::FileSystem::Exists(plugin_path)) {
    return plugin_path;
  }

  const char* trunk_env = std::getenv("TRUNK_ROOT");
  if (trunk_env && trunk_env[0] != '\0') {
    auto trunk_root = studio::core::FileSystem::ResolvePath(trunk_env);
    auto candidate = trunk_root / "scawful" / "research" / "afs_scawful";
    if (studio::core::FileSystem::Exists(candidate)) {
      return candidate;
    }
  }

  auto fallback_path = studio::core::FileSystem::ResolvePath("~/src/trunk/scawful/research/afs_scawful");
  if (studio::core::FileSystem::Exists(fallback_path)) {
    return fallback_path;
  }

  return {};
}

namespace ui {

static bool ContainsInsensitive(const std::string& str, const std::string& pattern) {
  if (pattern.empty()) return true;
  auto it = std::search(str.begin(), str.end(), pattern.begin(), pattern.end(),
                        [](char ch1, char ch2) {
                          return std::tolower(static_cast<unsigned char>(ch1)) ==
                                 std::tolower(static_cast<unsigned char>(ch2));
                        });
  return it != str.end();
}

static std::string TrimCopy(const std::string& input) {
  auto start = input.find_first_not_of(" \t\r\n");
  if (start == std::string::npos) return "";
  auto end = input.find_last_not_of(" \t\r\n");
  return input.substr(start, end - start + 1);
}

static std::string UnquoteCopy(const std::string& input) {
  if (input.size() >= 2 && input.front() == '"' && input.back() == '"') {
    return input.substr(1, input.size() - 2);
  }
  return input;
}

struct HackOverrideEdit {
  bool initialized = false;
  bool enabled = false;
  bool dirty = false;
  std::string review_status;
  float weight = 1.0f;
  bool weight_set = false;
  bool notes_set = false;
  bool include_set = false;
  bool exclude_set = false;
  std::string notes;
  std::vector<std::string> include_globs;
  std::vector<std::string> exclude_globs;
};

struct NoteBufferState {
  std::array<char, 512> buffer{};
  bool initialized = false;
};

static bool LoadOverrideFile(const std::filesystem::path& path,
                             std::unordered_map<std::string, HackOverrideEdit>* edits,
                             std::string* error) {
  edits->clear();
  if (error) error->clear();

  if (!studio::core::FileSystem::Exists(path)) {
    if (error) *error = "Overrides file not found";
    return false;
  }

  auto content_opt = studio::core::FileSystem::ReadFile(path);
  if (!content_opt) {
    if (error) *error = "Failed to read overrides file";
    return false;
  }

  std::istringstream stream(*content_opt);
  std::string line;
  HackOverrideEdit current;
  std::string current_name;

  auto flush = [&]() {
    if (current_name.empty()) return;
    current.initialized = true;
    current.enabled = true;
    (*edits)[current_name] = current;
  };

  while (std::getline(stream, line)) {
    std::string trimmed = TrimCopy(line);
    if (trimmed.empty() || trimmed[0] == '#') continue;

    if (trimmed == "[[hack]]") {
      flush();
      current = HackOverrideEdit{};
      current_name.clear();
      continue;
    }

    auto sep = trimmed.find('=');
    if (sep == std::string::npos) continue;
    std::string key = TrimCopy(trimmed.substr(0, sep));
    std::string value = TrimCopy(trimmed.substr(sep + 1));

    if (key == "name") {
      current_name = UnquoteCopy(value);
    } else if (key == "review_status") {
      current.review_status = UnquoteCopy(value);
    } else if (key == "notes") {
      current.notes = UnquoteCopy(value);
      current.notes_set = true;
    } else if (key == "weight") {
      try {
        current.weight = std::stof(value);
        current.weight_set = true;
      } catch (...) {
        // Ignore parse errors
      }
    } else if (key == "include_globs" || key == "exclude_globs") {
      std::vector<std::string> items;
      if (!value.empty() && value.front() == '[' && value.back() == ']') {
        std::string inner = value.substr(1, value.size() - 2);
        std::stringstream list_stream(inner);
        std::string token;
        while (std::getline(list_stream, token, ',')) {
          std::string cleaned = UnquoteCopy(TrimCopy(token));
          if (!cleaned.empty()) items.push_back(cleaned);
        }
      }
      if (key == "include_globs") {
        current.include_globs = std::move(items);
        current.include_set = true;
      } else {
        current.exclude_globs = std::move(items);
        current.exclude_set = true;
      }
    }
  }
  flush();

  return true;
}

template<size_t N>
static void FillBuffer(std::array<char, N>& buffer, const std::string& text) {
  buffer.fill('\0');
  size_t copy_len = std::min(buffer.size() - 1, text.size());
  std::memcpy(buffer.data(), text.data(), copy_len);
  buffer[copy_len] = '\0';
}

static std::string JoinLines(const std::vector<std::string>& lines) {
  std::ostringstream out;
  for (size_t i = 0; i < lines.size(); ++i) {
    out << lines[i];
    if (i + 1 < lines.size()) out << "\n";
  }
  return out.str();
}

static std::vector<std::string> SplitLines(const std::string& input) {
  std::vector<std::string> lines;
  std::istringstream stream(input);
  std::string line;
  while (std::getline(stream, line)) {
    std::string trimmed = TrimCopy(line);
    if (!trimmed.empty()) lines.push_back(trimmed);
  }
  return lines;
}

static std::string EscapeTomlString(const std::string& value) {
  std::string out;
  out.reserve(value.size());
  for (char ch : value) {
    if (ch == '"') out += "\\\"";
    else out += ch;
  }
  return out;
}

static void WriteStringArray(std::ostringstream& output, const std::string& key,
                             const std::vector<std::string>& values) {
  output << key << " = [";
  for (size_t i = 0; i < values.size(); ++i) {
    output << "\"" << EscapeTomlString(values[i]) << "\"";
    if (i + 1 < values.size()) output << ", ";
  }
  output << "]\n";
}

static bool RunPythonScript(const std::filesystem::path& script_path,
                            const std::filesystem::path& module_root,
                            std::string* output) {
  if (output) output->clear();
  if (!studio::core::FileSystem::Exists(script_path)) {
    if (output) *output = "Script not found";
    return false;
  }

  std::string cmd;
  if (!module_root.empty()) {
    cmd = "AFS_SCAWFUL_ROOT=\"" + module_root.string() + "\" ";
    cmd += "PYTHONPATH=\"" + module_root.string() + "\" ";
  }
  cmd += "python3 \"" + script_path.string() + "\" 2>&1";
  FILE* pipe = popen(cmd.c_str(), "r");
  if (!pipe) {
    if (output) *output = "Failed to launch script";
    return false;
  }

  char buffer[256];
  std::ostringstream result;
  while (fgets(buffer, sizeof(buffer), pipe)) {
    result << buffer;
  }
  int status = pclose(pipe);
  if (output) *output = result.str();
  return status == 0;
}

void RenderInspectorPanel(AppState& state, const DataLoader& loader, ImFont* font_header, const std::string& data_path) {
  const auto& trends = loader.GetQualityTrends();
  const auto& coverage = loader.GetCoverage();
  const auto& runs = loader.GetTrainingRuns();
  const auto& generators = loader.GetGeneratorStats();

  if (font_header) ImGui::PushFont(font_header);
  ImGui::Text(ICON_MD_INSIGHTS " INSPECTOR");
  if (font_header) ImGui::PopFont();
  ImGui::Separator();

  if (state.inspector_context != PlotKind::None) {
      ImGui::PushStyleColor(ImGuiCol_Text, GetThemeColor(ImGuiCol_PlotLines, state.current_theme));
      ImGui::Text(ICON_MD_SETTINGS " CHART PROPERTIES");
      ImGui::PopStyleColor();
      
      const auto& options = PlotOptions();
      const char* label = "Unknown Plot";
      for (const auto& opt : options) {
          if (opt.kind == state.inspector_context) { label = opt.label; break; }
      }
      ImGui::Text("Subject: %s", label);
      ImGui::Separator();
      
      ImGui::Checkbox("Show Markers", &state.show_plot_markers);
      ImGui::Checkbox("Show Legend", &state.show_plot_legends);
      ImGui::SliderFloat("Line Weight", &state.line_weight, 1.0f, 5.0f);
      
      if (state.inspector_context == PlotKind::QualityTrends) {
          ImGui::Spacing();
          ImGui::TextDisabled("Domain Filter");
          for (auto& [domain, visible] : state.domain_visibility) {
              ImGui::Checkbox(domain.c_str(), &visible);
          }
      }
      
      if (ImGui::Button("Reset Context")) state.inspector_context = PlotKind::None;
      ImGui::Separator();
  }

  ImGui::TextDisabled("Data Snapshot");
  ImGui::Text("Runs: %zu", runs.size());
  ImGui::Text("Generators: %zu", generators.size());
  ImGui::Text("Regions: %zu", loader.GetEmbeddingRegions().size());
  ImGui::Text("Sparse Regions: %d", coverage.sparse_regions);
  ImGui::Text("Data Path:");
  ImGui::TextWrapped("%s", data_path.c_str());
  const auto& status = loader.GetLastStatus();
  ImGui::Text("Sources: %d/%d ok", status.OkCount(), status.FoundCount());
  if (status.error_count > 0) {
    ImGui::TextColored(ImVec4(0.9f, 0.4f, 0.4f, 1.0f),
                       "Load Errors: %d", status.error_count);
    if (!status.last_error.empty()) {
      ImGui::TextDisabled("Last Error:");
      ImGui::TextWrapped("%s (%s)",
                         status.last_error.c_str(),
                         status.last_error_source.empty()
                             ? "unknown"
                             : status.last_error_source.c_str());
    }
  }

  float avg_quality = 0.0f;
  if (!trends.empty()) {
    for (const auto& t : trends) avg_quality += t.mean;
    avg_quality /= static_cast<float>(trends.size());
  }

  ImGui::Spacing();
  ImGui::TextDisabled("Health Signals");
  ImGui::ProgressBar(avg_quality, ImVec2(-1, 0), "Avg Quality");
  ImGui::ProgressBar(coverage.coverage_score, ImVec2(-1, 0), "Coverage Score");

  ImGui::Separator();
  ImGui::TextDisabled("Selected Run");

  if (state.selected_run_index >= 0 && state.selected_run_index < static_cast<int>(runs.size())) {
    const auto& run = runs[state.selected_run_index];
    ImGui::Text("%s", run.run_id.c_str());
    if (!run.model_name.empty()) ImGui::Text("Model: %s", run.model_name.c_str());
    if (!run.base_model.empty()) ImGui::Text("Base: %s", run.base_model.c_str());
    ImGui::Text("Samples: %d", run.samples_count);
    ImGui::Text("Final Loss: %.5f", run.final_loss);
    if (!run.start_time.empty() || !run.end_time.empty()) {
      ImGui::Text("Window: %s -> %s", run.start_time.empty() ? "?" : run.start_time.c_str(), run.end_time.empty() ? "?" : run.end_time.c_str());
    }
    if (!run.dataset_path.empty()) {
      ImGui::Text("Dataset:");
      ImGui::TextWrapped("%s", run.dataset_path.c_str());
    }
    if (!run.notes.empty()) {
      ImGui::Text("Notes:");
      ImGui::TextWrapped("%s", run.notes.c_str());
    }

    if (!run.domain_distribution.empty()) {
      std::vector<std::pair<std::string, int>> domains(run.domain_distribution.begin(), run.domain_distribution.end());
      std::sort(domains.begin(), domains.end(), [](const auto& a, const auto& b) { return a.second > b.second; });
      if (domains.size() > 6) domains.resize(6);

      std::vector<const char*> labels;
      std::vector<float> values;
      std::vector<std::string> label_storage;
      for (const auto& [domain, count] : domains) {
        label_storage.push_back(domain);
        values.push_back(static_cast<float>(count));
      }
      for (const auto& label : label_storage) labels.push_back(label.c_str());

      ImPlotFlags plot_flags = ImPlotFlags_NoLegend | ImPlotFlags_NoMenus;
      ApplyPremiumPlotStyles("##RunDomains", state);
      if (ImPlot::BeginPlot("##RunDomains", ImVec2(-1, 140), plot_flags)) {
        ImPlotAxisFlags axis_flags = static_cast<ImPlotAxisFlags>(GetPlotAxisFlags(state));
        ImPlot::SetupAxes("Domain", "Samples", axis_flags, axis_flags);
        ImPlot::SetupAxisTicks(ImAxis_X1, 0, static_cast<double>(labels.size() - 1), static_cast<int>(labels.size()), labels.data());
        ImPlot::SetNextFillStyle(GetSeriesColor(2), 0.75f);
        ImPlot::PlotBars("Samples", values.data(), static_cast<int>(values.size()), 0.6);
        ImPlot::EndPlot();
      }
      ImPlot::PopStyleColor(2);
      ImPlot::PopStyleVar(6);
    }

    if (!run.eval_metrics.empty()) {
      std::vector<const char*> labels;
      std::vector<float> values;
      std::vector<std::string> label_storage;
      for (const auto& [metric, value] : run.eval_metrics) {
        label_storage.push_back(metric);
        values.push_back(value);
      }
      for (const auto& label : label_storage) labels.push_back(label.c_str());

      ImPlotFlags plot_flags = ImPlotFlags_NoLegend | ImPlotFlags_NoMenus;
      ApplyPremiumPlotStyles("##RunMetrics", state);
      if (ImPlot::BeginPlot("##RunMetrics", ImVec2(-1, 120), plot_flags)) {
        ImPlotAxisFlags axis_flags = static_cast<ImPlotAxisFlags>(GetPlotAxisFlags(state));
        ImPlot::SetupAxes("Metric", "Score", axis_flags, axis_flags);
        ImPlot::SetupAxisLimits(ImAxis_Y1, 0.0, 1.0, ImPlotCond_Once);
        ImPlot::SetupAxisTicks(ImAxis_X1, 0, static_cast<double>(labels.size() - 1), static_cast<int>(labels.size()), labels.data());
        ImPlot::SetNextFillStyle(GetSeriesColor(4), 0.75f);
        ImPlot::PlotBars("Score", values.data(), static_cast<int>(values.size()), 0.6);
        ImPlot::EndPlot();
      }
      ImPlot::PopStyleColor(2);
      ImPlot::PopStyleVar(6);
    }
  } else {
    ImGui::TextDisabled("Select a training run in the Dataset panel.");
  }

  ImGui::Separator();
  ImGui::TextDisabled("Selected Generator");
  if (state.selected_generator_index >= 0 && state.selected_generator_index < static_cast<int>(generators.size())) {
    const auto& gen = generators[state.selected_generator_index];
    ImGui::Text("%s", gen.name.c_str());
    ImGui::Text("Accepted: %d", gen.samples_accepted);
    ImGui::Text("Rejected: %d", gen.samples_rejected);
    ImGui::Text("Avg Quality: %.3f", gen.avg_quality);
    ImGui::ProgressBar(gen.acceptance_rate, ImVec2(-1, 0), "Acceptance Rate");

    if (!gen.rejection_reasons.empty()) {
      std::vector<std::pair<std::string, int>> reasons(gen.rejection_reasons.begin(), gen.rejection_reasons.end());
      std::sort(reasons.begin(), reasons.end(), [](const auto& a, const auto& b) { return a.second > b.second; });
      if (reasons.size() > 6) reasons.resize(6);

      std::vector<const char*> labels;
      std::vector<float> values;
      std::vector<std::string> label_storage;
      for (const auto& [reason, count] : reasons) {
        std::string formatted = reason;
        std::replace(formatted.begin(), formatted.end(), '_', ' ');
        label_storage.push_back(formatted);
        values.push_back(static_cast<float>(count));
      }
      for (const auto& label : label_storage) labels.push_back(label.c_str());

      ImPlotFlags plot_flags = ImPlotFlags_NoLegend | ImPlotFlags_NoMenus;
      ApplyPremiumPlotStyles("##GenRejections", state);
      if (ImPlot::BeginPlot("##GenRejections", ImVec2(-1, 120), plot_flags)) {
        ImPlotAxisFlags axis_flags = static_cast<ImPlotAxisFlags>(GetPlotAxisFlags(state));
        ImPlot::SetupAxes("Reason", "Count", axis_flags, axis_flags);
        ImPlot::SetupAxisTicks(ImAxis_X1, 0, static_cast<double>(labels.size() - 1), static_cast<int>(labels.size()), labels.data());
        ImPlot::SetNextFillStyle(GetSeriesColor(7), 0.75f);
        ImPlot::PlotBars("Count", values.data(), static_cast<int>(values.size()), 0.6);
        ImPlot::EndPlot();
      }
      ImPlot::PopStyleColor(2);
      ImPlot::PopStyleVar(6);
    }
  } else {
    ImGui::TextDisabled("Select a generator in the Dataset panel.");
  }

  ImGui::Separator();
  ImGui::Spacing();
  if (font_header) ImGui::PushFont(font_header);
  ImGui::Text(ICON_MD_FILE_DOWNLOAD_DONE " DATA INTEGRITY AUDIT");
  if (font_header) ImGui::PopFont();
  ImGui::Separator();

  auto render_audit_item = [](const char* name, bool found, bool ok, const char* error) {
      ImGui::BeginGroup();
      if (!found) {
          ImGui::TextColored(ImVec4(0.5f, 0.5f, 0.5f, 1.0f), ICON_MD_FILE_OPEN " %s", name);
          ImGui::SameLine(); ImGui::TextDisabled("(Not Found)");
      } else if (!ok) {
          ImGui::TextColored(ImVec4(0.9f, 0.3f, 0.3f, 1.0f), ICON_MD_REPORT_GMAILERRORRED " %s", name);
          ImGui::SameLine(); ImGui::TextColored(ImVec4(0.9f, 0.3f, 0.3f, 1.0f), "(Error)");
          if (error && error[0] != '\0') {
              ImGui::Indent();
              ImGui::TextDisabled("%s", error);
              ImGui::Unindent();
          }
      } else {
          ImGui::TextColored(ImVec4(0.4f, 0.8f, 0.4f, 1.0f), ICON_MD_CHECK_CIRCLE " %s", name);
          ImGui::SameLine(); ImGui::TextDisabled("(Synced)");
      }
      ImGui::EndGroup();
  };

  render_audit_item("quality_feedback.json", status.quality_found, status.quality_ok, status.quality_ok ? "" : status.last_error.c_str());
  render_audit_item("active_learning.json", status.active_found, status.active_ok, status.active_ok ? "" : status.last_error.c_str());
  render_audit_item("training_feedback.json", status.training_found, status.training_ok, status.training_ok ? "" : status.last_error.c_str());

  ImGui::Spacing();
  ImGui::TextDisabled("Integrity Score: %.1f%%", (status.OkCount() / (float)std::max(1, status.FoundCount())) * 100.0f);
  ImGui::ProgressBar(status.OkCount() / (float)std::max(1, status.FoundCount()), ImVec2(-1, 0));
}

void RenderDatasetPanel(AppState& state, const DataLoader& loader) {
  const auto& runs = loader.GetTrainingRuns();
  const auto& generators = loader.GetGeneratorStats();
  const auto& coverage = loader.GetCoverage();
  const auto& dataset_registry = loader.GetDatasetRegistry();
  const auto& dataset_error = loader.GetDatasetRegistryError();

  if (ImGui::BeginTabBar("DatasetTabs")) {
    if (ImGui::BeginTabItem("Training Runs")) {
      ImGui::InputTextWithHint("##RunFilter", "Filter by run ID or model", state.run_filter.data(), state.run_filter.size());
      ImGui::SameLine();
      if (ImGui::Button("Clear")) state.run_filter[0] = '\0';

      if (ImGui::BeginTable("RunTable", 5, ImGuiTableFlags_RowBg | ImGuiTableFlags_Resizable | ImGuiTableFlags_Borders | ImGuiTableFlags_ScrollY)) {
        ImGui::TableSetupColumn("Run ID", ImGuiTableColumnFlags_WidthStretch);
        ImGui::TableSetupColumn("Model", ImGuiTableColumnFlags_WidthStretch);
        ImGui::TableSetupColumn("Samples", ImGuiTableColumnFlags_WidthFixed, 90);
        ImGui::TableSetupColumn("Loss", ImGuiTableColumnFlags_WidthFixed, 80);
        ImGui::TableSetupColumn("Domains", ImGuiTableColumnFlags_WidthFixed, 80);
        ImGui::TableHeadersRow();

        for (size_t i = 0; i < runs.size(); ++i) {
          const auto& run = runs[i];
          if (!ContainsInsensitive(run.run_id, state.run_filter.data()) && !ContainsInsensitive(run.model_name, state.run_filter.data())) continue;

          bool selected = static_cast<int>(i) == state.selected_run_index;
          ImGui::TableNextRow();
          ImGui::TableNextColumn();
          if (ImGui::Selectable(run.run_id.c_str(), selected, ImGuiSelectableFlags_SpanAllColumns)) {
            state.selected_run_index = static_cast<int>(i);
            state.selected_run_id = run.run_id;
          }
          ImGui::TableNextColumn(); ImGui::Text("%s", run.model_name.empty() ? "-" : run.model_name.c_str());
          ImGui::TableNextColumn(); ImGui::Text("%d", run.samples_count);
          ImGui::TableNextColumn(); ImGui::Text("%.4f", run.final_loss);
          ImGui::TableNextColumn(); ImGui::Text("%zu", run.domain_distribution.size());
        }
        ImGui::EndTable();
      }
      ImGui::EndTabItem();
    }

    if (ImGui::BeginTabItem("Data Sources")) {
      const auto& resource_index = loader.GetResourceIndex();
      const auto& resource_error = loader.GetResourceIndexError();
      static std::string resource_status;

      if (!resource_error.empty()) {
        ImGui::TextColored(ImVec4(0.9f, 0.5f, 0.2f, 1.0f), "%s", resource_error.c_str());
      }

      if (resource_index.total_files == 0) {
        ImGui::TextDisabled("No resource index loaded.");
      } else {
        ImGui::Text("Total files: %d", resource_index.total_files);
        ImGui::Text("Duplicates: %d", resource_index.duplicates_found);
        if (!resource_index.indexed_at.empty()) {
          ImGui::TextDisabled("Indexed at: %s", resource_index.indexed_at.c_str());
        }
      }

      ImGui::Spacing();
      if (ImGui::Button("Rebuild Resource Index")) {
        auto scawful_root = ResolveHafsScawfulRoot();
        std::filesystem::path script_path = scawful_root.empty()
            ? std::filesystem::current_path() / "rebuild_resource_index.py"
            : scawful_root / "scripts" / "rebuild_resource_index.py";
        std::string build_output;
        bool ok = RunPythonScript(script_path, scawful_root, &build_output);
        if (!build_output.empty()) {
          resource_status = ok ? "Resource index rebuilt (see logs)" : "Resource index rebuild failed (see logs)";
        } else {
          resource_status = ok ? "Resource index rebuilt" : "Resource index rebuild failed";
        }
        state.should_refresh = true;
      }
      if (!resource_status.empty()) {
        ImGui::SameLine();
        ImGui::TextDisabled("%s", resource_status.c_str());
      }

      if (!resource_index.by_source.empty()) {
        ImGui::Spacing();
        ImGui::Separator();
        ImGui::TextDisabled("Sources");

        std::vector<std::pair<std::string, int>> sources;
        sources.reserve(resource_index.by_source.size());
        for (const auto& [name, count] : resource_index.by_source) {
          sources.emplace_back(name, count);
        }
        std::sort(sources.begin(), sources.end(),
                  [](const auto& a, const auto& b) { return a.second > b.second; });

        if (ImGui::BeginTable("ResourceSources", 3,
                              ImGuiTableFlags_RowBg | ImGuiTableFlags_Resizable |
                              ImGuiTableFlags_Borders | ImGuiTableFlags_ScrollY | ImGuiTableFlags_SizingStretchProp)) {
          ImGui::TableSetupColumn("Source", ImGuiTableColumnFlags_WidthStretch, 1.5f);
          ImGui::TableSetupColumn("Files", ImGuiTableColumnFlags_WidthFixed, 80);
          ImGui::TableSetupColumn("Share", ImGuiTableColumnFlags_WidthFixed, 70);
          ImGui::TableHeadersRow();

          for (const auto& entry : sources) {
            ImGui::TableNextRow();
            ImGui::TableNextColumn();
            ImGui::Text("%s", entry.first.c_str());
            ImGui::TableNextColumn();
            ImGui::Text("%d", entry.second);
            ImGui::TableNextColumn();
            float share = resource_index.total_files > 0
                ? static_cast<float>(entry.second) / static_cast<float>(resource_index.total_files)
                : 0.0f;
            ImGui::Text("%.1f%%", share * 100.0f);
          }
          ImGui::EndTable();
        }
      }

      if (!resource_index.by_type.empty()) {
        ImGui::Spacing();
        ImGui::Separator();
        ImGui::TextDisabled("File Types");

        std::vector<std::pair<std::string, int>> types;
        types.reserve(resource_index.by_type.size());
        for (const auto& [name, count] : resource_index.by_type) {
          types.emplace_back(name, count);
        }
        std::sort(types.begin(), types.end(),
                  [](const auto& a, const auto& b) { return a.second > b.second; });

        if (ImGui::BeginTable("ResourceTypes", 3,
                              ImGuiTableFlags_RowBg | ImGuiTableFlags_Resizable |
                              ImGuiTableFlags_Borders | ImGuiTableFlags_ScrollY | ImGuiTableFlags_SizingStretchProp)) {
          ImGui::TableSetupColumn("Type", ImGuiTableColumnFlags_WidthStretch, 1.5f);
          ImGui::TableSetupColumn("Files", ImGuiTableColumnFlags_WidthFixed, 80);
          ImGui::TableSetupColumn("Share", ImGuiTableColumnFlags_WidthFixed, 70);
          ImGui::TableHeadersRow();

          for (const auto& entry : types) {
            ImGui::TableNextRow();
            ImGui::TableNextColumn();
            ImGui::Text("%s", entry.first.c_str());
            ImGui::TableNextColumn();
            ImGui::Text("%d", entry.second);
            ImGui::TableNextColumn();
            float share = resource_index.total_files > 0
                ? static_cast<float>(entry.second) / static_cast<float>(resource_index.total_files)
                : 0.0f;
            ImGui::Text("%.1f%%", share * 100.0f);
          }
          ImGui::EndTable();
        }
      }

      ImGui::EndTabItem();
    }

    if (ImGui::BeginTabItem("Datasets")) {
      static std::string dataset_status;
      if (!dataset_error.empty()) {
        ImGui::TextColored(ImVec4(0.9f, 0.5f, 0.2f, 1.0f), "%s", dataset_error.c_str());
      }

      ImGui::InputTextWithHint("##DatasetFilter", "Filter by dataset name", state.dataset_filter.data(), state.dataset_filter.size());
      ImGui::SameLine();
      if (ImGui::Button("Clear##DatasetFilter")) state.dataset_filter[0] = '\0';
      ImGui::SameLine();
      if (ImGui::Button("Rebuild Dataset Registry")) {
        auto scawful_root = ResolveHafsScawfulRoot();
        std::filesystem::path script_path = scawful_root.empty()
            ? std::filesystem::current_path() / "build_dataset_registry.py"
            : scawful_root / "scripts" / "build_dataset_registry.py";
        std::string build_output;
        bool ok = RunPythonScript(script_path, scawful_root, &build_output);
        if (!build_output.empty()) {
          dataset_status = ok ? "Dataset registry rebuilt (see logs)" : "Dataset registry rebuild failed (see logs)";
        } else {
          dataset_status = ok ? "Dataset registry rebuilt" : "Dataset registry rebuild failed";
        }
        state.should_refresh = true;
      }
      if (!dataset_status.empty()) {
        ImGui::SameLine();
        ImGui::TextDisabled("%s", dataset_status.c_str());
      }

      if (dataset_registry.datasets.empty()) {
        ImGui::TextDisabled("No dataset registry loaded.");
      } else {
        std::uint64_t total_size = 0;
        for (const auto& dataset : dataset_registry.datasets) {
          total_size += dataset.size_bytes;
        }
        double total_mb = static_cast<double>(total_size) / (1024.0 * 1024.0);
        ImGui::Text("Datasets: %zu", dataset_registry.datasets.size());
        ImGui::SameLine();
        ImGui::TextDisabled("Total size: %.2f MB", total_mb);
        if (!dataset_registry.generated_at.empty()) {
          ImGui::TextDisabled("Generated at: %s", dataset_registry.generated_at.c_str());
        }

        if (ImGui::BeginTable("DatasetRegistryTable", 4,
                              ImGuiTableFlags_RowBg | ImGuiTableFlags_Resizable |
                              ImGuiTableFlags_Borders | ImGuiTableFlags_ScrollY | ImGuiTableFlags_SizingStretchProp)) {
          ImGui::TableSetupColumn("Dataset", ImGuiTableColumnFlags_WidthStretch, 1.4f);
          ImGui::TableSetupColumn("Files", ImGuiTableColumnFlags_WidthFixed, 80);
          ImGui::TableSetupColumn("Size (MB)", ImGuiTableColumnFlags_WidthFixed, 100);
          ImGui::TableSetupColumn("Updated", ImGuiTableColumnFlags_WidthStretch, 1.1f);
          ImGui::TableHeadersRow();

          for (size_t i = 0; i < dataset_registry.datasets.size(); ++i) {
            const auto& dataset = dataset_registry.datasets[i];
            if (!ContainsInsensitive(dataset.name, state.dataset_filter.data())) {
              continue;
            }
            ImGui::TableNextRow();
            ImGui::TableNextColumn();
            bool selected = static_cast<int>(i) == state.selected_dataset_index;
            if (ImGui::Selectable(dataset.name.c_str(), selected, ImGuiSelectableFlags_SpanAllColumns)) {
              state.selected_dataset_index = static_cast<int>(i);
            }
            if (ImGui::IsItemHovered() && !dataset.path.empty()) {
              ImGui::BeginTooltip();
              ImGui::Text("%s", dataset.path.c_str());
              ImGui::EndTooltip();
            }
            ImGui::TableNextColumn();
            ImGui::Text("%zu", dataset.files.size());
            ImGui::TableNextColumn();
            double size_mb = static_cast<double>(dataset.size_bytes) / (1024.0 * 1024.0);
            ImGui::Text("%.2f", size_mb);
            ImGui::TableNextColumn();
            ImGui::Text("%s", dataset.updated_at.empty() ? "-" : dataset.updated_at.c_str());
          }
          ImGui::EndTable();
        }

        ImGui::Separator();
        if (state.selected_dataset_index >= 0 &&
            state.selected_dataset_index < static_cast<int>(dataset_registry.datasets.size())) {
          const auto& selected = dataset_registry.datasets[state.selected_dataset_index];
          ImGui::TextDisabled("Selected Dataset");
          ImGui::Text("%s", selected.name.c_str());
          ImGui::TextDisabled("%s", selected.path.empty() ? "-" : selected.path.c_str());
          ImGui::Text("Files: %zu", selected.files.size());

          ImGui::BeginChild("DatasetFiles", ImVec2(0, 120), true);
          size_t max_files = 12;
          for (size_t i = 0; i < selected.files.size() && i < max_files; ++i) {
            ImGui::BulletText("%s", selected.files[i].c_str());
          }
          if (selected.files.size() > max_files) {
            ImGui::TextDisabled("... and %zu more", selected.files.size() - max_files);
          }
          ImGui::EndChild();
        } else {
          ImGui::TextDisabled("Select a dataset to view details.");
        }
      }

      ImGui::EndTabItem();
    }

    if (ImGui::BeginTabItem("Generators")) {
      ImGui::InputTextWithHint("##GenFilter", "Filter by generator name", state.generator_filter.data(), state.generator_filter.size());
      ImGui::SameLine();
      if (ImGui::Button("Clear##Gen")) state.generator_filter[0] = '\0';

      if (ImGui::BeginTable("GeneratorTable", 5, ImGuiTableFlags_RowBg | ImGuiTableFlags_Resizable | ImGuiTableFlags_Borders | ImGuiTableFlags_ScrollY | ImGuiTableFlags_SizingStretchProp)) {
        ImGui::TableSetupColumn("Generator", ImGuiTableColumnFlags_WidthStretch, 1.5f);
        ImGui::TableSetupColumn("Accepted", ImGuiTableColumnFlags_WidthFixed, 80);
        ImGui::TableSetupColumn("Rejected", ImGuiTableColumnFlags_WidthFixed, 80);
        ImGui::TableSetupColumn("Rate %", ImGuiTableColumnFlags_WidthFixed, 70);
        ImGui::TableSetupColumn("Quality", ImGuiTableColumnFlags_WidthFixed, 70);
        ImGui::TableHeadersRow();

        for (size_t i = 0; i < generators.size(); ++i) {
          const auto& gen = generators[i];
          if (!ContainsInsensitive(gen.name, state.generator_filter.data())) continue;
          bool selected = static_cast<int>(i) == state.selected_generator_index;
          ImGui::TableNextRow();
          ImGui::TableNextColumn();
          if (ImGui::Selectable(gen.name.c_str(), selected, ImGuiSelectableFlags_SpanAllColumns)) {
            state.selected_generator_index = static_cast<int>(i);
            state.selected_generator_name = gen.name;
          }
          ImGui::TableNextColumn(); ImGui::Text("%d", gen.samples_accepted);
          ImGui::TableNextColumn(); ImGui::Text("%d", gen.samples_rejected);
          ImGui::TableNextColumn(); ImGui::Text("%.1f", gen.acceptance_rate * 100.0f);
          ImGui::TableNextColumn(); ImGui::Text("%.3f", gen.avg_quality);
        }
        ImGui::EndTable();
      }
      ImGui::EndTabItem();
    }

    if (ImGui::BeginTabItem("Domains")) {
      if (coverage.domain_coverage.empty()) {
        ImGui::TextDisabled("No domain coverage data available.");
      } else {
        if (ImGui::BeginTable("DomainCoverageTable", 3, ImGuiTableFlags_RowBg | ImGuiTableFlags_Resizable | ImGuiTableFlags_Borders)) {
          ImGui::TableSetupColumn("Domain", ImGuiTableColumnFlags_WidthStretch);
          ImGui::TableSetupColumn("Coverage %", ImGuiTableColumnFlags_WidthFixed, 110);
          ImGui::TableSetupColumn("Bar", ImGuiTableColumnFlags_WidthStretch);
          ImGui::TableHeadersRow();

          for (const auto& [domain, value] : coverage.domain_coverage) {
            ImGui::TableNextRow();
            ImGui::TableNextColumn(); ImGui::Text("%s", domain.c_str());
            ImGui::TableNextColumn(); ImGui::Text("%.1f", value * 100.0f);
            ImGui::TableNextColumn(); ImGui::ProgressBar(value, ImVec2(-1, 0));
          }
          ImGui::EndTable();
        }
      }
      ImGui::EndTabItem();
    }

    if (ImGui::BeginTabItem("Curated Hacks")) {
      const auto& hacks = loader.GetCuratedHacks();
      const auto& curated_error = loader.GetCuratedHacksError();
      static std::unordered_map<std::string, HackOverrideEdit> override_edits;
      static std::unordered_map<std::string, NoteBufferState> note_buffers;
      static bool overrides_loaded = false;
      static std::string overrides_error;
      static std::string overrides_status;
      static std::string selected_hack_name;
      static std::array<char, 2048> notes_buffer{};
      static std::array<char, 1024> include_buffer{};
      static std::array<char, 1024> exclude_buffer{};

      auto scawful_root = ResolveHafsScawfulRoot();
      std::filesystem::path override_path = scawful_root.empty()
          ? studio::core::FileSystem::ResolvePath("~/.config/afs/curated_hacks_overrides.toml")
          : scawful_root / "config" / "curated_hacks_overrides.toml";

      if (!overrides_loaded) {
        LoadOverrideFile(override_path, &override_edits, &overrides_error);
        overrides_loaded = true;
      }

      if (!curated_error.empty()) {
        ImGui::TextColored(ImVec4(0.9f, 0.5f, 0.2f, 1.0f), "%s", curated_error.c_str());
      }

      ImGui::Spacing();
      if (ImGui::Button("Reload Overrides")) {
        LoadOverrideFile(override_path, &override_edits, &overrides_error);
        overrides_status = overrides_error.empty() ? "Overrides reloaded" : overrides_error;
        note_buffers.clear();
      }
      ImGui::SameLine();
      if (ImGui::Button("Save Overrides")) {
        std::ostringstream output;
        output << "# Curated hack overrides (generated by AFS Studio)\n";
        int saved = 0;

        for (const auto& hack : hacks) {
          auto it = override_edits.find(hack.name);
          if (it == override_edits.end() || !it->second.enabled) continue;

          const auto& edit = it->second;
          output << "\n[[hack]]\n";
          output << "name = \"" << hack.name << "\"\n";
          if (!edit.review_status.empty()) {
            output << "review_status = \"" << edit.review_status << "\"\n";
          }
          output << "weight = " << std::fixed << std::setprecision(2) << edit.weight << "\n";
          if (edit.notes_set) {
            output << "notes = \"" << EscapeTomlString(edit.notes) << "\"\n";
          }
          if (edit.include_set) {
            WriteStringArray(output, "include_globs", edit.include_globs);
          }
          if (edit.exclude_set) {
            WriteStringArray(output, "exclude_globs", edit.exclude_globs);
          }
          saved++;
        }

        if (studio::core::FileSystem::EnsureDirectory(override_path.parent_path()) &&
            studio::core::FileSystem::WriteFile(override_path, output.str())) {
          overrides_status = "Saved " + std::to_string(saved) + " overrides";
          for (auto& [name, edit] : override_edits) {
            edit.dirty = false;
          }
        } else {
          overrides_status = "Failed to save overrides";
        }
      }
      ImGui::SameLine();
      if (ImGui::Button("Save + Rebuild Summary")) {
        std::ostringstream output;
        output << "# Curated hack overrides (generated by AFS Studio)\n";
        int saved = 0;

        for (const auto& hack : hacks) {
          auto it = override_edits.find(hack.name);
          if (it == override_edits.end() || !it->second.enabled) continue;

          const auto& edit = it->second;
          output << "\n[[hack]]\n";
          output << "name = \"" << hack.name << "\"\n";
          if (!edit.review_status.empty()) {
            output << "review_status = \"" << edit.review_status << "\"\n";
          }
          output << "weight = " << std::fixed << std::setprecision(2) << edit.weight << "\n";
          if (edit.notes_set) {
            output << "notes = \"" << EscapeTomlString(edit.notes) << "\"\n";
          }
          if (edit.include_set) {
            WriteStringArray(output, "include_globs", edit.include_globs);
          }
          if (edit.exclude_set) {
            WriteStringArray(output, "exclude_globs", edit.exclude_globs);
          }
          saved++;
        }

        if (studio::core::FileSystem::EnsureDirectory(override_path.parent_path()) &&
            studio::core::FileSystem::WriteFile(override_path, output.str())) {
          std::filesystem::path script_path = override_path.parent_path().parent_path();
          script_path /= "scripts/build_curated_hacks_summary.py";
          std::string build_output;
          bool ok = RunPythonScript(script_path, scawful_root, &build_output);
          overrides_status = ok ? "Saved overrides and rebuilt summary" : "Saved overrides, rebuild failed";
          if (!build_output.empty()) {
            overrides_status += " (see logs)";
          }
          state.should_refresh = true;
          for (auto& [name, edit] : override_edits) {
            edit.dirty = false;
          }
        } else {
          overrides_status = "Failed to save overrides";
        }
      }
      if (!overrides_status.empty()) {
        ImGui::SameLine();
        ImGui::TextDisabled("%s", overrides_status.c_str());
      }

      ImGui::TextDisabled("Tip: Save + Rebuild Summary refreshes file counts automatically.");

      if (!overrides_error.empty()) {
        ImGui::TextColored(ImVec4(0.9f, 0.4f, 0.4f, 1.0f), "%s", overrides_error.c_str());
      }

      if (hacks.empty()) {
        ImGui::TextDisabled("No curated hack summary available.");
        if (!scawful_root.empty()) {
          ImGui::TextDisabled("Run: %s", (scawful_root / "scripts" / "build_curated_hacks_summary.py").string().c_str());
        } else {
          ImGui::TextDisabled("Curated hacks plugin not configured.");
        }
      } else if (ImGui::BeginTable("CuratedHacksTable", 10,
                                   ImGuiTableFlags_RowBg | ImGuiTableFlags_Resizable |
                                   ImGuiTableFlags_Borders | ImGuiTableFlags_ScrollY |
                                   ImGuiTableFlags_SizingStretchProp | ImGuiTableFlags_NoSavedSettings)) {
        ImGui::TableSetupColumn("Name", ImGuiTableColumnFlags_WidthStretch, 1.2f);
        ImGui::TableSetupColumn("Status", ImGuiTableColumnFlags_WidthFixed, 85);
        ImGui::TableSetupColumn("Review", ImGuiTableColumnFlags_WidthFixed, 85);
        ImGui::TableSetupColumn("Weight", ImGuiTableColumnFlags_WidthFixed, 65);
        ImGui::TableSetupColumn("Eligible", ImGuiTableColumnFlags_WidthFixed, 65);
        ImGui::TableSetupColumn("Select", ImGuiTableColumnFlags_WidthFixed, 65);
        ImGui::TableSetupColumn("Org%", ImGuiTableColumnFlags_WidthFixed, 60);
        ImGui::TableSetupColumn("Addr%", ImGuiTableColumnFlags_WidthFixed, 60);
        ImGui::TableSetupColumn("Comm%", ImGuiTableColumnFlags_WidthFixed, 60);
        ImGui::TableSetupColumn("Path", ImGuiTableColumnFlags_WidthStretch, 2.0f);
        ImGui::TableHeadersRow();

        auto load_editor_buffers = [&](const auto& hack, HackOverrideEdit& edit) {
          const std::string notes_text = edit.notes_set ? edit.notes : hack.notes;
          const auto& include_list = edit.include_set ? edit.include_globs : hack.include_globs;
          const auto& exclude_list = edit.exclude_set ? edit.exclude_globs : hack.exclude_globs;
          FillBuffer(notes_buffer, notes_text);
          FillBuffer(include_buffer, JoinLines(include_list));
          FillBuffer(exclude_buffer, JoinLines(exclude_list));
          auto& note_state = note_buffers[hack.name];
          FillBuffer(note_state.buffer, notes_text);
          note_state.initialized = true;
        };

        for (const auto& hack : hacks) {
          auto& edit = override_edits[hack.name];
          if (!edit.initialized) {
            edit.review_status = hack.review_status;
            edit.weight = hack.weight;
            edit.weight_set = true;
            edit.notes = hack.notes;
            edit.notes_set = !hack.notes.empty();
            edit.include_globs = hack.include_globs;
            edit.include_set = !hack.include_globs.empty();
            edit.exclude_globs = hack.exclude_globs;
            edit.exclude_set = !hack.exclude_globs.empty();
            edit.initialized = true;
          } else if (!edit.weight_set) {
            edit.weight = hack.weight;
            edit.weight_set = true;
          }

          auto& note_state = note_buffers[hack.name];
          if (!note_state.initialized) {
            const std::string notes_text = edit.notes_set ? edit.notes : hack.notes;
            FillBuffer(note_state.buffer, notes_text);
            note_state.initialized = true;
          }

          ImGui::TableNextRow();
          ImGui::TableNextColumn();
          bool is_selected = (selected_hack_name == hack.name);
          if (ImGui::Selectable(hack.name.empty() ? "-" : hack.name.c_str(), is_selected)) {
            selected_hack_name = hack.name;
            load_editor_buffers(hack, edit);
          }
          if (!hack.authors.empty() && ImGui::IsItemHovered()) {
            ImGui::BeginTooltip();
            ImGui::Text("Authors:");
            for (const auto& author : hack.authors) {
              ImGui::BulletText("%s", author.c_str());
            }
            const auto& include_list = edit.include_set ? edit.include_globs : hack.include_globs;
            const auto& exclude_list = edit.exclude_set ? edit.exclude_globs : hack.exclude_globs;
            const auto& sample_list = hack.sample_files;
            if (!sample_list.empty()) {
              ImGui::Separator();
              ImGui::Text("Sample files:");
              for (const auto& sample : sample_list) {
                ImGui::BulletText("%s", sample.c_str());
              }
            }
            if (!include_list.empty()) {
              ImGui::Separator();
              ImGui::Text("Include globs:");
              for (const auto& glob : include_list) {
                ImGui::BulletText("%s", glob.c_str());
              }
            }
            if (!exclude_list.empty()) {
              ImGui::Separator();
              ImGui::Text("Exclude globs:");
              for (const auto& glob : exclude_list) {
                ImGui::BulletText("%s", glob.c_str());
              }
            }
            ImGui::EndTooltip();
          }

          ImGui::TableNextColumn();
          if (ImGui::Button(("Edit##" + hack.name).c_str())) {
            selected_hack_name = hack.name;
            load_editor_buffers(hack, edit);
          }

          ImGui::TableNextColumn();
          bool enabled = edit.enabled;
          if (ImGui::Checkbox(("##override_" + hack.name).c_str(), &enabled)) {
            edit.enabled = enabled;
            edit.dirty = true;
          }

          ImGui::TableNextColumn();
          if (edit.dirty) {
            ImGui::TextColored(ImVec4(0.9f, 0.4f, 0.4f, 1.0f), "dirty");
          } else {
            ImGui::TextDisabled("-");
          }

          ImGui::TableNextColumn();
          ImGui::BeginDisabled(!edit.enabled);
          float weight = edit.weight;
          ImGui::SetNextItemWidth(-1.0f);
          if (ImGui::SliderFloat(("##weight_" + hack.name).c_str(), &weight, 0.0f, 1.0f, "%.2f")) {
            edit.weight = weight;
            edit.weight_set = true;
            edit.dirty = true;
          }
          ImGui::EndDisabled();

          ImGui::TableNextColumn();
          ImGui::BeginDisabled(!edit.enabled);
          const char* status_items[] = {"", "approved", "hold", "rejected"};
          int status_index = 0;
          if (edit.review_status == "approved") status_index = 1;
          else if (edit.review_status == "hold") status_index = 2;
          else if (edit.review_status == "rejected") status_index = 3;
          ImGui::SetNextItemWidth(-1.0f);
          if (ImGui::Combo(("##review_" + hack.name).c_str(), &status_index, status_items, 4)) {
            edit.review_status = status_items[status_index];
            edit.dirty = true;
          }
          ImGui::EndDisabled();

          ImGui::TableNextColumn();
          ImGui::Text("%d/%d", hack.selected_files, hack.eligible_files);

          ImGui::TableNextColumn();
          ImGui::Text("%.0f", hack.org_ratio * 100.0f);

          ImGui::TableNextColumn();
          ImGui::Text("%.0f", hack.address_ratio * 100.0f);

          ImGui::TableNextColumn();
          ImGui::SetNextItemWidth(-1.0f);
          if (ImGui::InputTextWithHint(("##note_" + hack.name).c_str(),
                                       "Notes...", note_state.buffer.data(),
                                       note_state.buffer.size())) {
            edit.notes = TrimCopy(std::string(note_state.buffer.data()));
            edit.notes_set = true;
            edit.enabled = true;
            edit.dirty = true;
            if (selected_hack_name == hack.name) {
              FillBuffer(notes_buffer, edit.notes);
            }
          }
          std::string notes = edit.notes_set ? edit.notes : hack.notes;
          if (notes.empty()) notes = "-";
          if (ImGui::IsItemHovered()) {
            ImGui::BeginTooltip();
            ImGui::TextWrapped("%s", notes.c_str());
            if (!hack.path.empty()) {
              ImGui::Separator();
              ImGui::TextDisabled("%s", hack.path.c_str());
            }
            ImGui::EndTooltip();
          }
        }
        ImGui::EndTable();
      }

      if (!hacks.empty()) {
        ImGui::Spacing();
        ImGui::Separator();
        ImGui::Text(ICON_MD_EDIT " Override Editor");

        if (selected_hack_name.empty()) {
          ImGui::TextDisabled("Select a hack row to edit include/exclude globs and notes.");
        } else {
          auto it = std::find_if(hacks.begin(), hacks.end(), [&](const auto& h) {
            return h.name == selected_hack_name;
          });

          if (it == hacks.end()) {
            ImGui::TextDisabled("Selected hack not found.");
          } else {
            auto& edit = override_edits[it->name];
            ImGui::Text("Editing: %s", it->name.c_str());
            ImGui::SameLine();
            if (ImGui::Button("Revert Override")) {
              edit.enabled = false;
              edit.dirty = true;
              edit.review_status = it->review_status;
              edit.weight = it->weight;
              edit.weight_set = false;
              edit.notes = it->notes;
              edit.notes_set = false;
              edit.include_globs = it->include_globs;
              edit.include_set = false;
              edit.exclude_globs = it->exclude_globs;
              edit.exclude_set = false;
              FillBuffer(notes_buffer, it->notes);
              FillBuffer(include_buffer, JoinLines(it->include_globs));
              FillBuffer(exclude_buffer, JoinLines(it->exclude_globs));
              overrides_status = "Cleared override for " + it->name + " (not saved)";
            }
            bool notes_changed = ImGui::InputTextMultiline(
                "Notes", notes_buffer.data(), notes_buffer.size(), ImVec2(-1, 90));
            bool include_changed = ImGui::InputTextMultiline(
                "Include globs (one per line)", include_buffer.data(), include_buffer.size(),
                ImVec2(-1, 70));
            bool exclude_changed = ImGui::InputTextMultiline(
                "Exclude globs (one per line)", exclude_buffer.data(), exclude_buffer.size(),
                ImVec2(-1, 70));

            if (notes_changed || include_changed || exclude_changed) {
              edit.notes = TrimCopy(std::string(notes_buffer.data()));
              edit.notes_set = true;
              edit.include_globs = SplitLines(include_buffer.data());
              edit.include_set = true;
              edit.exclude_globs = SplitLines(exclude_buffer.data());
              edit.exclude_set = true;
              edit.enabled = true;
              edit.dirty = true;
              overrides_status = "Updated overrides for " + it->name + " (not saved)";
            }

            if (ImGui::Button("Reset Editor")) {
              auto load_editor_buffers = [&](const auto& hack, HackOverrideEdit& edit_ref) {
                const std::string notes_text = edit_ref.notes_set ? edit_ref.notes : hack.notes;
                const auto& include_list = edit_ref.include_set ? edit_ref.include_globs : hack.include_globs;
                const auto& exclude_list = edit_ref.exclude_set ? edit_ref.exclude_globs : hack.exclude_globs;
                FillBuffer(notes_buffer, notes_text);
                FillBuffer(include_buffer, JoinLines(include_list));
                FillBuffer(exclude_buffer, JoinLines(exclude_list));
              };
              load_editor_buffers(*it, edit);
            }
          }
        }
      }

      ImGui::EndTabItem();
    }
    ImGui::EndTabBar();
  }
}

void RenderSystemsPanel(AppState& state, ImFont* font_header, std::function<void(const char*)> refresh_callback) {
  if (font_header) ImGui::PushFont(font_header);
  ImGui::Text(ICON_MD_ROUTER " SYSTEMS OVERVIEW");
  if (font_header) ImGui::PopFont();
  ImGui::Separator();

  if (ImGui::Button(ICON_MD_REFRESH " Refresh Now", ImVec2(-1, 0))) {
    if (refresh_callback) refresh_callback("ui");
  }
  ImGui::Spacing();

  double seconds_since = std::max(0.0, glfwGetTime() - state.last_refresh_time);
  ImGui::Text("Auto Refresh: %s", state.auto_refresh ? "On" : "Off");
  ImGui::Text("Interval: %.1fs", state.refresh_interval_sec);
  ImGui::Text("Last Refresh: %.0fs ago", seconds_since);
  ImGui::Text("Simulation: %s", state.simulate_activity ? "On" : "Off");
  ImGui::Text("Quality Threshold: %.2f", state.quality_threshold);
  ImGui::Text("Mission Concurrency: %d", state.mission_concurrency);

  ImGui::Spacing();
  ImGui::Separator();
  ImGui::TextDisabled("Swarm Snapshot");

  int active_count = 0;
  int total_queue = 0;
  float total_success = 0.0f;
  for (const auto& agent : state.agents) {
    if (agent.enabled) active_count++;
    total_queue += agent.queue_depth;
    total_success += agent.success_rate;
  }
  if (!state.agents.empty()) total_success /= static_cast<float>(state.agents.size());

  if (ImGui::BeginTable("SystemSnapshot", 2, ImGuiTableFlags_SizingStretchProp)) {
    ImGui::TableNextColumn();
    ImGui::Text("Active Agents");
    ImGui::Text("Queue Depth");
    ImGui::Text("Avg Success");
    ImGui::TableNextColumn();
    ImGui::Text("%d / %d", active_count, static_cast<int>(state.agents.size()));
    ImGui::Text("%d", total_queue);
    ImGui::Text("%.1f%%", total_success * 100.0f);
    ImGui::EndTable();
  }

  ImGui::Spacing();
  ImGui::Separator();
  ImGui::TextDisabled("Core Services");

  auto render_row = [](const char* name, const char* status) {
    ImVec4 status_color = ImVec4(0.4f, 0.8f, 0.4f, 1.0f);
    if (strcmp(status, "Warning") == 0) status_color = ImVec4(0.9f, 0.7f, 0.2f, 1.0f);
    else if (strcmp(status, "Error") == 0) status_color = ImVec4(0.9f, 0.3f, 0.3f, 1.0f);

    ImGui::Bullet(); ImGui::SameLine();
    ImGui::Text("%s", name); ImGui::SameLine();
    ImGui::TextColored(status_color, "%s", status);
  };

  render_row("Orchestrator", "Active");
  render_row("Knowledge Base", "Active");
  render_row("Trainer", "Active");
  render_row("Embedding SVC", "Warning");
}

void RenderMenuBar(AppState& state,
                   std::function<void(const char*)> refresh_callback,
                   std::function<void()> quit_callback,
                   ShortcutManager& shortcuts,
                   bool* show_sample_review,
                   bool* show_shortcuts_window) {
  if (ImGui::BeginMainMenuBar()) {
    auto shortcut_label = [&](ActionId action_id) -> std::string {
      return shortcuts.FormatShortcut(action_id, ImGui::GetIO());
    };

    if (ImGui::BeginMenu("File")) {
      std::string refresh_shortcut = shortcut_label(ActionId::Refresh);
      if (ImGui::MenuItem("Refresh", refresh_shortcut.empty() ? nullptr
                                                              : refresh_shortcut.c_str())) {
        if (refresh_callback) refresh_callback("manual");
      }
      ImGui::Separator();
      std::string quit_shortcut = shortcut_label(ActionId::Quit);
      if (ImGui::MenuItem("Quit", quit_shortcut.empty() ? nullptr
                                                        : quit_shortcut.c_str())) {
        if (quit_callback) quit_callback();
      }
      ImGui::EndMenu();
    }

    if (ImGui::BeginMenu("View")) {
      if (ImGui::MenuItem("Reset Layout (F1)")) {
        state.force_reset_layout = true;
      }
      ImGui::Separator();
      if (ImGui::BeginMenu("Workspace")) {
        std::string dash_shortcut = shortcut_label(ActionId::WorkspaceDashboard);
        if (ImGui::MenuItem("Dashboard", dash_shortcut.empty() ? nullptr
                                                               : dash_shortcut.c_str(),
                            state.current_workspace == Workspace::Dashboard)) {
          state.current_workspace = Workspace::Dashboard;
          if (state.reset_layout_on_workspace_change) state.force_reset_layout = true;
        }
        std::string analysis_shortcut = shortcut_label(ActionId::WorkspaceAnalysis);
        if (ImGui::MenuItem("Analysis", analysis_shortcut.empty() ? nullptr
                                                                  : analysis_shortcut.c_str(),
                            state.current_workspace == Workspace::Analysis)) {
          state.current_workspace = Workspace::Analysis;
          if (state.reset_layout_on_workspace_change) state.force_reset_layout = true;
        }
        std::string optimization_shortcut = shortcut_label(ActionId::WorkspaceOptimization);
        if (ImGui::MenuItem("Optimization",
                            optimization_shortcut.empty() ? nullptr
                                                          : optimization_shortcut.c_str(),
                            state.current_workspace == Workspace::Optimization)) {
          state.current_workspace = Workspace::Optimization;
          if (state.reset_layout_on_workspace_change) state.force_reset_layout = true;
        }
        std::string systems_shortcut = shortcut_label(ActionId::WorkspaceSystems);
        if (ImGui::MenuItem("Systems", systems_shortcut.empty() ? nullptr
                                                                : systems_shortcut.c_str(),
                            state.current_workspace == Workspace::Systems)) {
          state.current_workspace = Workspace::Systems;
          if (state.reset_layout_on_workspace_change) state.force_reset_layout = true;
        }
        std::string custom_shortcut = shortcut_label(ActionId::WorkspaceCustom);
        if (ImGui::MenuItem("Custom Grid", custom_shortcut.empty() ? nullptr
                                                                   : custom_shortcut.c_str(),
                            state.current_workspace == Workspace::Custom)) {
          state.current_workspace = Workspace::Custom;
          if (state.reset_layout_on_workspace_change) state.force_reset_layout = true;
        }

        std::string training_shortcut = shortcut_label(ActionId::WorkspaceTraining);
        if (ImGui::MenuItem("Training Hub", training_shortcut.empty() ? nullptr
                                                                      : training_shortcut.c_str(),
                            state.current_workspace == Workspace::Training)) {
            state.current_workspace = Workspace::Training;
            if (state.reset_layout_on_workspace_change) state.force_reset_layout = true;
        }
        std::string context_shortcut = shortcut_label(ActionId::WorkspaceContext);
        if (ImGui::MenuItem("Context Broker", context_shortcut.empty() ? nullptr
                                                                       : context_shortcut.c_str(),
                            state.current_workspace == Workspace::Context)) {
            state.current_workspace = Workspace::Context;
            if (state.reset_layout_on_workspace_change) state.force_reset_layout = true;
        }
        ImGui::EndMenu();
      }
      
      if (ImGui::BeginMenu("Theme Profile")) {
          if (ImGui::MenuItem("Deep Sea (Default)", nullptr, state.current_theme == ThemeProfile::Default)) state.current_theme = ThemeProfile::Default;
          if (ImGui::MenuItem("Cyberpunk", nullptr, state.current_theme == ThemeProfile::Cyberpunk)) state.current_theme = ThemeProfile::Cyberpunk;
          if (ImGui::MenuItem("Monochrome", nullptr, state.current_theme == ThemeProfile::Monochrome)) state.current_theme = ThemeProfile::Monochrome;
          if (ImGui::MenuItem("Solarized", nullptr, state.current_theme == ThemeProfile::Solarized)) state.current_theme = ThemeProfile::Solarized;
          if (ImGui::MenuItem("Nord", nullptr, state.current_theme == ThemeProfile::Nord)) state.current_theme = ThemeProfile::Nord;
          if (ImGui::MenuItem("Dracula", nullptr, state.current_theme == ThemeProfile::Dracula)) state.current_theme = ThemeProfile::Dracula;
          ImGui::EndMenu();
      }

      ImGui::Separator();
      if (ImGui::BeginMenu("Panels")) {
        std::string inspector_shortcut = shortcut_label(ActionId::ToggleInspector);
        ImGui::MenuItem("Inspector", inspector_shortcut.empty() ? nullptr
                                                                : inspector_shortcut.c_str(),
                        &state.show_inspector);
        std::string dataset_shortcut = shortcut_label(ActionId::ToggleDatasetPanel);
        ImGui::MenuItem("Dataset Panel", dataset_shortcut.empty() ? nullptr
                                                                  : dataset_shortcut.c_str(),
                        &state.show_dataset_panel);
        std::string systems_panel_shortcut = shortcut_label(ActionId::ToggleSystemsPanel);
        ImGui::MenuItem("Systems Panel", systems_panel_shortcut.empty() ? nullptr
                                                                        : systems_panel_shortcut.c_str(),
                        &state.show_systems_panel);
        std::string status_shortcut = shortcut_label(ActionId::ToggleStatusBar);
        ImGui::MenuItem("Status Strip", status_shortcut.empty() ? nullptr
                                                                : status_shortcut.c_str(),
                        &state.show_status_strip);
        std::string controls_shortcut = shortcut_label(ActionId::ToggleControls);
        ImGui::MenuItem("Sidebar Controls", controls_shortcut.empty() ? nullptr
                                                                      : controls_shortcut.c_str(),
                        &state.show_controls);
        ImGui::MenuItem("Chat Panel", nullptr, &state.show_chat_panel);
        ImGui::Separator();
        ImGui::MenuItem("Quality Trends", nullptr, &state.show_quality_trends);
        ImGui::MenuItem("Generator Efficiency", nullptr, &state.show_generator_efficiency);
        ImGui::MenuItem("Coverage Density", nullptr, &state.show_coverage_density);
        ImGui::EndMenu();
      }

      if (ImGui::BeginMenu("Windows")) {
        if (show_sample_review) {
          std::string review_shortcut = shortcut_label(ActionId::ToggleSampleReview);
          ImGui::MenuItem("Sample Review", review_shortcut.empty() ? nullptr
                                                                   : review_shortcut.c_str(),
                          show_sample_review);
        }
        if (show_shortcuts_window) {
          std::string shortcuts_shortcut =
              shortcut_label(ActionId::ToggleShortcutsWindow);
          ImGui::MenuItem("Keyboard Shortcuts",
                          shortcuts_shortcut.empty() ? nullptr
                                                     : shortcuts_shortcut.c_str(),
                          show_shortcuts_window);
        }
        ImGui::EndMenu();
      }

      ImGui::Separator();
      std::string compact_shortcut = shortcut_label(ActionId::ToggleCompactUI);
      ImGui::MenuItem("Compact UI", compact_shortcut.empty() ? nullptr
                                                             : compact_shortcut.c_str(),
                      &state.compact_charts);
      std::string lock_shortcut = shortcut_label(ActionId::ToggleLockLayout);
      ImGui::MenuItem("Lock Layout", lock_shortcut.empty() ? nullptr
                                                           : lock_shortcut.c_str(),
                      &state.lock_layout);
      std::string reset_shortcut = shortcut_label(ActionId::ResetLayout);
      if (ImGui::MenuItem("Reset Layout",
                          reset_shortcut.empty() ? nullptr
                                                 : reset_shortcut.c_str())) {
        state.force_reset_layout = true;
      }
      ImGui::EndMenu();
    }

    if (ImGui::BeginMenu("Tools")) {
        std::string auto_refresh_shortcut =
            shortcut_label(ActionId::ToggleAutoRefresh);
        ImGui::MenuItem("Auto Refresh",
                        auto_refresh_shortcut.empty()
                            ? nullptr
                            : auto_refresh_shortcut.c_str(),
                        &state.auto_refresh);
        std::string simulate_shortcut =
            shortcut_label(ActionId::ToggleSimulation);
        ImGui::MenuItem("Simulate Activity",
                        simulate_shortcut.empty()
                            ? nullptr
                            : simulate_shortcut.c_str(),
                        &state.simulate_activity);
        ImGui::Separator();
        std::string demo_shortcut = shortcut_label(ActionId::ToggleDemoWindow);
        ImGui::MenuItem("Show ImGui Demo", demo_shortcut.empty() ? nullptr
                                                                 : demo_shortcut.c_str(),
                        &state.show_demo_window);
        ImGui::EndMenu();
    }

    if (ImGui::BeginMenu("Help")) {
      if (ImGui::MenuItem("Documentation")) {}
      std::string help_shortcut =
          shortcut_label(ActionId::ToggleShortcutsWindow);
      if (ImGui::MenuItem("Shortcuts",
                          help_shortcut.empty() ? nullptr
                                                : help_shortcut.c_str())) {
        if (show_shortcuts_window) *show_shortcuts_window = true;
      }
      ImGui::Separator();
      if (ImGui::MenuItem("About AFS Viz")) {}
      ImGui::EndMenu();
    }
    ImGui::EndMainMenuBar();
  }
}

void RenderSidebar(AppState& state, const DataLoader& loader, ImFont* font_ui, ImFont* font_header) {
  // Make the entire sidebar content scrollable to avoid overlaps
  ImGui::BeginChild("SidebarScroll", ImVec2(0, 0), false, ImGuiWindowFlags_AlwaysVerticalScrollbar | ImGuiWindowFlags_NoBackground);

  ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0, 4));
  ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0, 0, 0, 0));
  ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(1, 1, 1, 0.05f));
  ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(1, 1, 1, 0.08f));

  auto sidebar_button = [&](const char* label, Workspace ws, const char* icon) {
    bool active = state.current_workspace == ws;
    ImGui::PushID(label);

    ImVec2 size = ImVec2(ImGui::GetContentRegionAvail().x, 38);
    ImVec2 p_cursor = ImGui::GetCursorScreenPos();
    
    if (ImGui::InvisibleButton("##btn", size)) {
      if (state.current_workspace != ws) {
        state.current_workspace = ws;
        if (state.reset_layout_on_workspace_change) state.force_reset_layout = true;
      }
    }

    bool hovered = ImGui::IsItemHovered();
    bool pressed = ImGui::IsItemActive();
    
    ImDrawList* draw = ImGui::GetWindowDrawList();
    ImU32 bg_col = hovered ? ImGui::GetColorU32(ImGuiCol_ButtonHovered) : (pressed ? ImGui::GetColorU32(ImGuiCol_ButtonActive) : 0);
    if (active) bg_col = ImGui::GetColorU32(ImVec4(1, 1, 1, 0.08f));
    
    if (bg_col != 0) {
        draw->AddRectFilled(p_cursor, ImVec2(p_cursor.x + size.x, p_cursor.y + size.y), bg_col, 4.0f);
    }

    if (active) {
        draw->AddRectFilled(p_cursor, ImVec2(p_cursor.x + 3, p_cursor.y + size.y), ImGui::GetColorU32(ImVec4(0.40f, 0.85f, 1.0f, 1.0f)), 2.0f);
    }

    ImVec2 text_pos = ImVec2(p_cursor.x + 12, p_cursor.y + (size.y - ImGui::GetFontSize()) * 0.5f);
    draw->AddText(font_ui, ImGui::GetFontSize(), text_pos, active ? ImGui::GetColorU32(ImVec4(0.40f, 0.85f, 1.0f, 1.0f)) : ImGui::GetColorU32(ImGuiCol_Text), std::string(std::string(icon) + "  " + label).c_str());

    if (hovered) ImGui::SetTooltip("%s workspace", label);
    ImGui::PopID();
  };

  auto sidebar_header = [&](const char* title, const char* icon = nullptr) {
    ImGui::Spacing(); ImGui::Spacing();
    if (font_header) ImGui::PushFont(font_header);
    ImGui::SetCursorPosX(12);
    if (icon) {
        ImGui::TextDisabled("%s %s", icon, title);
    } else {
        ImGui::TextDisabled("%s", title);
    }
    if (font_header) ImGui::PopFont();
    ImGui::Spacing();
  };

  sidebar_header("WORKSPACES", ICON_MD_VIEW_QUILT);
  sidebar_button("Dashboard", Workspace::Dashboard, ICON_MD_DASHBOARD);
  sidebar_button("Analysis", Workspace::Analysis, ICON_MD_ANALYTICS);
  sidebar_button("Optimization", Workspace::Optimization, ICON_MD_SETTINGS_INPUT_COMPONENT);
  
  sidebar_header("OPERATIONS", ICON_MD_SETTINGS_SUGGEST);
  sidebar_button("Systems", Workspace::Systems, ICON_MD_ROUTER);
  sidebar_button("Training", Workspace::Training, ICON_MD_MODEL_TRAINING);
  sidebar_button("Custom Grid", Workspace::Custom, ICON_MD_DASHBOARD_CUSTOMIZE);
  
  sidebar_header("REGISTRIES", ICON_MD_STORAGE);

  sidebar_button("Context", Workspace::Context, ICON_MD_FOLDER_OPEN);
  sidebar_button("Models", Workspace::Models, ICON_MD_STICKY_NOTE_2);

  // New: Useful Tools Section
  sidebar_header("SYSTEM TOOLS", ICON_MD_HANDYMAN);
  ImGui::Indent(12);
  
  // Health Summary
  {
      float health = 0.92f; // Mock health
      ImGui::TextDisabled("System Health");
      ImGui::ProgressBar(health, ImVec2(-12, 4), "");
      if (ImGui::IsItemHovered()) ImGui::SetTooltip("Overall reliability score: %.0f%%", health * 100.0f);
  }
  
  ImGui::Spacing();
  
  // Quick Toggles
  if (ImGui::Checkbox("Simulate", &state.simulate_activity)) {}
  if (ImGui::IsItemHovered()) ImGui::SetTooltip("Toggle background task simulation");
  
  if (ImGui::Checkbox("Auto Refresh", &state.auto_refresh)) {}
  if (ImGui::IsItemHovered()) ImGui::SetTooltip("Refresh data every %.1fs", state.refresh_interval_sec);

  ImGui::Unindent(12);
  
  // New: Mounts Management Section
  sidebar_header("LOCAL MOUNTS", ICON_MD_STORAGE);
  ImGui::Indent(12);
  
  const auto& mounts = loader.GetMounts();
  if (mounts.empty()) {
      ImGui::TextDisabled("No mounts discovered");
  } else {
      for (const auto& mount : mounts) {
          ImGui::BeginGroup();
          ImGui::TextColored(mount.active ? ImVec4(0.4f, 1.0f, 0.6f, 1.0f) : ImVec4(0.5f, 0.5f, 0.5f, 1.0f), 
                             mount.active ? ICON_MD_DNS : ICON_MD_DASHBOARD_CUSTOMIZE);
          ImGui::SameLine();
          ImGui::Text("%s", mount.name.c_str());
          if (ImGui::IsItemHovered()) ImGui::SetTooltip("Path: %s\nStatus: %s", mount.path.c_str(), mount.active ? "Connected" : "Disconnected");
          ImGui::EndGroup();
      }
  }

  if (ImGui::SmallButton(ICON_MD_STORAGE " Mount Drives")) {
      const_cast<DataLoader&>(loader).MountDrive("all");
  }
  ImGui::SameLine();
  if (ImGui::SmallButton(ICON_MD_ADD " Add Mount")) {
      // TODO: Implement mount dialog
  }

  ImGui::Unindent(12);

  ImGui::PopStyleColor(3);
  ImGui::PopStyleVar();

  ImGui::EndChild(); // End SidebarScroll
}

} // namespace ui
} // namespace viz
} // namespace afs