gui.cpp

#include "gui.h"

#include <algorithm>
#include <array>
#include <cctype>
#include <cerrno>
#include <chrono>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <filesystem>
#include <fstream>
#include <nlohmann/json.hpp>
#include <sstream>
#include <string>
#include <unordered_set>
#include <utility>

#include "utl_settings.h"

#ifdef __EMSCRIPTEN__
#include <emscripten.h>
#endif

#include "third_party/tinyfiledialogs/tinyfiledialogs.h"

#include "utl_geom.h"
#include "imgui.h"
#include "imgui_internal.h"
#include "utl_log.h"
#include "scr_lua_console.h"
#include "gui_occt_view.h"
#include "doc_delta.h"
#include "utl_io.h"
#include "scr_python_console.h"
#include "shp_info.h"
#include "skt.h"
#include "utl.h"
#include "utl_cad_file_info.h"
#include "version.h"

#include <Standard_Version.hxx>
#include <GLFW/glfw3.h>

using namespace glm;

GUI* gui_instance = nullptr;

GUI::GUI()
{
  EZY_ASSERT(!gui_instance);

  m_view       = std::make_unique<Occt_view>(*this);
  gui_instance = this;
}

Length_dimension_style GUI::length_dimension_style() const
{
  Length_dimension_style s{};
  s.line_width        = m_edge_dim_line_width;
  s.arrow_size        = m_edge_dim_arrow_size;
  s.color_rgb[0]      = m_edge_dim_color[0];
  s.color_rgb[1]      = m_edge_dim_color[1];
  s.color_rgb[2]      = m_edge_dim_color[2];
  s.text_height_scale = m_edge_dim_text_scale;
  s.label_h           = m_edge_dim_label_h;
  s.arrow_style       = m_edge_dim_arrow_style;
  s.arrow_orientation = m_edge_dim_arrow_orientation;
  s.text_render_mode  = m_edge_dim_text_render_mode;
  return s;
}

void GUI::set_show_sketch_dimensions(const bool show)
{
  if (m_show_sketch_dimensions == show)
    return;

  m_show_sketch_dimensions = show;
  apply_sketch_dimensions_visibility();
}

void GUI::apply_sketch_dimensions_visibility()
{
  if (m_view)
    m_view->apply_sketch_dimensions_visibility();
}

ImFont* GUI::console_font() const
{
  if (!m_console_font || !ImGui::GetCurrentContext())
    return nullptr;

  ImFontAtlas* atlas = ImGui::GetIO().Fonts;
  if (!atlas)
    return nullptr;

  for (int i = 0; i < atlas->Fonts.Size; ++i)
    if (atlas->Fonts[i] == m_console_font)
      return m_console_font;

  return nullptr;
}

GUI::~GUI()
{
  cleanup_log_redirection_(); // Clean up stream redirection
}

ImVec4 GUI::get_clear_color() const
{
  if (m_dark_mode)
    return ImVec4(0.10f, 0.10f, 0.12f, 1.00f);

  return ImVec4(0.45f, 0.55f, 0.60f, 1.00f);
}

#ifdef __EMSCRIPTEN__
GUI& GUI::instance()
{
  EZY_ASSERT(gui_instance);
  return *gui_instance;
}
#endif

void GUI::render_gui()
{
  // Underlay transform sliders use sketch_plane_view_aabb_2d -> pt_on_plane -> view projection.
  // FlushViewEvents must run before ImGui so the camera matches the latest pan/zoom/rotate (do_frame() runs later).
  m_view->flush_view_events();

  update_window_title_();

  if (m_dark_mode)
    ImGui::StyleColorsDark();
  else
    ImGui::StyleColorsLight();

  apply_imgui_style_from_members_();

  menu_bar_();
  dock_space_();
  toolbar_();
  dist_edit_();
  angle_edit_();
  sketch_origin_set_edit_();
  sketch_list_();
  sketch_properties_dialog_();
  shape_list_();
  shape_info_dialog_();
  file_inspector_dialog_();
  // Paint the busy modal before poll so WASM can show "Importing..." for a frame first.
  cad_busy_dialog_();
  poll_cad_busy_();
  options_();
  message_status_window_();
  error_modal_dialog_();
  export_units_dialog_();
  about_dialog_();
  add_box_dialog_();
  add_pyramid_dialog_();
  add_sphere_dialog_();
  add_cylinder_dialog_();
  add_cone_dialog_();
  add_torus_dialog_();
  add_sketch_dialog_();
  log_window_();
  lua_console_();
  python_console_();
  settings_();
  dbg_();
}

void GUI::render_occt() { m_view->do_frame(); }

// Initialize toolbar buttons
void GUI::initialize_toolbar_()
{
  m_toolbar_buttons = {
      // clang-format off
      {load_texture("res/icons/User.png"),                            true,  "Inspection mode",                   Mode::Normal},
      {load_texture("res/icons/Workbench_Sketcher_none.png"),         false, "Sketch inspection mode",            Mode::Sketch_inspection_mode},
      {load_texture("res/icons/Assembly_AxialMove.png"),              false, "Shape move",                        Mode::Move},
      {load_texture("res/icons/Draft_Rotate.png"),                    false, "Shape rotate",                      Mode::Rotate},
      {load_texture("res/icons/Part_Scale.png"),                      false, "Shape Scale",                       Mode::Scale},
      {load_texture("res/icons/Assembly_Move.png"),                   false, "Align cylinders",                   Mode::Shape_cyl_align},
      {load_texture("res/icons/Macro_FaceToSketch_48.png"),           false, "Create a sketch from planar face",  Mode::Sketch_from_planar_face},
      {load_texture("res/icons/Sketcher_MirrorSketch.png"),           false, "Operational axis",                  Mode::Sketch_operation_axis},
      {load_texture("res/icons/Sketcher_CreatePoint.png"),            false, "Add node",                          Mode::Sketch_add_node},
      {load_texture("res/icons/Sketcher_Element_Line_Edge.png"),      false, "Add line edge",                     Mode::Sketch_add_edge},
      {load_texture("res/icons/ls.png"),                              false, "Add multi-line edge",               Mode::Sketch_add_multi_edges},
      {load_texture("res/icons/Sketcher_Element_Arc_Edge.png"),       false, "Add arc circle",                    Mode::Sketch_add_seg_circle_arc},
      {load_texture("res/icons/Sketcher_CreateSquare.png"),           false, "Add square",                        Mode::Sketch_add_square},
      {load_texture("res/icons/Sketcher_CreateRectangle.png"),        false, "Add rectangle from two points",     Mode::Sketch_add_rectangle},
      {load_texture("res/icons/Sketcher_CreateRectangle_Center.png"), false, "Add rectangle with center point",   Mode::Sketch_add_rectangle_center_pt},
      {load_texture("res/icons/Sketcher_CreateCircle.png"),           false, "Add circle",                        Mode::Sketch_add_circle},
      {load_texture("res/icons/Sketcher_Create3PointCircle.png"),     false, "Add circle from three points",      Mode::Sketch_add_circle_3_pts},
      {load_texture("res/icons/Sketcher_CreateSlot.png"),             false, "Add slot",                          Mode::Sketch_add_slot},
      {load_texture("res/icons/TechDraw_LengthDimension.png"),        false, "Length dimension",                  Mode::Sketch_dim_anno},
      {load_texture("res/icons/Design456_Extrude.png"),               false, "Extrude sketch face",               Mode::Sketch_face_extrude},
      {load_texture("res/icons/PartDesign_Chamfer.png"),              false, "Chamfer",                           Mode::Shape_chamfer},
      {load_texture("res/icons/PartDesign_Fillet.png"),               false, "Fillet",                            Mode::Shape_fillet},
      {load_texture("res/icons/Draft_PolarArray.png"),                false, "Shape polar duplicate",             Mode::Shape_polar_duplicate},
      {load_texture("res/icons/Curves_ExtractSubshape.png"),          false, "Shape cross-section",               Mode::Shape_cross_section},
      {load_texture("res/icons/Part_Cut.png"),                        false, "Shape cut",                         Command::Shape_cut},
      {load_texture("res/icons/Part_Fuse.png"),                       false, "Shape fuse",                        Command::Shape_fuse},
      {load_texture("res/icons/Part_Common.png"),                     false, "Shape common",                      Command::Shape_common},
      // clang-format on
  };
  sync_toolbar_hotkey_tooltips_();
}

void GUI::sync_toolbar_hotkey_tooltips_()
{
  auto tip_mode = [this](Mode mode, const char* base, Gui_action action)
  {
    for (Toolbar_button& b : m_toolbar_buttons)
    {
      if (b.data.index() != 0 || std::get<Mode>(b.data) != mode)
        continue;
      const std::string chord = Gui_hotkeys::format_chord(m_hotkeys.chord_for(action));
      b.tooltip               = std::string(base) + " (" + chord + ")";
      return;
    }
  };
  auto tip_cmd = [this](Command cmd, const char* base, Gui_action action)
  {
    for (Toolbar_button& b : m_toolbar_buttons)
    {
      if (b.data.index() != 1 || std::get<Command>(b.data) != cmd)
        continue;
      const std::string chord = Gui_hotkeys::format_chord(m_hotkeys.chord_for(action));
      b.tooltip               = std::string(base) + " (" + chord + ")";
      return;
    }
  };

  // clang-format off
  tip_mode(Mode::Move,                          "Shape move",                      Gui_action::Mode_move);
  tip_mode(Mode::Rotate,                        "Shape rotate",                    Gui_action::Mode_rotate);
  tip_mode(Mode::Scale,                         "Shape Scale",                     Gui_action::Mode_scale);
  tip_mode(Mode::Shape_cyl_align,               "Align cylinders",                 Gui_action::Mode_cyl_align);
  tip_mode(Mode::Sketch_dim_anno,               "Length dimension",                Gui_action::Mode_dimension);
  tip_mode(Mode::Sketch_face_extrude,           "Extrude sketch face",             Gui_action::Mode_extrude);
  tip_mode(Mode::Shape_chamfer,                 "Chamfer",                         Gui_action::Mode_chamfer);
  tip_mode(Mode::Shape_fillet,                  "Fillet",                          Gui_action::Mode_fillet);
  tip_mode(Mode::Sketch_inspection_mode,        "Sketch inspection mode",          Gui_action::Mode_sketch_inspection);
  tip_mode(Mode::Sketch_from_planar_face,       "Create a sketch from planar face", Gui_action::Mode_sketch_from_face);
  tip_mode(Mode::Sketch_operation_axis,         "Operational axis",                Gui_action::Mode_operation_axis);
  tip_mode(Mode::Sketch_add_node,               "Add node",                        Gui_action::Mode_add_node);
  tip_mode(Mode::Sketch_add_edge,               "Add line edge",                   Gui_action::Mode_add_edge);
  tip_mode(Mode::Sketch_add_multi_edges,        "Add multi-line edge",             Gui_action::Mode_add_multi_edges);
  tip_mode(Mode::Sketch_add_seg_circle_arc,     "Add arc circle",                  Gui_action::Mode_add_arc);
  tip_mode(Mode::Sketch_add_square,             "Add square",                      Gui_action::Mode_add_square);
  tip_mode(Mode::Sketch_add_rectangle,          "Add rectangle from two points",   Gui_action::Mode_add_rectangle);
  tip_mode(Mode::Sketch_add_rectangle_center_pt,"Add rectangle with center point", Gui_action::Mode_add_rectangle_center);
  tip_mode(Mode::Sketch_add_circle,             "Add circle",                      Gui_action::Mode_add_circle);
  tip_mode(Mode::Sketch_add_circle_3_pts,       "Add circle from three points",    Gui_action::Mode_add_circle_3_pts);
  tip_mode(Mode::Sketch_add_slot,               "Add slot",                        Gui_action::Mode_add_slot);
  tip_mode(Mode::Shape_polar_duplicate,         "Shape polar duplicate",           Gui_action::Mode_polar_duplicate);
  tip_mode(Mode::Shape_cross_section,           "Shape cross-section",             Gui_action::Mode_cross_section);
  tip_cmd(Command::Shape_cut,                   "Shape cut",                       Gui_action::Cmd_shape_cut);
  tip_cmd(Command::Shape_fuse,                  "Shape fuse",                      Gui_action::Cmd_shape_fuse);
  tip_cmd(Command::Shape_common,                "Shape common",                    Gui_action::Cmd_shape_common);
  // clang-format on
}

void GUI::load_examples_list_()
{
  m_example_files.clear();
#ifdef __EMSCRIPTEN__
  const std::filesystem::path examples_dir("/res/examples");
#else
  const std::filesystem::path examples_dir("res/examples");
#endif
  if (!std::filesystem::is_directory(examples_dir))
    return;

  for (const auto& entry : std::filesystem::directory_iterator(examples_dir))
  {
    if (!entry.is_regular_file())
      continue;

    const auto& p = entry.path();
    if (p.extension() != ".ezy")
      continue;

    std::string path  = p.string();
    std::string label = p.filename().string();
    m_example_files.push_back(Example_file{std::move(label), std::move(path)});
  }

  std::sort(m_example_files.begin(), m_example_files.end(),
            [](const Example_file& a, const Example_file& b) { return a.label < b.label; });
}

void GUI::seed_default_dock_layout_(ImGuiID dockspace_id)
{
  ImGui::DockBuilderRemoveNode(dockspace_id);
  // Cast private DockSpace flag: mixing ImGuiDockNodeFlagsPrivate_ with ImGuiDockNodeFlags_
  // triggers -Wdeprecated-enum-enum-conversion (e.g. emscripten/clang).
  ImGui::DockBuilderAddNode(dockspace_id, static_cast<ImGuiDockNodeFlags>(ImGuiDockNodeFlags_DockSpace) |
                                              ImGuiDockNodeFlags_PassthruCentralNode);
  ImGui::DockBuilderSetNodeSize(dockspace_id, ImGui::GetMainViewport()->WorkSize);

  ImGuiID dock_main        = dockspace_id;
  ImGuiID dock_left        = ImGui::DockBuilderSplitNode(dock_main, ImGuiDir_Left, 0.20f, nullptr, &dock_main);
  ImGuiID dock_right       = ImGui::DockBuilderSplitNode(dock_main, ImGuiDir_Right, 0.22f, nullptr, &dock_main);
  ImGuiID dock_bottom      = ImGui::DockBuilderSplitNode(dock_main, ImGuiDir_Down, 0.12f, nullptr, &dock_main);
  ImGuiID dock_left_bottom = 0;
  ImGuiID dock_left_top    = ImGui::DockBuilderSplitNode(dock_left, ImGuiDir_Down, 0.52f, &dock_left_bottom, &dock_left);

  ImGui::DockBuilderDockWindow("Shape List", dock_left_top);
  ImGui::DockBuilderDockWindow("Sketch List", dock_left_bottom);
  ImGui::DockBuilderDockWindow("Options", dock_right);
  ImGui::DockBuilderDockWindow("Log", dock_bottom);
  ImGui::DockBuilderFinish(dockspace_id);
}

bool GUI::occt_wants_mouse_at(const float x, const float y) const
{
  if (!m_occt_passthrough_valid)
    return false;

  return x >= m_occt_passthrough_min[0] && x < m_occt_passthrough_max[0] && y >= m_occt_passthrough_min[1] &&
         y < m_occt_passthrough_max[1];
}

ScreenCoords GUI::cursor_screen_coords() const
{
  EZY_ASSERT(m_glfw_window != nullptr);
  double x = 0.0;
  double y = 0.0;
  glfwGetCursorPos(m_glfw_window, &x, &y);
  return ScreenCoords(dvec2(x, y));
}

void GUI::dock_space_()
{
  m_occt_passthrough_valid = false;

  const ImGuiID dockspace_id = ImGui::DockSpaceOverViewport(ImGui::GetID("EzyCadMainDockSpace"), ImGui::GetMainViewport(),
                                                            ImGuiDockNodeFlags_PassthruCentralNode);

  if (m_seed_default_dock_layout)
  {
    seed_default_dock_layout_(dockspace_id);
    m_seed_default_dock_layout = false;
  }

  if (ImGuiDockNode* node = ImGui::DockBuilderGetNode(dockspace_id))
    if (ImGuiDockNode* central = node->CentralNode; central && central->IsEmpty())
    {
      m_occt_passthrough_min[0] = central->Pos.x;
      m_occt_passthrough_min[1] = central->Pos.y;
      m_occt_passthrough_max[0] = central->Pos.x + central->Size.x;
      m_occt_passthrough_max[1] = central->Pos.y + central->Size.y;
      m_occt_passthrough_valid  = true;

      const ImVec2 mouse = ImGui::GetIO().MousePos;
      if (occt_wants_mouse_at(mouse.x, mouse.y))
        ImGui::SetNextFrameWantCaptureMouse(false);
    }
}

void GUI::menu_bar_()
{
  if (!ImGui::BeginMainMenuBar())
    return;

  if (ImGui::BeginMenu("File"))
  {
    // Use separate `if` (not `else if`) for each entry. `BeginMenu` stays true while the submenu
    // is open; chaining with `else if` would skip later items (e.g. Examples hidden while Export open).
    if (ImGui::MenuItem("New", "Ctrl+N"))
      new_project_();

    if (ImGui::MenuItem("Open", "Ctrl+O"))
      open_file_dialog_();

    if (ImGui::MenuItem("Save", "Ctrl+S"))
      save_file_dialog_();

    if (ImGui::MenuItem("Save as"))
    {
      m_last_saved_path.clear(); // Force save as dialog
      save_file_dialog_();
    }

    if (ImGui::BeginMenu("Project units"))
    {
      const Project_unit cur = m_view->get_project_unit();
      if (ImGui::MenuItem("Inches", nullptr, cur == Project_unit::Inch))
        m_view->set_project_unit(Project_unit::Inch);
      if (ImGui::MenuItem("Millimeters", nullptr, cur == Project_unit::Millimeter))
        m_view->set_project_unit(Project_unit::Millimeter);
      ImGui::EndMenu();
    }

    if (ui_show_feature(2))
    {
      if (ImGui::MenuItem("Import"))
        import_file_dialog_();
    }

    if (ImGui::BeginMenu("Export"))
    {
      if (ImGui::MenuItem("STEP (.step)..."))
        open_export_units_dialog_(Export_format::Step);

      if (ImGui::MenuItem("IGES (.igs)..."))
        open_export_units_dialog_(Export_format::Iges);

      if (ImGui::MenuItem("STL (binary)..."))
        open_export_units_dialog_(Export_format::Stl);

      if (ImGui::MenuItem("PLY (binary)..."))
        open_export_units_dialog_(Export_format::Ply);

      ImGui::EndMenu();
    }

    if (ui_show_feature(2) && ImGui::BeginMenu("Examples"))
    {
      for (const Example_file& ex : m_example_files)
        if (ImGui::MenuItem(ex.label.c_str()))
        {
          std::ifstream     file(ex.path, std::ios::binary);
          const std::string file_bytes{std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>()};
          if (file.good() && !file_bytes.empty())
            on_file(ex.path, file_bytes);
          else
            show_message("Error opening example: " + ex.label);
        }

      ImGui::EndMenu();
    }
#ifdef __EMSCRIPTEN__
    if (ImGui::MenuItem("Save settings"))
    {
      save_occt_view_settings();
      show_message("Settings saved");
    }
#endif

    if (ImGui::MenuItem("Exit"))
      exit(0);

    ImGui::EndMenu();
  }

  if (ImGui::BeginMenu("Edit"))
  {
    if (ImGui::MenuItem("Undo", "Ctrl+Z", false, m_view->can_undo()))
      m_view->undo();

    if (ImGui::MenuItem("Redo", "Ctrl+Y", false, m_view->can_redo()))
      m_view->redo();

    add_menu_items_();

    ImGui::EndMenu();
  }

  if (ImGui::BeginMenu("View"))
  {
    bool save_panes = false;
    if (ImGui::MenuItem("Settings", nullptr, m_show_settings_dialog))
    {
      m_show_settings_dialog = !m_show_settings_dialog;
      save_panes             = true;
    }

    if (ui_show_feature(1))
    {
      if (ImGui::MenuItem("Options", nullptr, m_show_options))
      {
        m_show_options = !m_show_options;
        save_panes     = true;
      }

      if (ImGui::MenuItem("Sketch List", nullptr, m_show_sketch_list))
      {
        m_show_sketch_list = !m_show_sketch_list;
        save_panes         = true;
      }

      if (ImGui::MenuItem("Shape List", nullptr, m_show_shape_list))
      {
        m_show_shape_list = !m_show_shape_list;
        save_panes        = true;
      }

      if (ImGui::MenuItem("Log", nullptr, m_log_window_visible))
      {
        m_log_window_visible = !m_log_window_visible;
        save_panes           = true;
      }
    }

    if (ui_show_feature(2))
    {
      if (ImGui::MenuItem("Lua Console", nullptr, m_show_lua_console))
      {
        m_show_lua_console = !m_show_lua_console;
        save_panes         = true;
      }

      if (ui_show_contextual_help() && ImGui::IsItemHovered())
        ImGui::SetTooltip("Interactive Lua prompt and res/scripts/lua editors.");

      if (ImGui::MenuItem("Python Console", nullptr, m_show_python_console))
      {
        m_show_python_console = !m_show_python_console;
        save_panes            = true;
      }
    }
#ifndef NDEBUG
    if (ImGui::MenuItem("Debug", nullptr, m_show_dbg))
    {
      m_show_dbg = !m_show_dbg;
      save_panes = true;
    }
#endif
    if (save_panes)
      save_occt_view_settings();

    ImGui::EndMenu();
  }

  if (ImGui::BeginMenu("Help"))
  {
    if (ImGui::MenuItem("About"))
      m_open_about_popup = true;

    if (ImGui::MenuItem("Usage Guide"))
      open_url_("https://ezycad.readthedocs.io/en/latest/usage.html");

    ImGui::EndMenu();
  }

  ImGui::EndMainMenuBar();
}

void GUI::about_dialog_()
{
  if (m_open_about_popup)
  {
    m_about_popup_open = true;
    ImGui::SetNextWindowSize(ImVec2(520.0f, 520.0f), ImGuiCond_Appearing);
    ImGui::OpenPopup("About");
    m_open_about_popup = false;
  }

  if (!ImGui::BeginPopupModal("About", &m_about_popup_open, ImGuiWindowFlags_None))
    return;

  ensure_about_assets_();

  ImFont*               font = ImGui::GetFont();
  ImGui::MarkdownConfig md;

  md.linkCallback      = about_markdown_link_cb_;
  md.imageCallback     = about_markdown_image_cb_;
  md.tooltipCallback   = ImGui::defaultMarkdownTooltipCallback;
  md.linkIcon          = "";
  md.headingFormats[0] = {font, true};
  md.headingFormats[1] = {font, true};
  md.headingFormats[2] = {font, false};
  md.userData          = this;

  float const fs                = ImGui::GetFontSize();
  md.headingFormats[0].fontSize = fs * 1.15f;
  md.headingFormats[1].fontSize = fs * 1.05f;
  md.headingFormats[2].fontSize = fs;

  ImGui::BeginChild("AboutMd", ImVec2(0.0f, 0.0f), true, ImGuiWindowFlags_HorizontalScrollbar);
  ImGui::Markdown(m_about_markdown.c_str(), m_about_markdown.size(), md);
  ImGui::EndChild();

  ImGui::EndPopup();
}

std::string GUI::project_title_segment_() const
{
  if (m_last_saved_path.empty() || m_last_saved_path == "(startup)")
    return "untitled";

  try
  {
    const std::string fn = std::filesystem::path(m_last_saved_path).filename().string();
    if (fn.empty())
      return "untitled";

    return fn;
  }

  catch (...)
  {
    return "untitled";
  }
}

void GUI::update_window_title_()
{
  EZY_ASSERT(m_glfw_window != nullptr);

  const std::string title = std::string("EzyCad ") + EZYCAD_VERSION_STRING + " - " + project_title_segment_();
  if (title == m_cached_window_title)
    return;

  m_cached_window_title = title;
  glfwSetWindowTitle(m_glfw_window, m_cached_window_title.c_str());
}

void GUI::open_url_(const std::string& url)
{
#ifdef __EMSCRIPTEN__
  // For Emscripten, use JavaScript's window.open()
  // Use EM_ASM for safer execution
  EM_ASM_({ window.open(UTF8ToString($0), '_blank'); }, url.c_str());
#else
  // For native builds, use platform-specific system commands
  std::string cmd;
#ifdef _WIN32
  // Windows: Use 'start' command
  cmd = "start \"\" \"";
  cmd += url;
  cmd += "\"";
#elif defined(__APPLE__)
  // TODO test on macOS
  // macOS: Use 'open' command
  cmd = "open \"";
  cmd += url;
  cmd += "\"";
#else
  // TODO test on Linux
  // Linux and other Unix-like systems: Use 'xdg-open'
  cmd = "xdg-open \"";
  cmd += url;
  cmd += "\"";
#endif
  system(cmd.c_str());
#endif
}

void GUI::doc_help_button_(const char* scope, int line, const char* tooltip, const char* doc_url, bool trailing_same_line)
{
  if (!ui_show_contextual_help())
    return;

  ImGui::PushID(scope);
  ImGui::PushID(line);
  if (ImGui::SmallButton("?"))
    if (doc_url && doc_url[0] != '\0')
      open_url_(doc_url);

  ImGui::PopID();
  ImGui::PopID();

  if (ImGui::IsItemHovered())
    ImGui::SetTooltip("%s", tooltip);

  if (trailing_same_line)
    ImGui::SameLine(0.0f, ImGui::GetStyle().ItemInnerSpacing.x);
}

void GUI::ensure_about_assets_()
{
  if (m_about_assets_loaded)
    return;

  m_about_assets_loaded = true;

  const char* md_paths[] = {
#ifdef __EMSCRIPTEN__
      "/res/about.md",
#endif
      "res/about.md",
  };

  for (const char* p : md_paths)
  {
    std::ifstream f(p);
    if (!f)
      continue;

    m_about_markdown.assign(std::istreambuf_iterator<char>(f), std::istreambuf_iterator<char>());
    break;
  }
  if (m_about_markdown.empty())
    m_about_markdown = "Could not load res/about.md.\n";
  else
    m_about_markdown = std::string("**EzyCad ") + EZYCAD_VERSION_STRING + "**\n\n" + m_about_markdown;

  m_about_markdown += "\n\nOpen CASCADE ";
  m_about_markdown += OCC_VERSION_STRING_EXT;
  m_about_markdown += "\nDear ImGui ";
  m_about_markdown += IMGUI_VERSION;
  m_about_markdown += "\nnlohmann/json ";
  m_about_markdown += std::to_string(NLOHMANN_JSON_VERSION_MAJOR);
  m_about_markdown += '.';
  m_about_markdown += std::to_string(NLOHMANN_JSON_VERSION_MINOR);
  m_about_markdown += '.';
  m_about_markdown += std::to_string(NLOHMANN_JSON_VERSION_PATCH);
  m_about_markdown += "\ntinyfiledialogs ";
  m_about_markdown += tinyfd_version;
  m_about_markdown += "\nImGuiColorTextEdit ";
  m_about_markdown += EZYCAD_IMGUI_COLOR_TEXT_EDIT_REF;
  m_about_markdown += "\n";

  const char* png_paths[] = {
#ifdef __EMSCRIPTEN__
      "/res/AI-gen-splashscreen_05_01_2026_512.png",
#endif
      "res/AI-gen-splashscreen_05_01_2026_512.png",
  };
  for (const char* p : png_paths)
  {
    if (!std::filesystem::exists(p))
      continue;

    std::ifstream fi(p, std::ios::binary);
    if (!fi)
      continue;

    std::string bytes((std::istreambuf_iterator<char>(fi)), std::istreambuf_iterator<char>());
    if (auto dec = decode_image_bytes(bytes))
    {
      m_about_splash_size.x = std::get<1>(*dec);
      m_about_splash_size.y = std::get<2>(*dec);
    }
    m_about_splash_gl = load_texture(p);
    break;
  }
}

ImGui::MarkdownImageData GUI::about_markdown_image_(ImGui::MarkdownLinkCallbackData data)
{
  ImGui::MarkdownImageData out{};
  if (!data.isImage)
    return out;

  static constexpr char k_splash_id[] = "AI-gen-splashscreen_05_01_2026_512.png";
  std::string           id(data.link, data.linkLength);
  if (id != k_splash_id || m_about_splash_gl == 0)
    return out;

  out.isValid         = true;
  out.useLinkCallback = false;
  out.user_texture_id = (ImTextureID)(intptr_t)m_about_splash_gl;
  out.size            = ImVec2((float)m_about_splash_size.x, (float)m_about_splash_size.y);
  ImVec2 const avail  = ImGui::GetContentRegionAvail();
  if (out.size.x > avail.x && avail.x > 1.0f)
  {
    float const ratio = out.size.y / out.size.x;
    out.size.x        = avail.x;
    out.size.y        = avail.x * ratio;
  }
  return out;
}

void GUI::about_markdown_link_cb_(ImGui::MarkdownLinkCallbackData data)
{
  if (data.isImage || !data.userData)
    return;

  std::string url(data.link, data.linkLength);
  static_cast<GUI*>(data.userData)->open_url_(url);
}

ImGui::MarkdownImageData GUI::about_markdown_image_cb_(ImGui::MarkdownLinkCallbackData data)
{
  if (!data.userData)
    return {};

  return static_cast<GUI*>(data.userData)->about_markdown_image_(data);
}

// Render toolbar with ImGui
void GUI::toolbar_()
{
  ImGui::Begin("Toolbar", nullptr,
               ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoDocking);

  ImVec2 button_size(32, 32);

  for (int i = 0; i < m_toolbar_buttons.size(); i++)
  {
    ImGui::PushID(i);

    bool was_active = false;
    if (m_toolbar_buttons[i].is_active)
    {
      ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.26f, 0.59f, 0.98f, 1.00f));
      ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.26f, 0.59f, 0.98f, 1.00f));
      ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(0.06f, 0.53f, 0.98f, 1.00f));
      was_active = true;
    }

    // Add a unique string ID (e.g., "button0", "button1", etc.)
    char button_id[16];
    snprintf(button_id, sizeof(button_id), "button%d", i);
    if (ImGui::ImageButton(button_id, (ImTextureID)(intptr_t)m_toolbar_buttons[i].texture_id, button_size))
    {
      if (m_toolbar_buttons[i].data.index() == 1)
        switch (std::get<Command>(m_toolbar_buttons[i].data))
        {
        case Command::Shape_cut:
          if (Status s = m_view->shp_cut().selected_cut(); !s.is_ok())
            show_message(s.message());

          break;

        case Command::Shape_fuse:
          if (Status s = m_view->shp_fuse().selected_fuse(); !s.is_ok())
            show_message(s.message());

          break;

        case Command::Shape_common:
          if (Status s = m_view->shp_common().selected_common(); !s.is_ok())
            show_message(s.message());

          break;

        default:
          EZY_ASSERT(false);
        }
      else
        set_mode(std::get<Mode>(m_toolbar_buttons[i].data));
    }

    if (ui_show_help(1) && ImGui::IsItemHovered())
      ImGui::SetTooltip("%s", m_toolbar_buttons[i].tooltip.c_str());

    if (was_active)
      ImGui::PopStyleColor(3);

    ImGui::SameLine();
    ImGui::PopID();
  }

  ImGui::End();
}

// Distance edit related
void GUI::set_dist_edit(float dist, std::function<void(float, bool)>&& callback,
                        const std::optional<ScreenCoords> screen_coords)
{
  // Sketch calls this every mousemove while TAB length mode is on; do not reset value/position each frame
  // or typed distance is replaced by the rubber-band length at the cursor.
  const bool already_editing = m_dist_callback != nullptr;
  if (!already_editing)
  {
    m_dist_val = dist;
    std::snprintf(m_dist_text_buf.data(), m_dist_text_buf.size(), "%.9g", static_cast<double>(dist));
    if (screen_coords.has_value())
      m_dist_edit_loc = *screen_coords;
    else
      m_dist_edit_loc = cursor_screen_coords();
  }

  m_dist_callback = std::move(callback);
  if (!already_editing)
    m_dist_edit_focus_pending = true;
}

void GUI::hide_dist_edit(bool apply)
{
  if (!m_dist_callback)
    return;

  float parsed{};
  if (parse_dist_text_to_float_(m_dist_text_buf.data(), parsed))
    m_dist_val = parsed;

  std::function<void(float, bool)> callback;
  std::swap(callback, m_dist_callback);
  if (apply)
    callback(m_dist_val, true);
}

void GUI::dist_edit_()
{
  if (!m_dist_callback)
    return;

  //  Set the position of the next window
  ImGui::SetNextWindowPos(ImVec2(float(m_dist_edit_loc.unsafe_get_x()), float(m_dist_edit_loc.unsafe_get_y())),
                          ImGuiCond_Always);

  // Set a small size (optional)
  ImGui::SetNextWindowSize(ImVec2(120.0f, 25.0f), ImGuiCond_Once);

  // Begin a window with minimal flags
  ImGui::Begin("FloatEdit##unique_id", nullptr,
               ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_AlwaysAutoResize |
                   ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoMouseInputs);

  ImGui::SetNextItemWidth(100.0f);
  // Focusing every frame prevents IsItemDeactivatedAfterEdit (click away / Tab) from ever committing.
  if (m_dist_edit_focus_pending)
  {
    ImGui::SetKeyboardFocusHere(0);
    m_dist_edit_focus_pending = false;
  }

  // Text field: InputFloat applies printf rounding so typed digits can disagree with m_dist_val.
  const bool text_changed = ImGui::InputText("##dist_edit_text", m_dist_text_buf.data(), m_dist_text_buf.size(),
                                             ImGuiInputTextFlags_CharsDecimal | ImGuiInputTextFlags_CharsScientific);
  // Snapshot before unit suffix Text; that widget becomes LastItem and would hide Enter/click-away commit.
  const bool deactivated_after_edit = ImGui::IsItemDeactivatedAfterEdit();

  ImGui::SameLine(0.0f, ImGui::GetStyle().ItemInnerSpacing.x);
  ImGui::TextUnformatted(m_view->project_unit_suffix());

  if (text_changed && parse_dist_text_to_float_(m_dist_text_buf.data(), m_dist_val))
    m_dist_callback(m_dist_val, false);

  if (deactivated_after_edit && m_dist_callback)
  {
    if (ImGui::IsKeyPressed(ImGuiKey_Escape))
    {
      hide_dist_edit(false);
      return;
    }

    float parsed{};
    if (parse_dist_text_to_float_(m_dist_text_buf.data(), parsed))
      m_dist_val = parsed;

    std::function<void(float, bool)> callback;
    std::swap(callback, m_dist_callback);
    callback(m_dist_val, true);
  }

  ImGui::End();
}

// Angle edit related
void GUI::set_angle_edit(float angle, std::function<void(float, bool)>&& callback,
                         const std::optional<ScreenCoords> screen_coords)
{
  const bool already_editing = m_angle_callback != nullptr;
  if (!already_editing)
  {
    m_angle_val = angle;
    std::snprintf(m_angle_text_buf.data(), m_angle_text_buf.size(), "%.9g", static_cast<double>(angle));
    if (screen_coords.has_value())
      m_angle_edit_loc = *screen_coords;
    else
      m_angle_edit_loc = cursor_screen_coords();
  }

  m_angle_callback = std::move(callback);
  if (!already_editing)
    m_angle_edit_focus_pending = true;
}

void GUI::hide_angle_edit(bool apply)
{
  if (!m_angle_callback)
    return;

  float parsed{};
  if (parse_dist_text_to_float_(m_angle_text_buf.data(), parsed))
    m_angle_val = parsed;

  std::function<void(float, bool)> callback;
  std::swap(callback, m_angle_callback);
  if (apply)
    callback(m_angle_val, true);
}

bool GUI::is_dist_or_angle_edit_active() const { return m_dist_callback != nullptr || m_angle_callback != nullptr; }

bool GUI::is_sketch_origin_set_edit_active() const { return m_sketch_origin_set_plane_idx >= 0; }

void GUI::open_sketch_origin_set_edit_(const Sketch::sptr& sk, int plane_idx, double v_min, double v_max)
{
  EZY_ASSERT(sk);
  EZY_ASSERT(plane_idx == 0 || plane_idx == 1);

  m_sketch_origin_set_sketch        = sk;
  m_sketch_origin_set_plane_idx     = plane_idx;
  m_sketch_origin_set_v_min         = v_min;
  m_sketch_origin_set_v_max         = v_max;
  m_sketch_origin_set_loc           = ImGui::GetItemRectMin();
  m_sketch_origin_set_focus_pending = true;
  std::snprintf(m_sketch_origin_set_text_buf.data(), m_sketch_origin_set_text_buf.size(), "%.9g",
                m_sketch_origin_xy[plane_idx]);
}

void GUI::hide_sketch_origin_set_edit(bool apply)
{
  if (m_sketch_origin_set_plane_idx < 0)
    return;

  const Sketch::sptr sk         = m_sketch_origin_set_sketch.lock();
  const int          plane_idx  = m_sketch_origin_set_plane_idx;
  const double       v_min      = m_sketch_origin_set_v_min;
  const double       v_max      = m_sketch_origin_set_v_max;
  m_sketch_origin_set_plane_idx = -1;
  m_sketch_origin_set_sketch.reset();

  if (!sk || !apply)
    return;

  float parsed{};
  if (!parse_dist_text_to_float_(m_sketch_origin_set_text_buf.data(), parsed))
    return;

  m_sketch_origin_xy[plane_idx] = std::clamp(static_cast<double>(parsed), v_min, v_max);
  sk->set_origin_pt(gp_Pnt2d(m_sketch_origin_xy[0], m_sketch_origin_xy[1]));
  m_view->ctx().UpdateCurrentViewer();
}

void GUI::sketch_origin_set_edit_()
{
  if (m_sketch_origin_set_plane_idx < 0)
    return;

  if (!m_sketch_origin_set_sketch.lock())
  {
    m_sketch_origin_set_plane_idx = -1;
    return;
  }

  ImGui::SetNextWindowPos(m_sketch_origin_set_loc, ImGuiCond_Always);
  ImGui::SetNextWindowSize(ImVec2(120.0f, 25.0f), ImGuiCond_Once);
  ImGui::Begin("OriginSetEdit##unique_id", nullptr,
               ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_AlwaysAutoResize |
                   ImGuiWindowFlags_NoSavedSettings);

  ImGui::SetNextItemWidth(100.0f);
  if (m_sketch_origin_set_focus_pending)
  {
    ImGui::SetKeyboardFocusHere(0);
    m_sketch_origin_set_focus_pending = false;
  }

  ImGui::InputText("##origin_set_text", m_sketch_origin_set_text_buf.data(), m_sketch_origin_set_text_buf.size(),
                   ImGuiInputTextFlags_CharsDecimal | ImGuiInputTextFlags_CharsScientific);

  if (ImGui::IsItemDeactivatedAfterEdit())
    hide_sketch_origin_set_edit(true);

  ImGui::End();
}

void GUI::angle_edit_()
{
  if (!m_angle_callback)
    return;

  //  Set the position of the next window
  ImGui::SetNextWindowPos(ImVec2(float(m_angle_edit_loc.unsafe_get_x()), float(m_angle_edit_loc.unsafe_get_y())),
                          ImGuiCond_Always);

  // Set a small size (optional)
  ImGui::SetNextWindowSize(ImVec2(120.0f, 25.0f), ImGuiCond_Once);

  // Begin a window with minimal flags
  ImGui::Begin("AngleEdit##unique_id", nullptr,
               ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_AlwaysAutoResize |
                   ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoMouseInputs);

  ImGui::SetNextItemWidth(100.0f);
  if (m_angle_edit_focus_pending)
  {
    ImGui::SetKeyboardFocusHere(0);
    m_angle_edit_focus_pending = false;
  }

  const bool text_changed = ImGui::InputText("##angle_edit_text", m_angle_text_buf.data(), m_angle_text_buf.size(),
                                             ImGuiInputTextFlags_CharsDecimal | ImGuiInputTextFlags_CharsScientific);
  // Snapshot before "deg" Text; that widget becomes LastItem and would hide Enter/click-away commit.
  const bool deactivated_after_edit = ImGui::IsItemDeactivatedAfterEdit();

  ImGui::SameLine(0.0f, ImGui::GetStyle().ItemInnerSpacing.x);
  ImGui::TextUnformatted("deg");

  if (text_changed && parse_dist_text_to_float_(m_angle_text_buf.data(), m_angle_val))
    m_angle_callback(m_angle_val, false);

  if (deactivated_after_edit && m_angle_callback)
  {
    if (ImGui::IsKeyPressed(ImGuiKey_Escape))
    {
      hide_angle_edit(false);
      return;
    }

    float parsed{};
    if (parse_dist_text_to_float_(m_angle_text_buf.data(), parsed))
      m_angle_val = parsed;

    std::function<void(float, bool)> callback;
    std::swap(callback, m_angle_callback);
    callback(m_angle_val, true);
  }

  ImGui::End();
}

bool GUI::parse_dist_text_to_float_(const char* buf, float& out)
{
  if (!buf)
    return false;

  const char* s = buf;
  while (*s != '\0' && std::isspace(static_cast<unsigned char>(*s)))
    ++s;
  if (*s == '\0')
    return false;

  char*       end = nullptr;
  const float v   = std::strtof(s, &end);
  if (end == s)
    return false;

  while (*end != '\0' && std::isspace(static_cast<unsigned char>(*end)))
    ++end;
  if (*end != '\0')
    return false;

  out = v;
  return true;
}

bool GUI::is_valid_project_manifest_(const std::string& s)
{
  try
  {
    const nlohmann::json j = nlohmann::json::parse(s);
    return j.contains("sketches") && j["sketches"].is_array();
  }
  catch (...)
  {
    return false;
  }
}

bool GUI::is_valid_project_file_(const std::string& bytes)
{
  if (is_ezy_zip(bytes))
  {
    const auto unpacked = unpack_ezy(bytes);
    return unpacked && is_valid_project_manifest_(unpacked->manifest_json);
  }

  return is_ezy_json(bytes) && is_valid_project_manifest_(bytes);
}

std::optional<std::string> GUI::manifest_from_project_file_(const std::string& file_bytes, Occt_view& view, bool replace_assets)
{
  if (is_ezy_zip(file_bytes))
  {
    auto unpacked = unpack_ezy(file_bytes);
    if (!unpacked)
      return std::nullopt;

    if (replace_assets)
      view.asset_store().clear();

    for (auto& [id, data] : unpacked->assets)
      view.asset_store().import_asset(id, std::move(data));

    return unpacked->manifest_json;
  }

  if (is_ezy_json(file_bytes))
    return file_bytes;

  return std::nullopt;
}

const std::vector<std::string>& GUI::occt_material_combo_labels_()
{
  static std::vector<std::string> names;
  if (names.empty())
    for (int i = 0; i < Graphic3d_MaterialAspect::NumberOfMaterials(); ++i)
    {
      Graphic3d_MaterialAspect mat(static_cast<Graphic3d_NameOfMaterial>(i));
      names.emplace_back(mat.MaterialName());
    }

  return names;
}

void GUI::sketch_list_inspector_(const Sketch::sptr& sketch, int index, Sketch_list_row_ui& row_ui,
                                 Sketch::sptr& hover_dim_sketch, size_t& hover_dim_index, Sketch::sptr& hover_face_sketch,
                                 size_t& hover_face_index, Sketch::sptr& hover_edge_sketch, size_t& hover_edge_index,
                                 Sketch::sptr& hover_node_sketch, size_t& hover_node_index)
{
  ImGui::Indent();
  ImGui::PushID(index);

  const auto sync_tree_open = [](bool& open_state, bool open)
  {
    if (open != open_state)
      open_state = open;
  };

  const auto draw_hover_section = [&](const char* title, const std::vector<std::string>& labels, bool& open_state,
                                      Sketch::sptr& hover_sketch, size_t& hover_index)
  {
    const size_t       count = labels.size();
    ImGuiTreeNodeFlags flags = ImGuiTreeNodeFlags_SpanAvailWidth;
    if (count == 0)
      flags |= ImGuiTreeNodeFlags_Leaf | ImGuiTreeNodeFlags_NoTreePushOnOpen;

    ImGui::SetNextItemOpen(open_state);
    const bool open = ImGui::TreeNodeEx(title, flags, "%s (%zu)", title, count);
    sync_tree_open(open_state, open);
    if (!open)
      return;

    for (size_t i = 0; i < count; ++i)
    {
      ImGui::PushID(static_cast<int>(i));
      ImGui::BulletText("%s", labels[i].c_str());
      if (ImGui::IsItemHovered() && sketch->is_visible())
      {
        hover_sketch = sketch;
        hover_index  = i;
      }
      ImGui::PopID();
    }

    if (count > 0)
      ImGui::TreePop();
  };

  {
    const std::vector<std::string> labels = sketch->inspector_dimension_labels();
    const size_t                   count  = labels.size();
    ImGuiTreeNodeFlags             flags  = ImGuiTreeNodeFlags_SpanAvailWidth;
    if (count == 0)
      flags |= ImGuiTreeNodeFlags_Leaf | ImGuiTreeNodeFlags_NoTreePushOnOpen;

    ImGui::SetNextItemOpen(row_ui.dimensions);
    const bool open = ImGui::TreeNodeEx("Dimensions", flags, "Dimensions (%zu)", count);
    sync_tree_open(row_ui.dimensions, open);
    if (open)
    {
      if (count > 0 && ImGui::BeginTable("sketch_dim_rows", 3, ImGuiTableFlags_Resizable | ImGuiTableFlags_SizingStretchProp))
      {
        ImGui::TableSetupColumn("show", ImGuiTableColumnFlags_WidthFixed, 28.f);
        ImGui::TableSetupColumn("dim", ImGuiTableColumnFlags_WidthStretch);
        ImGui::TableSetupColumn("offset", ImGuiTableColumnFlags_WidthFixed, 120.f);

        for (size_t i = 0; i < count; ++i)
        {
          bool   visible     = sketch->dimension_visible(i);
          double offset      = sketch->dimension_offset(i);
          bool   row_hovered = false;

          ImGui::PushID(static_cast<int>(i));
          ImGui::TableNextRow();

          ImGui::TableSetColumnIndex(0);
          if (ImGui::Checkbox("##dim_visible", &visible))
            sketch->set_dimension_visible(i, visible);

          row_hovered |= ImGui::IsItemHovered();

          ImGui::TableSetColumnIndex(1);
          char        name_buf[128];
          std::string cur_name = sketch->dimension_name(i);
          safe_cstr_copy(name_buf, sizeof(name_buf), cur_name.c_str());
          ImGui::SetNextItemWidth(-FLT_MIN);
          if (ImGui::InputText("##dim_name", name_buf, sizeof(name_buf)))
            sketch->set_dimension_name(i, std::string(name_buf));

          row_hovered |= ImGui::IsItemHovered();

          ImGui::TableSetColumnIndex(2);
          ImGui::SetNextItemWidth(86.f);
          if (ImGui::InputDouble("##dim_offset", &offset, 0.5, 2.0, "%.2f"))
            sketch->set_dimension_offset(i, offset);

          row_hovered |= ImGui::IsItemHovered();

          if (ui_show_contextual_help() && ImGui::IsItemHovered())
            ImGui::SetTooltip("Label offset from edge. 0 = automatic.");

          if (row_hovered && sketch->is_visible() && sketch->shows_dimensions() && visible &&
              !sketch->length_dimension_handle(i).IsNull())
          {
            hover_dim_sketch = sketch;
            hover_dim_index  = i;
          }

          ImGui::PopID();
        }

        ImGui::EndTable();
      }

      if (count > 0)
        ImGui::TreePop();
    }
  }

  draw_hover_section("Nodes", sketch->inspector_node_labels(), row_ui.nodes, hover_node_sketch, hover_node_index);
  draw_hover_section("Edges", sketch->inspector_edge_labels(), row_ui.edges, hover_edge_sketch, hover_edge_index);

  {
    const std::vector<std::string> labels = sketch->inspector_face_labels();
    const size_t                   count  = labels.size();
    ImGuiTreeNodeFlags             flags  = ImGuiTreeNodeFlags_SpanAvailWidth;
    if (count == 0)
      flags |= ImGuiTreeNodeFlags_Leaf | ImGuiTreeNodeFlags_NoTreePushOnOpen;

    ImGui::SetNextItemOpen(row_ui.faces);
    const bool open = ImGui::TreeNodeEx("Faces", flags, "Faces (%zu)", count);
    sync_tree_open(row_ui.faces, open);
    if (open)
    {
      for (size_t i = 0; i < count; ++i)
      {
        bool row_hovered = false;

        ImGui::PushID(static_cast<int>(i));
        ImGui::AlignTextToFramePadding();
        ImGui::BulletText("%s", labels[i].c_str());
        row_hovered |= ImGui::IsItemHovered();
        if (ImGui::BeginPopupContextItem("face_extrude_ctx"))
        {
          if (ImGui::MenuItem("Extrude"))
            sketch_list_extrude_face_(sketch, i);
          ImGui::EndPopup();
        }
        ImGui::SameLine();
        if (ImGui::SmallButton("E"))
          sketch_list_extrude_face_(sketch, i);
        row_hovered |= ImGui::IsItemHovered();
        if (ui_show_contextual_help() && ImGui::IsItemHovered())
          ImGui::SetTooltip("Extrude this face");

        if (row_hovered && sketch->is_visible() && sketch->inspector_face(i))
        {
          hover_face_sketch = sketch;
          hover_face_index  = i;
        }

        ImGui::PopID();
      }

      if (count > 0)
        ImGui::TreePop();
    }
  }

  ImGui::PopID();
  ImGui::Unindent();
}

void GUI::sketch_list_extrude_face_(const Sketch::sptr& sketch, size_t face_index)
{
  EZY_ASSERT(sketch);
  const Sketch_face_shp_ptr face = sketch->inspector_face(face_index);
  if (!face)
    return;

  m_view->set_curr_sketch(sketch);
  set_mode(Mode::Sketch_face_extrude);
  m_view->begin_sketch_face_extrude(face);
}

void GUI::sketch_list_()
{
  if (!show_sketch_list_effective())
  {
    m_view->set_sketch_list_hover(nullptr);
    m_view->set_sketch_list_measurement_hover(nullptr, SIZE_MAX);
    m_view->set_sketch_list_hover_face(nullptr, SIZE_MAX);
    m_view->set_sketch_list_hover_edge(nullptr, SIZE_MAX);
    m_view->set_sketch_list_hover_node(nullptr, SIZE_MAX);
    return;
  }

  const ImGuiStyle& st              = ImGui::GetStyle();
  float             max_name_text_w = 0.f;
  for (const Sketch::sptr& s : m_view->get_sketches())
  {
    EZY_ASSERT(s);
    const std::string& nm = s->get_name();
    max_name_text_w       = std::max(max_name_text_w, ImGui::CalcTextSize(nm.c_str(), nm.c_str() + nm.size()).x);
  }

  if (!ImGui::Begin("Sketch List", &m_show_sketch_list, ImGuiWindowFlags_None))
  {
    m_view->set_sketch_list_hover(nullptr);
    m_view->set_sketch_list_measurement_hover(nullptr, SIZE_MAX);
    m_view->set_sketch_list_hover_face(nullptr, SIZE_MAX);
    m_view->set_sketch_list_hover_edge(nullptr, SIZE_MAX);
    m_view->set_sketch_list_hover_node(nullptr, SIZE_MAX);
    ImGui::End();
    return;
  }

  ImGui::BeginChild("##sketch_list_scroll", ImVec2(0.f, 0.f), false, ImGuiWindowFlags_HorizontalScrollbar);
  const float name_field_w = list_name_field_width_(st, max_name_text_w);

  int          index = 0;
  Sketch::sptr sketch_to_delete;
  Sketch::sptr sketch_list_hover;
  Sketch::sptr sketch_list_measurement_hover_sketch;
  size_t       sketch_list_measurement_hover_index = SIZE_MAX;
  Sketch::sptr sketch_list_hover_face_sketch;
  size_t       sketch_list_hover_face_index = SIZE_MAX;
  Sketch::sptr sketch_list_hover_edge_sketch;
  size_t       sketch_list_hover_edge_index = SIZE_MAX;
  Sketch::sptr sketch_list_hover_node_sketch;
  size_t       sketch_list_hover_node_index = SIZE_MAX;
  for (Sketch::sptr& sketch : m_view->get_sketches())
  {
    EZY_ASSERT(sketch);

    ImGui::BeginGroup();

    // Buffer for editable name
    char name_buffer[1024];
    safe_cstr_copy(name_buffer, sizeof(name_buffer), sketch->get_name().c_str());

    // Unique ID suffix using index
    std::string id_suffix = "##" + std::to_string(index);

    Sketch_list_row_ui& row_ui   = m_sketch_list_ui[sketch->get_id()];
    bool&               expanded = row_ui.expanded;

    if (ui_show_sketch_list_expand())
    {
      ImGui::PushID(("expand" + id_suffix).c_str());
      if (ImGui::SmallButton(expanded ? "v" : ">"))
        expanded = !expanded;

      if (ui_show_contextual_help() && ImGui::IsItemHovered())
        ImGui::SetTooltip(expanded ? "Collapse details" : "Expand details");

      ImGui::PopID();

      ImGui::SameLine();
    }

    // Radio button for selection
    ImGui::PushID(("select" + id_suffix).c_str());
    if (ImGui::RadioButton("", &m_view->curr_sketch() == sketch.get()))
    {
      m_view->set_curr_sketch(sketch);
      if (!is_sketch_mode(get_mode()))
        set_mode(Mode::Sketch_inspection_mode);
    }

    if (ui_show_contextual_help() && ImGui::IsItemHovered())
      ImGui::SetTooltip("Sets current");

    ImGui::PopID();

    // Text edit for name (width fits longest sketch name across the list, capped)
    ImGui::SameLine();
    ImGui::PushID(("name" + id_suffix).c_str());
    ImGui::SetNextItemWidth(name_field_w);
    if (ImGui::InputText("", name_buffer, sizeof(name_buffer)))
      sketch->set_name(std::string(name_buffer));

    // This will open a popup when you right-click on the InputText
    if (ImGui::BeginPopupContextItem("Sketch_InputTextContextMenu"))
    {
      if (ImGui::MenuItem("Delete"))
        sketch_to_delete = sketch;

      ImGui::EndPopup();
    }
    ImGui::PopID();

    // Checkbox for visibility, same line
    ImGui::SameLine();
    ImGui::PushID(("visible" + id_suffix).c_str());
    bool visible = sketch->is_visible();
    if (ImGui::Checkbox("", &visible))
    {
      if (!visible && m_view->sketch_list_hover() == sketch)
        m_view->set_sketch_list_hover(nullptr);

      sketch->set_visible(visible);
    }

    if (ui_show_contextual_help() && ImGui::IsItemHovered())
      ImGui::SetTooltip("Visibility");

    ImGui::PopID();

    ImGui::SameLine();
    ImGui::PushID(("uldisp" + id_suffix).c_str());
    {
      const bool has_ul = sketch->underlay().has_image();
      bool       dummy_off{false};
      bool       ul_vis = has_ul && sketch->underlay().visible();
      if (!has_ul)
        ImGui::BeginDisabled();

      bool* const vptr = has_ul ? &ul_vis : &dummy_off;
      if (ImGui::Checkbox("", vptr) && has_ul)
      {
        sketch->underlay().set_visible_sync(ul_vis, sketch->get_plane());
        if (m_underlay_panel_sketch == sketch.get())
          m_underlay_vis = ul_vis;
        if (m_view->sketch_list_hover() == sketch)
        {
          m_view->set_sketch_list_hover(nullptr);
          m_view->set_sketch_list_hover(sketch);
        }
      }

      if (!has_ul)
        ImGui::EndDisabled();

      if (ui_show_contextual_help() && ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled))
        ImGui::SetTooltip(has_ul ? "Display underlay" : "Import an image in Sketch properties to enable the underlay.");
    }
    ImGui::PopID();

    if (ui_show_sketch_list_props_slot())
    {
      ImGui::SameLine();
      ImGui::PushID(("props" + id_suffix).c_str());
      if (ui_show_sketch_list_props_button())
      {
        if (ImGui::SmallButton("[P]"))
        {
          m_view->set_curr_sketch(sketch);
          if (!is_sketch_mode(get_mode()))
            set_mode(Mode::Sketch_inspection_mode);
          m_sketch_properties_sketch = sketch;
          m_sketch_properties_open   = true;
        }

        if (ui_show_contextual_help() && ImGui::IsItemHovered())
          ImGui::SetTooltip("Sketch properties");
      }
      else
      {
        ImGui::BeginDisabled();
        ImGui::SmallButton("[P]");
        ImGui::EndDisabled();
        if (ui_show_contextual_help() && ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled))
          ImGui::SetTooltip("Sketch properties ([P]) unlocks at UI verbosity 3.");
      }

      ImGui::PopID();
    }

    ImGui::EndGroup();

    if (ImGui::IsItemHovered() && sketch->is_visible())
      sketch_list_hover = sketch;

    if (expanded && ui_show_sketch_list_expand())
      sketch_list_inspector_(sketch, index, row_ui, sketch_list_measurement_hover_sketch, sketch_list_measurement_hover_index,
                             sketch_list_hover_face_sketch, sketch_list_hover_face_index, sketch_list_hover_edge_sketch,
                             sketch_list_hover_edge_index, sketch_list_hover_node_sketch, sketch_list_hover_node_index);

    ++index;
  }

  m_view->set_sketch_list_hover(sketch_list_hover);
  m_view->set_sketch_list_measurement_hover(sketch_list_measurement_hover_sketch, sketch_list_measurement_hover_index);
  m_view->set_sketch_list_hover_face(sketch_list_hover_face_sketch, sketch_list_hover_face_index);
  m_view->set_sketch_list_hover_edge(sketch_list_hover_edge_sketch, sketch_list_hover_edge_index);
  m_view->set_sketch_list_hover_node(sketch_list_hover_node_sketch, sketch_list_hover_node_index);

  if (m_sketch_list_scroll_restore)
  {
    ImGui::SetScrollY(m_sketch_list_scroll_y);
    m_sketch_list_scroll_restore = false;
  }
  else
    m_sketch_list_scroll_y = ImGui::GetScrollY();

  ImGui::EndChild();

  if (sketch_to_delete)
  {
    if (const auto p = m_sketch_properties_sketch.lock(); p && p == sketch_to_delete)
      m_sketch_properties_open = false;

    m_sketch_list_ui.erase(sketch_to_delete->get_id());
    m_view->remove_sketch(sketch_to_delete);
  }

  ImGui::End();
}

void GUI::sketch_underlay_import_dialog_()
{
#ifndef __EMSCRIPTEN__
  char const* filter_patterns[4] = {"*.png", "*.jpg", "*.jpeg", "*.bmp"};
  char const* selected = tinyfd_openFileDialog("Sketch underlay image", "", 4, filter_patterns, "PNG / JPEG / BMP", 0);
  if (selected)
  {
    std::ifstream file(selected, std::ios::binary);
    if (!file.is_open())
    {
      show_message("Error opening: " + std::filesystem::path(selected).filename().string());
      return;
    }

    const std::string file_bytes{std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>()};
    if (!file_bytes.empty())
      on_sketch_underlay_file(selected, file_bytes);
    else
      show_message("Error opening: " + std::filesystem::path(selected).filename().string());
  }
#else
  sketch_underlay_file_dialog_async();
#endif
}

void GUI::sketch_properties_dialog_()
{
  if (!m_sketch_properties_open)
  {
    hide_sketch_origin_set_edit(false);
    return;
  }

  const Sketch::sptr sk = m_view->curr_sketch_shared();
  if (!sk)
  {
    m_sketch_properties_open = false;
    hide_sketch_origin_set_edit(false);
    return;
  }

  m_sketch_properties_sketch = sk;

  ImGui::SetNextWindowSize(ImVec2(400, 0), ImGuiCond_FirstUseEver);
  bool open = m_sketch_properties_open;
  if (!ImGui::Begin("Sketch properties", &open, ImGuiWindowFlags_None))
  {
    m_sketch_properties_open = open;
    if (!open)
      hide_sketch_origin_set_edit(false);
    ImGui::End();
    return;
  }

  ImGui::TextUnformatted(sk->get_name().c_str());
  ImGui::Separator();
  sketch_origin_panel_settings_(sk);
  sketch_underlay_panel_settings_(sk);
  m_sketch_properties_open = open;
  ImGui::End();
}

void GUI::sketch_origin_panel_settings_(const Sketch::sptr& sk)
{
  EZY_ASSERT(sk);

  if (m_sketch_origin_panel_sketch != sk.get())
  {
    hide_sketch_origin_set_edit(false);
    m_sketch_origin_panel_sketch = sk.get();
    const gp_Pnt2d o             = sk->origin_pt();
    m_sketch_origin_xy[0]        = o.X();
    m_sketch_origin_xy[1]        = o.Y();
  }

  ImGui::TextUnformatted("Origin");
  ImGui::Separator();

  bool show_origin = sk->show_origin_marker();
  if (ImGui::Checkbox("Show origin marker", &show_origin))
  {
    sk->set_show_origin_marker(show_origin);
    m_view->ctx().UpdateCurrentViewer();
  }

  ImGui::SameLine(0.0f, ImGui::GetStyle().ItemInnerSpacing.x);
  GUI_DOC_HELP_("When off, hides the Origin +/circle for this sketch (active sketch only) and removes it from snap targets.",
                doc_urls::k_sketch_origin);

  const ImGuiIO& io    = ImGui::GetIO();
  double         min_u = 0., min_v = 0., max_u = 1., max_v = 1.;
  const bool     have_view = m_view->sketch_plane_view_aabb_2d(sk->get_plane(), static_cast<double>(io.DisplaySize.x),
                                                               static_cast<double>(io.DisplaySize.y), min_u, min_v, max_u, max_v);
  if (!have_view)
  {
    constexpr double k_fallback = 250.0;
    min_u                       = m_sketch_origin_xy[0] - k_fallback;
    max_u                       = m_sketch_origin_xy[0] + k_fallback;
    min_v                       = m_sketch_origin_xy[1] - k_fallback;
    max_v                       = m_sketch_origin_xy[1] + k_fallback;
  }

  auto apply_origin = [&]()
  {
    sk->set_origin_pt(gp_Pnt2d(m_sketch_origin_xy[0], m_sketch_origin_xy[1]));
    m_view->ctx().UpdateCurrentViewer();
  };

  auto origin_axis_row = [&](const char* axis_label, const char* popup_id, int plane_idx, double v_min, double v_max)
  {
    ImGui::PushID(popup_id);
    double* const p_value = &m_sketch_origin_xy[plane_idx];
    const bool    changed =
        ImGui::SliderScalar(axis_label, ImGuiDataType_Double, p_value, &v_min, &v_max, "%.4f", ImGuiSliderFlags_ClampOnInput);

    if (changed)
      apply_origin();

    ImGui::SameLine(0.0f, ImGui::GetStyle().ItemInnerSpacing.x);
    if (ImGui::SmallButton("Set"))
      open_sketch_origin_set_edit_(sk, plane_idx, v_min, v_max);

    ImGui::PopID();
  };

  ImGui::TextUnformatted("Position (sketch plane, vs. current view)");
  ImGui::SameLine(0.0f, ImGui::GetStyle().ItemInnerSpacing.x);
  GUI_DOC_HELP_("Sketch plane coordinates for the permanent Origin marker (+ with circle). Click ? for the user guide.",
                doc_urls::k_sketch_origin);

  ImGui::PushID(sk.get());
  // Labels match typical sketch axes on screen: "X" drives plane Y, "Y" plane X (same as underlay center).
  origin_axis_row("X", "sketch_origin_set_x", 1, min_v, max_v);
  origin_axis_row("Y", "sketch_origin_set_y", 0, min_u, max_u);
  ImGui::PopID();

  ImGui::Separator();
}

void GUI::sketch_underlay_panel_settings_(const Sketch::sptr& sk)
{
  EZY_ASSERT(sk);

  Sketch_underlay& ul              = sk->underlay();
  const gp_Pln&    ul_pln          = sk->get_plane();
  const bool       ul_sketch_shown = sk->is_visible();

  ImGui::TextUnformatted("Image underlay");
  ImGui::Separator();

  if (m_underlay_panel_sketch != sk.get())
  {
    m_underlay_panel_sketch = sk.get();
    if (ul.has_image())
    {
      ul.ui_params(m_underlay_center.x, m_underlay_center.y, m_underlay_half_extents.x, m_underlay_half_extents.y,
                   m_underlay_rot);
      // Also seed raw 6-DOF for sheared editor (will be refreshed live in the transform section too).
      {
        gp_Pnt2d b;
        gp_Vec2d au, av;
        ul.get_affine(b, au, av);
        m_underlay_base = dvec2(b.X(), b.Y());
        m_underlay_u    = dvec2(au.X(), au.Y());
        m_underlay_v    = dvec2(av.X(), av.Y());
      }
      m_underlay_raw_shear    = ul.raw_shear_display();
      m_underlay_flip_u       = ul.flip_image_u();
      m_underlay_flip_v       = ul.flip_image_v();
      m_underlay_calib_x_done = false;
      m_underlay_calib_y_done = false;
      m_underlay_opacity      = ul.opacity();
      m_underlay_vis          = ul.visible();
      m_underlay_key_white    = ul.key_white_transparent();
      m_underlay_line_tint    = ul.line_tint_enabled();
      {
        uint8_t tr, tg, tb, ta;
        ul.line_tint_rgba(tr, tg, tb, ta);
        m_underlay_tint_col[0] = static_cast<float>(tr) / 255.f;
        m_underlay_tint_col[1] = static_cast<float>(tg) / 255.f;
        m_underlay_tint_col[2] = static_cast<float>(tb) / 255.f;
        m_underlay_tint_col[3] = static_cast<float>(ta) / 255.f;
      }
    }
    else
    {
      m_underlay_center       = glm::dvec2(0.0, 0.0);
      m_underlay_half_extents = glm::dvec2(0.0, 0.0);
      m_underlay_rot          = 0.0;
      m_underlay_raw_shear    = false;
      m_underlay_flip_u       = false;
      m_underlay_flip_v       = false;
      m_underlay_calib_x_done = false;
      m_underlay_calib_y_done = false;
      m_underlay_opacity      = 0.88f;
      m_underlay_vis          = true;
      m_underlay_key_white    = true;
      m_underlay_line_tint    = true;
      m_underlay_tint_col     = glm::vec4(1.f, 220.f / 255.f, 0.f, 1.f);
    }
  }

#ifndef __EMSCRIPTEN__
  if (ImGui::Button("Import image..."))
  {
    m_underlay_import_sketch_target = sk;
    sketch_underlay_import_dialog_();
  }
#else
  if (ImGui::Button("Import image..."))
  {
    m_underlay_import_sketch_target = sk;
    sketch_underlay_file_dialog_async();
  }
#endif

  ImGui::SameLine();
  if (ImGui::Button("Remove underlay"))
    if (ul.has_image())
    {
      const nlohmann::json before = ul.to_json(m_view->asset_store());
      ul.clear_and_update();
      push_underlay_change_(*sk, before);
      m_underlay_panel_sketch = nullptr;
    }

  ImGui::SameLine(0.0f, ImGui::GetStyle().ItemInnerSpacing.x);
  GUI_DOC_HELP_("Import PNG/JPEG/BMP as a sketch underlay. Adjust half-width, half-height, center, and rotation to match "
                "real dimensions; changes apply in real time. Click ? to open the user guide.",
                doc_urls::k_image_underlay);

  if (!ul.has_image())
    return;

  if (ImGui::Checkbox("White paper -> transparent", &m_underlay_key_white))
  {
    ul.set_key_white_transparent(m_underlay_key_white);
    ul.rebuild_display(ul_pln, ul_sketch_shown);
  }

  if (ui_show_contextual_help() && ImGui::IsItemHovered())
    ImGui::SetTooltip("Uses brightness: white background becomes clear; dark lines stay visible. "
                      "Turn off for full-color photos. Inverting the image is not needed for typical scans.");

  if (ImGui::Checkbox("Tint visible lines", &m_underlay_line_tint))
  {
    ul.set_line_tint_enabled(m_underlay_line_tint);
    ul.rebuild_display(ul_pln, ul_sketch_shown);
  }

  if (ui_show_contextual_help() && ImGui::IsItemHovered())
    ImGui::SetTooltip("Paints non-transparent pixels (after white key) with the line color. "
                      "Default amber/gold contrasts with the dark view and cyan frame.");

  if (m_underlay_line_tint)
    if (ImGui::ColorEdit4("Line color", &m_underlay_tint_col[0]))
    {
      const auto to_u8 = [](float c) -> uint8_t
      {
        const float x = std::clamp(c, 0.f, 1.f) * 255.f;
        return static_cast<uint8_t>(x + 0.5f);
      };
      ul.set_line_tint_rgba(to_u8(m_underlay_tint_col[0]), to_u8(m_underlay_tint_col[1]), to_u8(m_underlay_tint_col[2]),
                            to_u8(m_underlay_tint_col[3]));
      ul.rebuild_display(ul_pln, ul_sketch_shown);
    }

  if (ImGui::SliderFloat("Opacity", &m_underlay_opacity, 0.f, 1.f, "%.2f"))
    ul.set_opacity_live(m_underlay_opacity);

  if (ui_show_contextual_help() && ImGui::IsItemHovered())
    ImGui::SetTooltip("Overall opacity of the underlay image (0 = fully transparent, 1 = fully opaque).");

  ImGui::Separator();
  ImGui::TextUnformatted("Calibrate from sketch edges");
  {
    const bool sk_is_cur = (m_view->curr_sketch_shared() == sk);
    if (!sk_is_cur)
      ImGui::TextDisabled("(Make this sketch current in the sketch list to pick.)");

    const bool pick_x = m_underlay_calib_phase == Underlay_calib_phase::PickX1 ||
                        m_underlay_calib_phase == Underlay_calib_phase::PickX2 ||
                        m_underlay_calib_phase == Underlay_calib_phase::AwaitDistX;
    const bool pick_y = m_underlay_calib_phase == Underlay_calib_phase::PickY1 ||
                        m_underlay_calib_phase == Underlay_calib_phase::PickY2 ||
                        m_underlay_calib_phase == Underlay_calib_phase::AwaitDistY;

    if (pick_x || pick_y)
    {
      const char* hint = "";
      switch (m_underlay_calib_phase)
      {
      case Underlay_calib_phase::PickX1:
        hint = "First click: bitmap corner (0,0) in the current underlay transform (sliders / rotation).";
        break;
      case Underlay_calib_phase::PickX2:
        hint = "Second click: along bitmap +U from that corner; calibration refines scale from this placement.";
        break;
      case Underlay_calib_phase::AwaitDistX:
        hint = "Enter the drawing distance for X (dimension popup). If Y is not calibrated yet, its scale still follows "
               "image aspect.";
        break;
      case Underlay_calib_phase::PickY1:
        hint = "First click: along bitmap height (+V) using the current underlay transform.";
        break;
      case Underlay_calib_phase::PickY2:
        hint = "Second click: farther along +V; calibration refines Y from this placement.";
        break;
      case Underlay_calib_phase::AwaitDistY:
        hint = "Enter the drawing distance for Y (dimension popup).";
        break;
      default:
        break;
      }
      ImGui::TextColored(ImVec4(1.0f, 0.82f, 0.25f, 1.0f), "%s", hint);
    }

    ImGui::BeginDisabled(!sk_is_cur || pick_y);
    if (ImGui::Button("Set X from edge..."))
      begin_underlay_calib_set_x_(sk);

    ImGui::EndDisabled();
    if (ui_show_contextual_help() && ImGui::IsItemHovered())
      ImGui::SetTooltip("Two clicks along width (+U), then type the real drawing distance (same units as sketch dimensions). "
                        "You can use Set Y before or after; until both are set, the other axis still follows default aspect.");

    ImGui::SameLine();
    ImGui::BeginDisabled(!sk_is_cur || pick_x);
    if (ImGui::Button("Set Y from edge..."))
      begin_underlay_calib_set_y_(sk);

    ImGui::EndDisabled();
    if (ui_show_contextual_help() && ImGui::IsItemHovered())
      ImGui::SetTooltip(
          "Two clicks along height (+V), then enter the drawing distance for Y. Order vs. Set X does not matter.");
  }

  ImGui::Separator();
  ImGui::TextUnformatted("Transform (sketch plane, vs. current view)");
  {
    // Refresh raw affine every time this pane renders for the active underlay sketch.
    // This keeps the 6-DOF editor in sync after calibration, external changes, or when an edit
    // causes the basis to become (or stop being) orthogonal.
    gp_Pnt2d b;
    gp_Vec2d au, av;
    ul.get_affine(b, au, av);
    m_underlay_base = dvec2(b.X(), b.Y());
    m_underlay_u    = dvec2(au.X(), au.Y());
    m_underlay_v    = dvec2(av.X(), av.Y());

    const bool ul_ortho = ul.axes_orthogonal();

    if (!ul_ortho)
    {
      ImGui::TextWrapped(
          "Edge calibration produced shear (bitmap U and V are not perpendicular). The fields below directly edit the "
          "raw affine basis (origin + U and V vectors). The orthogonal sliders are unavailable so they cannot overwrite "
          "the calibrated fit. You can still use the calibration buttons or the Make orthogonal button below.");
    }

    if (ul_ortho)
    {
      // Orthogonal case: original friendly Center / Half extents / Rotation controls (unchanged behavior).
      const ImGuiIO& io    = ImGui::GetIO();
      double         min_u = 0., min_v = 0., max_u = 1., max_v = 1.;
      const bool     have_view =
          m_view->sketch_plane_view_aabb_2d(sk->get_plane(), static_cast<double>(io.DisplaySize.x),
                                            static_cast<double>(io.DisplaySize.y), min_u, min_v, max_u, max_v);
      if (!have_view)
      {
        constexpr double k_fallback = 250.0;
        // m_underlay_center stays sketch-plane gp_Pnt2d X / Y (same as underlay_ui_params).
        min_u = m_underlay_center.x - k_fallback;
        max_u = m_underlay_center.x + k_fallback;
        min_v = m_underlay_center.y - k_fallback;
        max_v = m_underlay_center.y + k_fallback;
      }

      const double span_u      = std::max(max_u - min_u, 1e-6);
      const double span_v      = std::max(max_v - min_v, 1e-6);
      const double half_span_u = 0.5 * span_u;
      const double half_span_v = 0.5 * span_v;
      // Allow underlay larger than the visible frustum (trace paper / zoomed views).
      const double     max_half_w = std::max(std::hypot(half_span_u, half_span_v) * 2.5, 1e-3);
      const double     max_half_h = max_half_w;
      constexpr double k_min_half = 1e-6;
      double           rot_min    = -180.0;
      double           rot_max    = 180.0;

      auto apply_ul_xform = [&]()
      {
        if (!ul.axes_orthogonal())
          return;

        ul.set_center_extents_rotation_display(dvec2(m_underlay_center.x, m_underlay_center.y),
                                               dvec2(m_underlay_half_extents.x, m_underlay_half_extents.y), m_underlay_rot,
                                               ul_pln, ul_sketch_shown);
      };

      auto transform_slider = [&](const char* label, ImGuiDataType type, void* p_data, const void* p_min, const void* p_max,
                                  const char* format, ImGuiSliderFlags flags = 0)
      {
        const bool changed = ImGui::SliderScalar(label, type, p_data, p_min, p_max, format, flags);
        if (ImGui::IsItemActivated())
          begin_underlay_undo_(*sk);
        if (ImGui::IsItemDeactivatedAfterEdit())
          commit_underlay_undo_(*sk);

        if (changed)
          apply_ul_xform();
      };

      auto transform_input_double = [&](const char* label, double* p_data, double v_min, double v_max, const char* format)
      {
        const bool changed = ImGui::InputDouble(label, p_data, 0.0, 0.0, format);
        if (ImGui::IsItemActivated())
          begin_underlay_undo_(*sk);
        if (ImGui::IsItemDeactivatedAfterEdit())
          commit_underlay_undo_(*sk);

        if (changed)
        {
          *p_data = std::clamp(*p_data, v_min, v_max);
          apply_ul_xform();
        }
      };

      // Labels match typical sketch axes on screen: "Center X" drives plane Y (gp_Pnt2d::Y / view v), "Center Y" plane X (u).
      transform_slider("Center X", ImGuiDataType_Double, &m_underlay_center.y, &min_v, &max_v, "%.4f",
                       ImGuiSliderFlags_ClampOnInput);
      transform_slider("Center Y", ImGuiDataType_Double, &m_underlay_center.x, &min_u, &max_u, "%.4f",
                       ImGuiSliderFlags_ClampOnInput);
      transform_slider("Half width", ImGuiDataType_Double, &m_underlay_half_extents.x, &k_min_half, &max_half_w, "%.4f",
                       ImGuiSliderFlags_ClampOnInput | ImGuiSliderFlags_Logarithmic);
      transform_slider("Half height", ImGuiDataType_Double, &m_underlay_half_extents.y, &k_min_half, &max_half_h, "%.4f",
                       ImGuiSliderFlags_ClampOnInput | ImGuiSliderFlags_Logarithmic);
      transform_slider("Rotation (deg)", ImGuiDataType_Double, &m_underlay_rot, &rot_min, &rot_max, "%.1f",
                       ImGuiSliderFlags_ClampOnInput);
      transform_input_double("Rotation value (deg)", &m_underlay_rot, rot_min, rot_max, "%.4f");
    }
    else
    {
      // Sheared (non-orthogonal) case: 6-DOF raw affine editor.
      // Base = bitmap (0,0) location in sketch plane.
      // U and V are the full edge vectors (their magnitudes are the half-extents in those directions).
      // Base X/Y use viewport-relative sliders (matching the previous Center X/Y behavior for position).

      m_underlay_raw_shear = ul.raw_shear_display();
      if (ImGui::Checkbox("Show raw shear distortion in image (makes bad Y-axis or other calibration mistakes visible as skew "
                          "in the raster)",
                          &m_underlay_raw_shear))
      {
        ul.set_raw_shear_display(m_underlay_raw_shear);
        ul.rebuild_display(ul_pln, ul_sketch_shown);
      }

      if (m_underlay_raw_shear)
      {
        m_underlay_flip_u = ul.flip_image_u();
        m_underlay_flip_v = ul.flip_image_v();

        if (ImGui::Checkbox("Reverse image U (flip horizontal in source)", &m_underlay_flip_u))
        {
          ul.set_flip_image_u(m_underlay_flip_u);
          ul.rebuild_display(ul_pln, ul_sketch_shown);
        }
        if (ImGui::Checkbox("Reverse image V (flip vertical in source)", &m_underlay_flip_v))
        {
          ul.set_flip_image_v(m_underlay_flip_v);
          ul.rebuild_display(ul_pln, ul_sketch_shown);
        }
        ImGui::TextDisabled("(Cycle these to put raster (0,0) at the 'top left' corner of the parallelogram)");
      }

      const ImGuiIO& io    = ImGui::GetIO();
      double         min_u = 0., min_v = 0., max_u = 1., max_v = 1.;
      const bool     have_view =
          m_view->sketch_plane_view_aabb_2d(sk->get_plane(), static_cast<double>(io.DisplaySize.x),
                                            static_cast<double>(io.DisplaySize.y), min_u, min_v, max_u, max_v);
      if (!have_view)
      {
        constexpr double k_fallback = 250.0;
        min_u                       = m_underlay_base.x - k_fallback;
        max_u                       = m_underlay_base.x + k_fallback;
        min_v                       = m_underlay_base.y - k_fallback;
        max_v                       = m_underlay_base.y + k_fallback;
      }

      auto apply_affine = [&]()
      {
        sk->underlay().set_affine_plane(gp_Pnt2d(m_underlay_base.x, m_underlay_base.y),
                                        gp_Vec2d(m_underlay_u.x, m_underlay_u.y), gp_Vec2d(m_underlay_v.x, m_underlay_v.y),
                                        sk->get_plane(), sk->is_visible());
      };

      // Base position sliders (viewport frustum bounds + fallback, direct plane X/Y).
      {
        const bool changed = ImGui::SliderScalar("Base X", ImGuiDataType_Double, &m_underlay_base.x, &min_u, &max_u, "%.4f",
                                                 ImGuiSliderFlags_ClampOnInput);
        if (ImGui::IsItemActivated())
          begin_underlay_undo_(*sk);
        if (ImGui::IsItemDeactivatedAfterEdit())
          commit_underlay_undo_(*sk);
        if (changed)
          apply_affine();
      }

      {
        const bool changed = ImGui::SliderScalar("Base Y", ImGuiDataType_Double, &m_underlay_base.y, &min_v, &max_v, "%.4f",
                                                 ImGuiSliderFlags_ClampOnInput);
        if (ImGui::IsItemActivated())
          begin_underlay_undo_(*sk);
        if (ImGui::IsItemDeactivatedAfterEdit())
          commit_underlay_undo_(*sk);
        if (changed)
          apply_affine();
      }

      auto vector_component = [&](const char* label, double* p_data)
      {
        const bool changed = ImGui::InputDouble(label, p_data, 0.0, 0.0, "%.4f");
        if (ImGui::IsItemActivated())
          begin_underlay_undo_(*sk);
        if (ImGui::IsItemDeactivatedAfterEdit())
          commit_underlay_undo_(*sk);

        if (changed)
          apply_affine();
      };

      ImGui::TextUnformatted("+U vector");
      if (ImGui::IsItemHovered())
        ImGui::SetTooltip("Maps the horizontal (width / columns) of the source bitmap. From the Base, this vector reaches the "
                          "right edge of the full image. Set X from edge and datum tools primarily affect +U.");
      vector_component("U X", &m_underlay_u.x);
      vector_component("U Y", &m_underlay_u.y);

      ImGui::TextUnformatted("+V vector");
      if (ImGui::IsItemHovered())
        ImGui::SetTooltip(
            "Maps the vertical (height / rows) of the source bitmap. From the Base, this vector reaches the bottom edge of the "
            "full image. 'Set Y from edge...' and y-axis calibration adjust +V (this is what you set for the Y-axis).");

      vector_component("V X", &m_underlay_v.x);
      vector_component("V Y", &m_underlay_v.y);

      // Live derived metrics (useful while tweaking shear cases).
      {
        const double lu        = std::hypot(m_underlay_u.x, m_underlay_u.y);
        const double lv        = std::hypot(m_underlay_v.x, m_underlay_v.y);
        double       shear_deg = 0.0;
        if (lu > 1e-12 && lv > 1e-12)
        {
          const double dot = m_underlay_u.x * m_underlay_v.x + m_underlay_u.y * m_underlay_v.y;
          const double c   = std::clamp(dot / (lu * lv), -1.0, 1.0);
          shear_deg        = std::acos(c) * (180.0 / std::acos(-1.0));
        }

        ImGui::Text("U len: %.4f   V len: %.4f   Angle U-V: %.2f deg", lu, lv, shear_deg);
      }

      if (ImGui::Button("Make orthogonal (keep lengths + U direction)"))
      {
        const nlohmann::json before = sk->underlay().to_json(m_view->asset_store());
        force_underlay_orthogonal_(sk);
        push_underlay_change_(*sk, before);
      }

      if (ui_show_contextual_help() && ImGui::IsItemHovered())
        ImGui::SetTooltip("Project V to be perpendicular to U. Keeps the current lengths of both axes and the original "
                          "orientation (sign of U cross V). After this the Center / Half / Rotation sliders return.");
    }
  }
}

void GUI::on_sketch_underlay_file(const std::string& file_path, const std::string& file_bytes)
{
  Sketch::sptr sk = m_underlay_import_sketch_target.lock();
  m_underlay_import_sketch_target.reset();
  if (!sk)
    sk = m_view->curr_sketch_shared();

  const nlohmann::json before = sk->underlay().to_json(m_view->asset_store());
  uint8_t              hr, hg, hb, ha;
  underlay_highlight_color_rgba(hr, hg, hb, ha);
  if (!sk->underlay().load_from_file_bytes(file_bytes, m_view->asset_store(), hr, hg, hb, ha, sk->get_plane(),
                                           sk->is_visible()))
  {
    show_message("Could not decode image: " + std::filesystem::path(file_path).filename().string());
    return;
  }

  push_underlay_change_(*sk, before);
  m_underlay_calib_x_done = false;
  m_underlay_calib_y_done = false;
  m_underlay_panel_sketch = nullptr;
  show_message("Underlay: " + std::filesystem::path(file_path).filename().string());
}

void GUI::cancel_underlay_calib_()
{
  m_dist_callback        = nullptr;
  m_underlay_calib_phase = Underlay_calib_phase::None;

  m_underlay_calib_sketch_wk.reset();
}

void GUI::begin_underlay_undo_(Sketch& sk)
{
  m_underlay_undo_before    = sk.underlay().to_json(m_view->asset_store());
  m_underlay_undo_sketch_id = sk.get_id();
}

void GUI::commit_underlay_undo_(Sketch& sk)
{
  if (!m_underlay_undo_before)
    return;

  const nlohmann::json after = sk.underlay().to_json(m_view->asset_store());
  if (after == *m_underlay_undo_before)
  {
    m_underlay_undo_before.reset();
    return;
  }

  m_view->push_undo_delta(std::make_unique<Underlay_delta>(m_underlay_undo_sketch_id, *m_underlay_undo_before, after));
  m_underlay_undo_before.reset();
}

void GUI::push_underlay_change_(Sketch& sk, const nlohmann::json& before)
{
  const nlohmann::json after = sk.underlay().to_json(m_view->asset_store());
  if (after == before)
    return;

  m_view->push_undo_delta(std::make_unique<Underlay_delta>(sk.get_id(), before, after));
}

void GUI::force_underlay_orthogonal_(const Sketch::sptr& sk)
{
  if (!sk || !sk->underlay().has_image())
    return;

  Sketch_underlay& ul = sk->underlay();
  gp_Pnt2d         b;
  gp_Vec2d         au, av;
  ul.get_affine(b, au, av);
  const double lu = au.Magnitude();
  const double lv = av.Magnitude();
  if (lu > 1e-12 && lv > 1e-12)
  {
    gp_Vec2d au_n = au;
    au_n.Normalize();
    const double det = au.X() * av.Y() - au.Y() * av.X();
    gp_Vec2d     av_perp;
    if (det >= 0.0)
      av_perp = gp_Vec2d(-au_n.Y() * lv, au_n.X() * lv);
    else
      av_perp = gp_Vec2d(au_n.Y() * lv, -au_n.X() * lv);

    const gp_Vec2d au_final = au_n * lu;
    ul.set_affine_plane(b, au_final, av_perp, sk->get_plane(), sk->is_visible());
    // Refresh locals for this frame and any immediate follow-up UI.
    m_underlay_u = dvec2(au_final.X(), au_final.Y());
    m_underlay_v = dvec2(av_perp.X(), av_perp.Y());
  }
  ul.ui_params(m_underlay_center.x, m_underlay_center.y, m_underlay_half_extents.x, m_underlay_half_extents.y, m_underlay_rot);
  m_underlay_panel_sketch = nullptr;
}

void GUI::begin_underlay_calib_set_x_(const Sketch::sptr& sk)
{
  if (!sk || !sk->underlay().has_image())
    return;

  if (m_view->curr_sketch_shared() != sk)
  {
    show_message("Make this sketch current in the sketch list, then try again.");
    return;
  }

  cancel_underlay_calib_();
  sk->underlay().ui_params(m_underlay_center.x, m_underlay_center.y, m_underlay_half_extents.x, m_underlay_half_extents.y,
                           m_underlay_rot);
  m_underlay_calib_sketch_wk = sk;
  m_underlay_calib_phase     = Underlay_calib_phase::PickX1;
  show_message("Underlay X: uses the current transform. Click bitmap corner (0,0), then along +U; then enter the distance.");
}

void GUI::begin_underlay_calib_set_y_(const Sketch::sptr& sk)
{
  if (!sk || !sk->underlay().has_image())
    return;

  if (m_view->curr_sketch_shared() != sk)
  {
    show_message("Make this sketch current in the sketch list, then try again.");
    return;
  }

  cancel_underlay_calib_();
  sk->underlay().ui_params(m_underlay_center.x, m_underlay_center.y, m_underlay_half_extents.x, m_underlay_half_extents.y,
                           m_underlay_rot);

  m_underlay_calib_sketch_wk = sk;
  m_underlay_calib_phase     = Underlay_calib_phase::PickY1;
  show_message("Underlay Y: uses the current transform. Click two points along +V; then enter the drawing distance.");
}

void GUI::underlay_calib_prompt_x_distance_(const Sketch::sptr& sk)
{
  m_underlay_calib_phase       = Underlay_calib_phase::AwaitDistX;
  const double       L_model   = m_underlay_calib_x0.Distance(m_underlay_calib_x1);
  const float        dist_show = static_cast<float>(L_model / m_view->get_display_to_model_scale());
  const ScreenCoords spos      = cursor_screen_coords();

  Sketch::wptr wk      = sk;
  auto         on_dist = [this, wk](float new_dist, bool is_final)
  {
    if (!is_final)
      return;

    const Sketch::sptr s = wk.lock();
    if (!s || !s->underlay().has_image())
    {
      m_dist_callback = nullptr;
      cancel_underlay_calib_();
      return;
    }

    if (m_underlay_calib_phase != Underlay_calib_phase::AwaitDistX)
      return;

    const double Dx = static_cast<double>(new_dist) * m_view->get_display_to_model_scale();
    if (Dx <= 1e-12)
    {
      show_message("Distance must be positive.");
      return;
    }

    const nlohmann::json before = s->underlay().to_json(m_view->asset_store());
    if (!s->underlay().rescale_uv_chord_to_length(m_underlay_calib_x0, m_underlay_calib_x1, Dx, s->get_plane(),
                                                  s->is_visible()))
    {
      show_message("Could not calibrate X (underlay axes degenerate or segment too short).");
      return;
    }

    s->underlay().ui_params(m_underlay_center.x, m_underlay_center.y, m_underlay_half_extents.x, m_underlay_half_extents.y,
                            m_underlay_rot);

    m_underlay_calib_x_done = true;
    m_underlay_panel_sketch = nullptr;

    if (m_underlay_calib_x_done && m_underlay_calib_y_done)
      force_underlay_orthogonal_(s);

    push_underlay_change_(*s, before);

    m_dist_callback        = nullptr;
    m_underlay_calib_phase = Underlay_calib_phase::None;
    show_message("X distance applied to the picked segment. Use Set Y from edge for the vertical span if needed, or adjust "
                 "transforms.");
  };

  set_dist_edit(dist_show, std::move(on_dist), spos);
}

void GUI::underlay_calib_prompt_y_distance_(const Sketch::sptr& sk)
{
  m_underlay_calib_phase       = Underlay_calib_phase::AwaitDistY;
  const double       L_model   = m_underlay_calib_y0.Distance(m_underlay_calib_y1);
  const float        dist_show = static_cast<float>(L_model / m_view->get_display_to_model_scale());
  const ScreenCoords spos      = cursor_screen_coords();

  Sketch::wptr wk      = sk;
  auto         on_dist = [this, wk](float new_dist, bool is_final)
  {
    if (!is_final)
      return;

    const Sketch::sptr s = wk.lock();
    if (!s || !s->underlay().has_image())
    {
      m_dist_callback = nullptr;
      cancel_underlay_calib_();
      return;
    }

    if (m_underlay_calib_phase != Underlay_calib_phase::AwaitDistY)
      return;

    const double Dy = static_cast<double>(new_dist) * m_view->get_display_to_model_scale();
    if (Dy <= 1e-12)
    {
      show_message("Distance must be positive.");
      return;
    }

    const nlohmann::json before = s->underlay().to_json(m_view->asset_store());
    if (!s->underlay().rescale_v_chord_to_length(m_underlay_calib_y0, m_underlay_calib_y1, Dy, s->get_plane(), s->is_visible()))
    {
      show_message("Set Y: picks need a clear span along image height (not along the same edge as X only). Try two points "
                   "further apart in V.");
      return;
    }

    s->underlay().ui_params(m_underlay_center.x, m_underlay_center.y, m_underlay_half_extents.x, m_underlay_half_extents.y,
                            m_underlay_rot);

    m_underlay_calib_y_done = true;
    m_underlay_panel_sketch = nullptr;

    if (m_underlay_calib_x_done && m_underlay_calib_y_done)
      force_underlay_orthogonal_(s);

    push_underlay_change_(*s, before);

    m_dist_callback = nullptr;
    cancel_underlay_calib_();
    show_message("Y distance applied to the picked segment. Use Set X from edge for the horizontal span if needed, or adjust "
                 "transforms.");
  };

  set_dist_edit(dist_show, std::move(on_dist), spos);
}

bool GUI::try_underlay_calib_click_(const ScreenCoords& screen_coords)
{
  if (m_underlay_calib_phase == Underlay_calib_phase::None)
    return false;

  if (m_underlay_calib_phase == Underlay_calib_phase::AwaitDistX || m_underlay_calib_phase == Underlay_calib_phase::AwaitDistY)
    return true;

  const Sketch::sptr sk     = m_underlay_calib_sketch_wk.lock();
  const Sketch::sptr sk_cur = m_view->curr_sketch_shared();
  if (!sk || !sk_cur || sk != sk_cur)
  {
    cancel_underlay_calib_();
    show_message("Underlay calibration canceled.");
    return true;
  }

  if (!sk->underlay().has_image())
  {
    cancel_underlay_calib_();
    return true;
  }

  const std::optional<gp_Pnt2d> pt =
      Sketch_underlay::pick_point_for_calib(*m_view, sk->get_plane(), sk->get_nodes(), screen_coords);
  if (!pt)
    return true;

  auto too_short = [](const gp_Pnt2d& a, const gp_Pnt2d& b)
  {
    const double dx = b.X() - a.X();
    const double dy = b.Y() - a.Y();
    return dx * dx + dy * dy <= 1e-16;
  };

  switch (m_underlay_calib_phase)
  {
  case Underlay_calib_phase::PickX1:
    m_underlay_calib_x0    = *pt;
    m_underlay_calib_phase = Underlay_calib_phase::PickX2;
    show_message("Underlay X: click second point (end of width / +U).");
    return true;

  case Underlay_calib_phase::PickX2:
    if (too_short(m_underlay_calib_x0, *pt))
    {
      show_message("X segment too short.");
      return true;
    }

    m_underlay_calib_x1 = *pt;
    show_message("Enter drawing distance for X (same unit convention as sketch edge dimensions).");
    underlay_calib_prompt_x_distance_(sk);
    return true;

  case Underlay_calib_phase::PickY1:
    m_underlay_calib_y0    = *pt;
    m_underlay_calib_phase = Underlay_calib_phase::PickY2;
    show_message("Underlay Y: click second point (end of height / +V).");
    return true;

  case Underlay_calib_phase::PickY2:
    if (too_short(m_underlay_calib_y0, *pt))
    {
      show_message("Y segment too short.");
      return true;
    }

    m_underlay_calib_y1 = *pt;
    show_message("Enter drawing distance for Y.");
    underlay_calib_prompt_y_distance_(sk);
    return true;

  default:
    return false;
  }
}

void GUI::shape_list_()
{
  if (!show_shape_list_effective())
  {
    m_view->set_shape_list_hover(nullptr);
    return;
  }

  if (!ImGui::Begin("Shape List", &m_show_shape_list, ImGuiWindowFlags_None))
  {
    m_view->set_shape_list_hover(nullptr);
    ImGui::End();
    return;
  }

  if (ImGui::Checkbox("Hide all", &m_hide_all_shapes))
  {
    if (m_hide_all_shapes)
      m_view->set_shape_list_hover(nullptr);
    m_view->sync_sketch_shape_faint_style();
  }

  ImGui::SameLine();
  if (ImGui::SmallButton("New group"))
  {
    Shp_ptr grp = m_view->create_group("Group", m_view->current_group_id());
    if (!grp.IsNull())
      m_view->set_current_group_id(grp->get_id());
  }

  ImGui::SameLine();
  {
    const std::vector<Shp_ptr> sel       = m_view->get_selected_shps();
    const bool                 can_group = !sel.empty();
    if (!can_group)
      ImGui::BeginDisabled();

    if (ImGui::SmallButton("Group"))
      (void)m_view->group_shapes(sel);

    if (!can_group)
      ImGui::EndDisabled();
  }

  ImGui::Separator();

  const std::vector<std::string>& mat_names       = occt_material_combo_labels_();
  const int                       nmat            = static_cast<int>(mat_names.size());
  float                           mat_label_w_max = 0.0f;
  for (int mi = 0; mi < nmat; ++mi)
    mat_label_w_max = std::max(mat_label_w_max, ImGui::CalcTextSize(mat_names[static_cast<size_t>(mi)].c_str()).x);

  const ImGuiStyle& st_mat      = ImGui::GetStyle();
  const float       mat_popup_w = std::min(440.0f, std::max(280.0f, mat_label_w_max + st_mat.WindowPadding.x * 2.0f +
                                                                        st_mat.FramePadding.x * 2.0f + st_mat.ScrollbarSize + 8.0f));
  const float       check_col_w = ImGui::GetFrameHeight();
  const float       mat_col_w   = ImGui::CalcTextSize("M").x + st_mat.FramePadding.x * 2.0f;

  Shp_ptr  shape_to_delete;
  Shp_ptr  shape_list_hover;
  Shape_id shape_to_ungroup_id = 0;

  std::unordered_set<const AIS_Shape*> selected_in_viewer;
  for (const AIS_Shape_ptr& ais : m_view->get_selected())
    if (!ais.IsNull())
      selected_in_viewer.insert(ais.get());

  auto row_is_selected = [&](const Shp_ptr& shape) -> bool
  {
    if (shape.IsNull())
      return false;

    if (shape->is_group())
    {
      for (const Shp_ptr& leaf : m_view->shape_descendant_solids(shape->get_id()))
        if (selected_in_viewer.count(leaf.get()) != 0)
          return true;

      return false;
    }
    return selected_in_viewer.count(shape.get()) != 0;
  };

  auto select_shape_row = [&](const Shp_ptr& shape)
  {
    AIS_InteractiveContext& ctx  = m_view->ctx();
    const bool              ctrl = ImGui::GetIO().KeyCtrl;
    if (!ctrl)
      ctx.ClearSelected(false);

    if (shape->is_group())
    {
      m_view->set_current_group_id(shape->get_id());
      for (const Shp_ptr& leaf : m_view->shape_descendant_solids(shape->get_id()))
        ctx.AddOrRemoveSelected(leaf, true);
    }
    else
    {
      m_view->set_current_group_id(shape->get_parent_id());
      ctx.AddOrRemoveSelected(shape, true);
    }

    ctx.UpdateCurrentViewer();
  };

  // Tree node always uses NoTreePushOnOpen; indent children with an explicit TreePush/TreePop
  // pair so table rows cannot leave the ImGui tree stack unbalanced (which nested siblings
  // under the wrong parent and made Ungroup look like it only moved one child).
  std::unordered_set<Shape_id> shape_list_ancestors;
  auto draw_shape_row = [&](auto&& self, const Shp_ptr& shape) -> void
  {
    EZY_ASSERT(shape);
    if (!shape_list_ancestors.insert(shape->get_id()).second)
      return; // Parent cycle: skip rather than hang the Shape List.

    const bool                 is_group         = shape->is_group();
    const std::vector<Shp_ptr> children         = m_view->shape_children(shape->get_id());
    const bool                 has_children     = !children.empty();
    const bool                 is_current_group = is_group && shape->get_id() == m_view->current_group_id();
    const bool                 row_selected     = is_current_group || row_is_selected(shape);
    bool                       row_hovered      = false;

    ImGui::PushID(static_cast<int>(shape->get_id()));
    ImGui::TableNextRow();
    if (row_selected)
      ImGui::TableSetBgColor(ImGuiTableBgTarget_RowBg0, ImGui::GetColorU32(ImGuiCol_Header, 0.45f));

    char name_buffer[1024];
    safe_cstr_copy(name_buffer, sizeof(name_buffer), shape->get_name().c_str());

    int mat_idx = 0;
    if (!is_group)
    {
      mat_idx = shape->Material();
      if (mat_idx < 0 || mat_idx >= nmat)
        mat_idx = static_cast<int>(m_view->get_default_material().Name());
    }

    auto apply_shape_material = [&](int i)
    {
      if (is_group || i < 0 || i >= nmat)
        return;

      // OwnColor (e.g. from older wasm SetColor workarounds) overrides material presets.
      if (shape->HasColor())
        shape->UnsetColor();
      shape->SetMaterial(Graphic3d_MaterialAspect(static_cast<Graphic3d_NameOfMaterial>(i)));
      m_view->refresh_shape_shading_(shape);
      m_view->ctx().Redisplay(shape, true);
      m_view->ctx().UpdateCurrentViewer();
    };

    // Columns 0-2: fixed actions on the left (no tree indent).
    ImGui::TableSetColumnIndex(0);
    bool visible = shape->get_visible();
    if (ImGui::Checkbox("##vis", &visible))
    {
      if (!visible && m_view->shape_list_hover() == shape)
        m_view->set_shape_list_hover(nullptr);

      shape->set_visible(visible);
      m_view->sync_sketch_shape_faint_style();
    }
    row_hovered |= ImGui::IsItemHovered();
    if (ui_show_contextual_help() && ImGui::IsItemHovered())
      ImGui::SetTooltip(is_group ? "Show/hide group subtree" : "visibility");

    ImGui::TableSetColumnIndex(1);
    if (is_group)
      ImGui::TextUnformatted("");
    else
    {
      bool shaded = shape->get_disp_mode() == AIS_Shaded;
      if (ImGui::Checkbox("##shaded", &shaded))
        shape->set_disp_mode(shaded ? AIS_Shaded : AIS_WireFrame);

      row_hovered |= ImGui::IsItemHovered();
      if (ui_show_contextual_help() && ImGui::IsItemHovered())
        ImGui::SetTooltip("solid/wire");
    }

    ImGui::TableSetColumnIndex(2);
    if (is_group)
      ImGui::TextUnformatted("");
    else
    {
      ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(4.0f, ImGui::GetStyle().FramePadding.y));
      if (ImGui::Button("M"))
        ImGui::OpenPopup("mat_pick");

      ImGui::PopStyleVar();
      row_hovered |= ImGui::IsItemHovered();
      if (ui_show_contextual_help() && ImGui::IsItemHovered())
        ImGui::SetTooltip("%s\n(click: material; right-click name: Delete)", mat_names[static_cast<size_t>(mat_idx)].c_str());

      ImGui::SetNextWindowSize(ImVec2(mat_popup_w, 0.0f), ImGuiCond_Appearing);
      if (ImGui::BeginPopup("mat_pick"))
      {
        ImGui::TextUnformatted("Material");
        ImGui::Separator();
        const float max_h = ImGui::GetTextLineHeightWithSpacing() * 12.0f;
        const float sc_w  = std::max(1.0f, ImGui::GetContentRegionAvail().x);
        if (ImGui::BeginChild("mat_sc", ImVec2(sc_w, max_h), ImGuiChildFlags_Borders, ImGuiWindowFlags_AlwaysVerticalScrollbar))
        {
          for (int i = 0; i < nmat; ++i)
            if (ImGui::Selectable(mat_names[static_cast<size_t>(i)].c_str(), i == mat_idx))
            {
              apply_shape_material(i);
              ImGui::CloseCurrentPopup();
            }

          ImGui::EndChild();
        }

        ImGui::EndPopup();
      }

      if (ImGui::BeginPopupContextItem("mat_btn_ctx"))
      {
        if (ImGui::MenuItem("Shape info..."))
          open_shape_info_(shape);

        if (ImGui::MenuItem("Delete"))
          shape_to_delete = shape;

        ImGui::EndPopup();
      }
    }

    // Column 3: tree arrow + name (indent applies here so hierarchy stays under the name).
    ImGui::TableSetColumnIndex(3);
    ImGui::AlignTextToFramePadding();

    ImGuiTreeNodeFlags node_flags = ImGuiTreeNodeFlags_FramePadding | ImGuiTreeNodeFlags_OpenOnArrow |
                                    ImGuiTreeNodeFlags_DrawLinesToNodes | ImGuiTreeNodeFlags_NoTreePushOnOpen;
    if (!has_children)
      node_flags |= ImGuiTreeNodeFlags_Leaf;

    if (row_selected)
      node_flags |= ImGuiTreeNodeFlags_Selected;

    bool open = true;
    if (has_children)
    {
      const auto exp_it = m_shape_list_expanded.find(shape->get_id());
      open              = (exp_it == m_shape_list_expanded.end()) ? true : exp_it->second;
      ImGui::SetNextItemOpen(open);
    }

    ImGui::SetNextItemAllowOverlap();
    const bool node_open = ImGui::TreeNodeEx("##node", node_flags);
    if (has_children && node_open != open)
      m_shape_list_expanded[shape->get_id()] = node_open;

    if (ImGui::IsItemClicked() && !ImGui::IsItemToggledOpen())
      select_shape_row(shape);

    row_hovered |= ImGui::IsItemHovered();
    if (row_selected && ui_show_contextual_help() && ImGui::IsItemHovered())
      ImGui::SetTooltip(is_current_group ? "Current group (new shapes go here)" : "Selected in 3D viewer");

    if (ImGui::BeginDragDropSource(ImGuiDragDropFlags_SourceAllowNullID))
    {
      const Shape_id drag_id = shape->get_id();
      ImGui::SetDragDropPayload("EZY_SHAPE_ID", &drag_id, sizeof(drag_id));
      ImGui::TextUnformatted(shape->get_name().c_str());
      ImGui::EndDragDropSource();
    }

    // Drop onto group -> that group; onto solid -> solid's parent. Register on both the
    // tree arrow and the name field - the name covers most of the row.
    auto accept_reparent_drop = [&]()
    {
      if (!ImGui::BeginDragDropTarget())
        return;

      if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("EZY_SHAPE_ID"))
      {
        Shape_id drag_id = 0;
        std::memcpy(&drag_id, payload->Data, sizeof(drag_id));
        const Shape_id new_parent = is_group ? shape->get_id() : shape->get_parent_id();
        (void)m_view->reparent_shape(drag_id, new_parent, -1, true);
      }
      ImGui::EndDragDropTarget();
    };
    accept_reparent_drop();

    ImGui::SameLine();
    ImGui::SetNextItemWidth(std::max(1.0f, ImGui::GetContentRegionAvail().x));
    if (ImGui::InputText("##name", name_buffer, sizeof(name_buffer)))
      shape->set_name(std::string(name_buffer));

    if (ImGui::IsItemClicked())
      select_shape_row(shape);

    if (ImGui::BeginDragDropSource(ImGuiDragDropFlags_SourceAllowNullID))
    {
      const Shape_id drag_id = shape->get_id();
      ImGui::SetDragDropPayload("EZY_SHAPE_ID", &drag_id, sizeof(drag_id));
      ImGui::TextUnformatted(shape->get_name().c_str());
      ImGui::EndDragDropSource();
    }
    accept_reparent_drop();

    row_hovered |= ImGui::IsItemHovered();
    if (ImGui::BeginPopupContextItem("shape_name_ctx"))
    {
      if (!is_group && ImGui::MenuItem("Shape info..."))
        open_shape_info_(shape);

      if (is_group && ImGui::MenuItem("Ungroup"))
        shape_to_ungroup_id = shape->get_id();

      if (ImGui::MenuItem("Delete"))
        shape_to_delete = shape;

      ImGui::EndPopup();
    }

    if (row_hovered && shape->get_visible() && !is_group)
      shape_list_hover = shape;

    if (has_children && node_open)
    {
      ImGui::TreePush(reinterpret_cast<const void*>(static_cast<uintptr_t>(shape->get_id())));
      for (const Shp_ptr& child : children)
        self(self, child);
      ImGui::TreePop();
    }

    ImGui::PopID();
    shape_list_ancestors.erase(shape->get_id());
  };

  const ImGuiTableFlags table_flags =
      ImGuiTableFlags_ScrollY | ImGuiTableFlags_RowBg | ImGuiTableFlags_NoBordersInBody | ImGuiTableFlags_SizingFixedFit;
  if (ImGui::BeginTable("##shape_outliner", 4, table_flags, ImVec2(0.f, 0.f)))
  {
    // Fixed actions on the left; stretch name on the right (tree indent on name only).
    ImGui::TableSetupColumn(
        "vis", ImGuiTableColumnFlags_WidthFixed | ImGuiTableColumnFlags_NoResize | ImGuiTableColumnFlags_IndentDisable,
        check_col_w);
    ImGui::TableSetupColumn(
        "disp", ImGuiTableColumnFlags_WidthFixed | ImGuiTableColumnFlags_NoResize | ImGuiTableColumnFlags_IndentDisable,
        check_col_w);
    ImGui::TableSetupColumn(
        "mat", ImGuiTableColumnFlags_WidthFixed | ImGuiTableColumnFlags_NoResize | ImGuiTableColumnFlags_IndentDisable,
        mat_col_w);
    ImGui::TableSetupColumn("name", ImGuiTableColumnFlags_WidthStretch | ImGuiTableColumnFlags_IndentEnable, 1.0f);

    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding,
                        ImVec2(st_mat.FramePadding.x, std::max(1.0f, st_mat.FramePadding.y * 0.65f)));
    ImGui::PushStyleVar(ImGuiStyleVar_CellPadding, ImVec2(st_mat.CellPadding.x, std::max(1.0f, st_mat.CellPadding.y * 0.5f)));

    for (const Shp_ptr& root : m_view->shape_children(0))
      draw_shape_row(draw_shape_row, root);

    // Empty pad below the last row: drop here to move to document root (no permanent root node).
    // Size from the visible clip remainder, not GetContentRegionAvail().y -- inside a ScrollY
    // table that avail tracks content size, so a fill-avail pad feeds back into growing scroll.
    {
      const float        min_pad_h = ImGui::GetFrameHeight();
      const ImGuiWindow* inner     = ImGui::GetCurrentWindow();
      const float visible_remain = inner->InnerClipRect.Max.y - ImGui::GetCursorScreenPos().y - ImGui::GetStyle().CellPadding.y;
      const float pad_h          = std::max(min_pad_h, visible_remain);
      ImGui::TableNextRow(ImGuiTableRowFlags_None, pad_h);
      ImGui::TableSetColumnIndex(0);

      const ImGuiPayload* active_payload = ImGui::GetDragDropPayload();
      const bool          dragging_shape = active_payload != nullptr && active_payload->IsDataType("EZY_SHAPE_ID") &&
                                  active_payload->DataSize == sizeof(Shape_id);

      if (dragging_shape)
        ImGui::TableSetBgColor(ImGuiTableBgTarget_RowBg0, ImGui::GetColorU32(ImGuiCol_Header, 0.20f));

      ImGui::Selectable("##shape_root_drop", false,
                        ImGuiSelectableFlags_SpanAllColumns | ImGuiSelectableFlags_AllowOverlap | ImGuiSelectableFlags_Disabled,
                        ImVec2(0.0f, pad_h));

      bool root_drop_hovered = false;
      if (ImGui::BeginDragDropTarget())
      {
        const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("EZY_SHAPE_ID", ImGuiDragDropFlags_AcceptBeforeDelivery);
        if (payload != nullptr)
        {
          root_drop_hovered = payload->Preview;
          if (payload->IsDelivery())
          {
            Shape_id drag_id = 0;
            std::memcpy(&drag_id, payload->Data, sizeof(drag_id));
            (void)m_view->reparent_shape(drag_id, 0, -1, true);
          }
        }
        ImGui::EndDragDropTarget();
      }

      if (dragging_shape)
      {
        const ImVec2 rmin = ImGui::GetItemRectMin();
        const ImVec2 rmax = ImGui::GetItemRectMax();
        if (root_drop_hovered)
          ImGui::GetWindowDrawList()->AddRectFilled(rmin, rmax, ImGui::GetColorU32(ImGuiCol_HeaderHovered, 0.55f));

        const char*  hint = "Move to root";
        const ImVec2 ts   = ImGui::CalcTextSize(hint);
        ImGui::GetWindowDrawList()->AddText(
            ImVec2(rmin.x + (rmax.x - rmin.x - ts.x) * 0.5f, rmin.y + (rmax.y - rmin.y - ts.y) * 0.5f),
            ImGui::GetColorU32(ImGuiCol_TextDisabled), hint);
      }
    }

    ImGui::PopStyleVar(2);
    ImGui::EndTable();
  }

  m_view->set_shape_list_hover(shape_list_hover);

  if (shape_to_ungroup_id != 0)
  {
    m_shape_list_expanded.erase(shape_to_ungroup_id);
    (void)m_view->ungroup_shape(shape_to_ungroup_id);
  }

  if (shape_to_delete)
    m_view->delete_shapes({shape_to_delete});

  ImGui::End();
}

void GUI::open_shape_info_(const Shp_ptr& shape)
{
  if (shape.IsNull() || shape->is_group())
    return;

  const std::vector<std::string>& mat_names = occt_material_combo_labels_();
  int                             mat_idx   = shape->Material();
  if (mat_idx < 0 || mat_idx >= static_cast<int>(mat_names.size()))
    mat_idx = static_cast<int>(m_view->get_default_material().Name());

  shp_info::Display_meta meta;
  meta.name         = shape->get_name();
  meta.material     = mat_names[static_cast<size_t>(mat_idx)];
  meta.display_mode = shape->get_disp_mode() == AIS_Shaded ? "Shaded" : "Wireframe";
  meta.visible      = shape->get_visible();

  m_shape_info_shp   = shape;
  m_shape_info_lines = shp_info::collect(shape->Shape(), &meta);
  m_shape_info_open  = true;
}

void GUI::shape_info_dialog_()
{
  if (!m_shape_info_open)
    return;

  if (m_shape_info_shp.IsNull())
  {
    m_shape_info_open = false;
    return;
  }

  bool shape_still_exists = false;
  for (const Shp_ptr& s : m_view->get_shapes())
    if (s == m_shape_info_shp)
    {
      shape_still_exists = true;
      break;
    }

  if (!shape_still_exists)
  {
    m_shape_info_open = false;
    m_shape_info_shp.Nullify();
    m_shape_info_lines.clear();
    return;
  }

  const std::string title = "Shape info: " + m_shape_info_shp->get_name();
  ImGui::SetNextWindowSize(ImVec2(440.0f, 0.0f), ImGuiCond_FirstUseEver);
  bool open = m_shape_info_open;
  if (!ImGui::Begin(title.c_str(), &open, ImGuiWindowFlags_None))
  {
    m_shape_info_open = open;
    ImGui::End();
    return;
  }

  if (ImGui::Button("Refresh"))
    open_shape_info_(m_shape_info_shp);

  ImGui::Separator();

  const float max_h = ImGui::GetTextLineHeightWithSpacing() * 18.0f;
  if (ImGui::BeginChild("shape_info_scroll", ImVec2(0.0f, max_h), ImGuiChildFlags_Borders,
                        ImGuiWindowFlags_AlwaysVerticalScrollbar))
  {
    if (ImGui::BeginTable("shape_info_tbl", 2, ImGuiTableFlags_SizingStretchProp | ImGuiTableFlags_RowBg))
    {
      ImGui::TableSetupColumn("label", ImGuiTableColumnFlags_WidthFixed, 120.0f);
      ImGui::TableSetupColumn("value", ImGuiTableColumnFlags_WidthStretch);

      for (const shp_info::Line& line : m_shape_info_lines)
      {
        if (line.label.empty() && line.value.empty())
        {
          ImGui::TableNextRow();
          ImGui::TableSetColumnIndex(0);
          ImGui::Separator();
          ImGui::TableSetColumnIndex(1);
          ImGui::Separator();
          continue;
        }

        ImGui::TableNextRow();
        ImGui::TableSetColumnIndex(0);
        ImGui::TextUnformatted(line.label.c_str());
        ImGui::TableSetColumnIndex(1);
        ImGui::TextUnformatted(line.value.c_str());
      }

      ImGui::EndTable();
    }

    ImGui::EndChild();
  }

  m_shape_info_open = open;
  if (!open)
    m_shape_info_shp.Nullify();

  ImGui::End();
}

void GUI::open_file_inspector_(const std::string& file_path, const std::string& file_bytes)
{
  m_file_inspector_path      = file_path;
  m_file_inspector_bytes     = file_bytes;
  m_file_inspector_fmt       = utl_cad_file_info::detect(file_path, file_bytes);
  m_file_inspector_step_mode = Step_import_mode::Preserve_hierarchy;
  m_file_inspector_open      = true;
}

bool GUI::cad_busy_() const { return m_cad_busy_kind != Cad_busy_kind::Idle; }

void GUI::cancel_cad_busy_()
{
  if (!m_cad_busy_progress.IsNull())
    m_cad_busy_progress->request_cancel();
}

void GUI::begin_step_import_(const Step_import_mode mode)
{
  if (cad_busy_() || m_file_inspector_bytes.empty() || !m_view)
    return;

  m_cad_busy_kind        = Cad_busy_kind::Import;
  m_cad_busy_path        = m_file_inspector_path;
  m_cad_busy_bytes       = m_file_inspector_bytes;
  m_cad_busy_import_mode = mode;
  m_cad_busy_title       = "Importing";
  m_cad_busy_open_popup  = true;
  m_cad_busy_modal_open  = true;

#ifndef __EMSCRIPTEN__
  m_cad_busy_progress = new Atomic_progress_indicator();
  m_cad_busy_progress->set_stage("Starting...");
  const std::string                   bytes = m_cad_busy_bytes;
  const Step_import_mode              m     = mode;
  const double                        scale = m_view->step_import_model_scale();
  const Atomic_progress_indicator_ptr prog  = m_cad_busy_progress;
  m_cad_busy_import_fut                     = std::async(std::launch::async,
                                                         [bytes, m, scale, prog]() -> std::pair<Status, Occt_view::Step_import_geom>
                                                         {
                                       Occt_view::Step_import_geom geom;
                                       Status st = Occt_view::prepare_step_import(bytes, m, scale, geom, prog);
                                       return {st, std::move(geom)};
                                     });
#else
  // OpenPopup + one painted frame before the main-thread Transfer freezes the UI.
  m_cad_busy_defer_frames = 2;
  m_cad_busy_progress     = {};
#endif
}

void GUI::finish_step_import_(Status st, Occt_view::Step_import_geom& geom)
{
  const bool cancelled = !m_cad_busy_progress.IsNull() && m_cad_busy_progress->cancelled();
  m_cad_busy_kind       = Cad_busy_kind::Idle;
  m_cad_busy_progress   = {};
  m_cad_busy_modal_open = false;

  if (cancelled || (!st.is_ok() && st.message().find("cancelled") != std::string::npos))
  {
    show_message("STEP import cancelled.");
    return;
  }

  if (!st.is_ok())
  {
    show_message(st.message());
    return;
  }

  if (Status commit = m_view->commit_step_import(geom); !commit.is_ok())
  {
    show_message(commit.message());
    return;
  }

  const std::string name = std::filesystem::path(m_cad_busy_path).filename().string();
  switch (m_cad_busy_import_mode)
  {
  case Step_import_mode::Union_shapes:
    show_message("Imported (union): " + name);
    break;
  case Step_import_mode::Flat_solids:
    show_message("Imported (flat): " + name);
    break;
  default:
    show_message("Imported: " + name);
    break;
  }
  close_file_inspector_();
}

void GUI::poll_cad_busy_()
{
  if (m_cad_busy_kind != Cad_busy_kind::Import)
    return;

#ifdef __EMSCRIPTEN__
  if (m_cad_busy_defer_frames > 0)
  {
    --m_cad_busy_defer_frames;
    return;
  }

  Occt_view::Step_import_geom geom;
  Status st = Occt_view::prepare_step_import(m_cad_busy_bytes, m_cad_busy_import_mode, m_view->step_import_model_scale(),
                                             geom, {});
  finish_step_import_(st, geom);
#else
  if (!m_cad_busy_import_fut.valid())
    return;

  if (m_cad_busy_import_fut.wait_for(std::chrono::seconds(0)) != std::future_status::ready)
    return;

  auto [st, geom] = m_cad_busy_import_fut.get();
  finish_step_import_(st, geom);
#endif
}

void GUI::cad_busy_dialog_()
{
  if (m_cad_busy_open_popup)
  {
    ImGui::OpenPopup("##EzyCadCadBusy");
    m_cad_busy_open_popup = false;
  }

  if (!cad_busy_() && !m_cad_busy_modal_open)
    return;

#ifdef __EMSCRIPTEN__
  // Simple wait dialog (no Cancel / no close). Transfer runs on the main thread after paint.
  if (!cad_busy_())
  {
    if (ImGui::BeginPopupModal("##EzyCadCadBusy", nullptr, ImGuiWindowFlags_AlwaysAutoResize))
    {
      ImGui::CloseCurrentPopup();
      ImGui::EndPopup();
    }
    return;
  }

  ImGui::SetNextWindowSize(ImVec2(280.0f, 0.0f), ImGuiCond_Appearing);
  if (!ImGui::BeginPopupModal("##EzyCadCadBusy", nullptr,
                              ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoMove))
    return;

  ImGui::TextUnformatted("Importing...");
  const std::string name = std::filesystem::path(m_cad_busy_path).filename().string();
  if (!name.empty())
    ImGui::TextWrapped("%s", name.c_str());

  ImGui::EndPopup();
#else
  ImGui::SetNextWindowSize(ImVec2(420.0f, 0.0f), ImGuiCond_Appearing);
  if (!ImGui::BeginPopupModal("##EzyCadCadBusy", &m_cad_busy_modal_open, ImGuiWindowFlags_AlwaysAutoResize))
  {
    if (!m_cad_busy_modal_open && cad_busy_())
      cancel_cad_busy_();

    return;
  }

  ImGui::TextUnformatted(m_cad_busy_title.empty() ? "Importing" : m_cad_busy_title.c_str());
  const std::string name = std::filesystem::path(m_cad_busy_path).filename().string();
  if (!name.empty())
    ImGui::TextWrapped("%s", name.c_str());

  std::string stage = m_cad_busy_progress.IsNull() ? std::string("Working...") : m_cad_busy_progress->stage();
  if (stage.empty())
    stage = "Working...";
  ImGui::TextWrapped("%s", stage.c_str());

  const float pos = m_cad_busy_progress.IsNull() ? 0.f : m_cad_busy_progress->position();
  if (pos > 0.001f)
  {
    char overlay[32];
    std::snprintf(overlay, sizeof(overlay), "%.0f%%", static_cast<double>(pos) * 100.0);
    ImGui::ProgressBar(pos, ImVec2(-1.0f, 0.0f), overlay);
  }
  else
    ImGui::ProgressBar(-1.0f * static_cast<float>(ImGui::GetTime()), ImVec2(-1.0f, 0.0f), "Working...");

  if (ImGui::Button("Cancel", ImVec2(120.0f, 0.0f)))
    cancel_cad_busy_();

  ImGui::EndPopup();
#endif
}

void GUI::close_file_inspector_()
{
  m_file_inspector_open = false;
  m_file_inspector_path.clear();
  m_file_inspector_bytes.clear();
  m_file_inspector_fmt       = utl_cad_file_info::Format::Unknown;
  m_file_inspector_step_mode = Step_import_mode::Preserve_hierarchy;
}

void GUI::file_inspector_dialog_()
{
  if (!m_file_inspector_open)
    return;

  const std::string name  = std::filesystem::path(m_file_inspector_path).filename().string();
  const std::string title = "Import: " + (name.empty() ? std::string("file") : name);
  ImGui::SetNextWindowSize(ImVec2(360.0f, 0.0f), ImGuiCond_FirstUseEver);
  bool open = m_file_inspector_open;
  if (!ImGui::Begin(title.c_str(), &open, ImGuiWindowFlags_AlwaysAutoResize))
  {
    m_file_inspector_open = open;
    ImGui::End();
    return;
  }

  if (!name.empty())
    ImGui::TextUnformatted(name.c_str());

  if (utl_cad_file_info::can_import(m_file_inspector_fmt) && !m_file_inspector_bytes.empty())
  {
    const bool is_step = m_file_inspector_fmt == utl_cad_file_info::Format::Step;
    if (is_step)
    {
      static const char* k_step_import_labels[] = {
          "Preserve hierarchy",
          "Flat solids",
          "Union shapes",
      };
      int mode_i = static_cast<int>(m_file_inspector_step_mode);
      ImGui::SetNextItemWidth(220.0f);
      if (ImGui::Combo("Import as", &mode_i, k_step_import_labels, IM_ARRAYSIZE(k_step_import_labels)))
        m_file_inspector_step_mode = static_cast<Step_import_mode>(mode_i);
      if (ui_show_contextual_help() && ImGui::IsItemHovered())
        ImGui::SetTooltip("Preserve hierarchy: Shape List groups from the STEP assembly (default).\n"
                          "Flat solids: leaf solids only at the document root.\n"
                          "Union shapes: fuse all bodies into one solid.");
    }
    else
      m_file_inspector_step_mode = Step_import_mode::Preserve_hierarchy;

    ImGui::BeginDisabled(cad_busy_());
    if (ImGui::Button("Import into project"))
    {
      if (m_file_inspector_fmt == utl_cad_file_info::Format::Step)
        begin_step_import_(m_file_inspector_step_mode);
      else if (on_import_file(m_file_inspector_path, m_file_inspector_bytes, m_file_inspector_step_mode))
      {
        close_file_inspector_();
        ImGui::End();
        return;
      }
    }
    ImGui::EndDisabled();
  }
  else
    ImGui::TextWrapped("This file type cannot be imported.");

  m_file_inspector_open = open;
  if (!open)
    close_file_inspector_();

  ImGui::End();
}

float GUI::list_name_field_width_(const ImGuiStyle& st, const float max_name_text_w)
{
  constexpr float k_name_field_cap = 480.f;
  // Keep names editable even when all names are short.
  constexpr float k_name_field_floor = 72.f;
  const float     name_pad_x         = st.FramePadding.x * 2.0f;
  return std::clamp(max_name_text_w + name_pad_x, k_name_field_floor, k_name_field_cap);
}

#ifndef NDEBUG
void GUI::dbg_()
{
  if (!m_show_dbg)
    return;

  if (!ImGui::Begin("dbg", &m_show_dbg))
  {
    ImGui::End();
    return;
  }
  // Undo / redo stack
  ImGui::Text("Undo: %zu (Ctrl+Z)  |  Redo: %zu (Ctrl+Y)  [max 50]", m_view->undo_stack_size(), m_view->redo_stack_size());
  ImGui::Separator();
  // Get the available content region width
  float available_width = ImGui::GetContentRegionAvail().x;

  // Set the text wrapping position to match the available width
  ImGui::PushTextWrapPos(available_width);
  static std::string dbg_str;
  dbg_str.clear();
  m_view->curr_sketch().dbg_append_str(dbg_str);
  // Display the multiline text with wrapping
  ImGui::TextWrapped("%s", dbg_str.c_str());

  // Reset the wrapping position
  ImGui::PopTextWrapPos();
  ImGui::End();
}
#else
void GUI::dbg_() {}
#endif

void GUI::show_message(const std::string& message)
{
  m_message            = message;
  m_message_visible    = true;
  m_message_start_time = std::chrono::steady_clock::now();
  log_message(message);
}

void GUI::show_error_dialog(const std::string& title, const std::string& message)
{
  // Log full detail once; toast title only (do not call show_message - that would log twice).
  log_message(title + ": " + message);
  m_message             = title;
  m_message_visible     = true;
  m_message_start_time  = std::chrono::steady_clock::now();
  m_error_modal_title   = title;
  m_error_modal_message = message;
  m_open_error_modal    = true;
}

void GUI::error_modal_dialog_()
{
  if (m_open_error_modal)
  {
    m_error_modal_open = true;
    ImGui::SetNextWindowSize(ImVec2(480.0f, 0.0f), ImGuiCond_Appearing);
    ImGui::OpenPopup("##EzyCadErrorModal");
    m_open_error_modal = false;
  }

  if (!ImGui::BeginPopupModal("##EzyCadErrorModal", &m_error_modal_open, ImGuiWindowFlags_AlwaysAutoResize))
    return;

  ImGui::PushTextWrapPos(ImGui::GetCursorPos().x + 440.0f);
  ImGui::TextUnformatted(m_error_modal_title.c_str());
  ImGui::Separator();
  ImGui::TextWrapped("%s", m_error_modal_message.c_str());
  ImGui::PopTextWrapPos();
  ImGui::Spacing();

  if (ImGui::Button("OK", ImVec2(120.0f, 0.0f)))
  {
    m_error_modal_open = false;
    ImGui::CloseCurrentPopup();
  }
  ImGui::SetItemDefaultFocus();
  ImGui::EndPopup();
}

void GUI::message_status_window_()
{
  if (!m_message_visible || m_message.empty())
    return;

  // Check if 3 seconds have passed
  auto now     = std::chrono::steady_clock::now();
  auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(now - m_message_start_time).count();
  if (elapsed > 6000) // 6 seconds
  {
    m_message_visible = false;
    m_message.clear();
    return;
  }

  // Calculate fade effect (optional, for visual polish)
  float alpha = 1.0f;
  if (elapsed > 2500)                            // Start fading after 2.5 seconds
    alpha = 1.0f - (elapsed - 2500.0f) / 500.0f; // Fade over last 0.5 seconds

  // Set window position (bottom-right corner)
  ImGuiIO& io = ImGui::GetIO();
  ImVec2   window_pos(io.DisplaySize.x - 250.0f, io.DisplaySize.y - 50.0f); // Adjust as needed
  ImGui::SetNextWindowPos(window_pos, ImGuiCond_Always);
  ImGui::SetNextWindowSize(ImVec2(240.0f, 40.0f), ImGuiCond_Once);

  // Begin window with minimal flags
  ImGui::Begin("MessageStatus##unique_id", nullptr,
               ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_AlwaysAutoResize |
                   ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoFocusOnAppearing | ImGuiWindowFlags_NoNav);

  // Set text color with alpha for fade effect
  ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 0.0f, 0.0f, alpha));
  ImGui::TextWrapped("%s", m_message.c_str());
  ImGui::PopStyleColor();

  ImGui::End();
}

// Log window implementation
namespace
{

std::string format_log_line(const std::string& base, size_t repeat_count)
{
  if (repeat_count <= 1)
    return base;
  return base + " #" + std::to_string(repeat_count);
}

void append_log_line(std::vector<char>& buffer, const std::string& line)
{
  if (buffer.size() > 1)
  {
    buffer.pop_back(); // trailing '\0'
    buffer.push_back('\n');
  }
  else if (!buffer.empty())
    buffer.pop_back();

  buffer.insert(buffer.end(), line.begin(), line.end());
  buffer.push_back('\0');
}

} // namespace

void GUI::log_message(const std::string& message)
{
  if (!m_log_last_line_base.empty() && message == m_log_last_line_base)
  {
    ++m_log_repeat_count;
    const std::string line = format_log_line(m_log_last_line_base, m_log_repeat_count);
    m_log_buffer.resize(m_log_last_line_start);
    m_log_buffer.insert(m_log_buffer.end(), line.begin(), line.end());
    m_log_buffer.push_back('\0');
    m_log_scroll_to_bottom = true;
    return;
  }

  append_log_line(m_log_buffer, message);
  m_log_last_line_base   = message;
  m_log_last_line_start  = m_log_buffer.size() - message.size() - 1;
  m_log_repeat_count     = 1;
  m_log_scroll_to_bottom = true;
}

void GUI::log_window_()
{
  if (!log_window_visible_effective())
    return;

  if (!ImGui::Begin("Log", &m_log_window_visible, ImGuiWindowFlags_None))
  {
    ImGui::End();
    return;
  }

  if (m_log_buffer.empty())
    m_log_buffer.push_back('\0');

  ImGui::BeginChild("LogScroll", ImVec2(0, 0), true, ImGuiWindowFlags_HorizontalScrollbar);
  const char* log_begin = m_log_buffer.data();
  const char* log_end   = m_log_buffer.size() > 1 ? log_begin + m_log_buffer.size() - 1 : log_begin;
  ImGui::TextUnformatted(log_begin, log_end);
  if (m_log_scroll_to_bottom)
  {
    ImGui::SetScrollHereY(1.0f);
    m_log_scroll_to_bottom = false;
  }

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

void GUI::lua_console_()
{
  if (!show_lua_console_effective())
    return;
  if (!m_lua_console)
    m_lua_console = std::make_unique<Lua_console>(this);
  m_lua_console->render(&m_show_lua_console);
}

void GUI::python_console_()
{
  if (!show_python_console_effective())
    return;

  if (!m_python_console)
    m_python_console = std::make_unique<Python_console>(this);
  m_python_console->render(&m_show_python_console);
}

void GUI::ensure_python_console()
{
#ifdef EZYCAD_HAVE_PYTHON
  if (!m_python_console)
    m_python_console = std::make_unique<Python_console>(this);
#endif
}

Python_console* GUI::get_python_console() { return m_python_console.get(); }

void GUI::init(GLFWwindow* window, ImFont* console_font)
{
  m_glfw_window  = window;
  m_console_font = console_font;
  initialize_toolbar_();
  settings::set_log_callback([this](const std::string& m) { log_message(m); });
  setup_log_redirection_(); // Set up stream redirection
  log_message("EzyCad: initializing 3D view...");
  m_view->init_window(window);
  m_view->init_viewer();
  m_view->init_default();
  log_message("EzyCad: 3D view ready (initial empty document).");

  load_occt_view_settings_();
  // Re-frame after settings load so Default 2D view width/height apply (init_default ran with defaults).
  m_view->reset_default_view();

  load_examples_list_();
  if (m_example_files.empty())
    log_message("EzyCad: no example projects found under res/examples.");
  else
    log_message("EzyCad: " + std::to_string(m_example_files.size()) + " example project(s) available in File > Examples.");

  load_default_project_();
}

void GUI::persist_last_opened_project_path_(const std::string& path)
{
#ifndef __EMSCRIPTEN__
  if (path.empty() || path == "(startup)")
    return;

  try
  {
    const std::filesystem::path p(path);
    if (p.empty())
      return;

    m_last_opened_project_path = p.generic_string();
    save_occt_view_settings();
  }
  catch (...)
  {
  }
#endif
}

void GUI::load_default_project_()
{
  static constexpr char k_bundled_default[] = "res/default.ezy";

  log_message("EzyCad: resolving startup document...");

#ifndef __EMSCRIPTEN__
  if (m_load_last_opened_on_startup && !m_last_opened_project_path.empty())
    try
    {
      const std::filesystem::path p(m_last_opened_project_path);
      if (std::filesystem::exists(p))
      {
        std::ifstream file(p, std::ios::binary);
        if (file.is_open())
        {
          const std::string file_bytes{std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>()};
          if (is_valid_project_file_(file_bytes))
          {
            log_message("EzyCad: loading last opened project: " + p.string());
            on_file(p.string(), file_bytes, false);
            log_message("EzyCad: startup document loaded (last opened).");
            return;
          }

          log_message("EzyCad: last opened project JSON is invalid; falling back to startup/default.");
          show_message("Last opened project file is invalid; loading startup/default.");
        }
      }
      else
        log_message("EzyCad: last opened project path not found; falling back to startup/default.");
    }
    catch (...)
    {
      log_message("EzyCad: could not load last opened project; falling back to startup/default.");
    }
#endif

  const std::string user_startup = settings::load_user_startup_project();
  if (is_valid_project_file_(user_startup))
  {
#ifdef __EMSCRIPTEN__
    log_message("EzyCad: loading saved startup project (browser storage).");
#else
    {
      const std::filesystem::path p = settings::user_startup_project_path();
      log_message("EzyCad: loading saved startup project: " + (p.empty() ? std::string("(user storage)") : p.string()));
    }
#endif
    on_file("(startup)", user_startup, false);
    m_last_saved_path.clear();
    log_message("EzyCad: startup document loaded (saved startup).");
    return;
  }
  if (!user_startup.empty())
  {
    log_message("EzyCad: saved startup project is invalid or incomplete; falling back to install default.");
    show_message("Saved startup project is invalid; loading install default.");
  }
  else
    log_message("EzyCad: no saved startup project; trying bundled default.");

  std::ifstream file(k_bundled_default, std::ios::binary);
  if (!file.is_open())
  {
    log_message("EzyCad: bundled " + std::string(k_bundled_default) + " not found; keeping initial empty document.");
    return;
  }

  const std::string file_bytes{std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>()};
  if (is_valid_project_file_(file_bytes))
  {
    log_message("EzyCad: loading bundled default project (" + std::string(k_bundled_default) + ").");
    on_file(k_bundled_default, file_bytes, false);
    m_last_saved_path.clear();
    log_message("EzyCad: startup document loaded (bundled default).");
  }
  else
    log_message("EzyCad: bundled " + std::string(k_bundled_default) + " is invalid; keeping initial empty document.");
}

void GUI::clear_sketch_list_ui_()
{
  m_sketch_list_ui.clear();
  m_sketch_list_scroll_y       = 0.f;
  m_sketch_list_scroll_restore = false;
  m_shape_list_expanded.clear();
}

nlohmann::json GUI::shape_list_ui_to_json_() const
{
  using namespace nlohmann;
  json out;
  json expanded = json::object();
  for (const auto& [id, is_open] : m_shape_list_expanded)
  {
    if (!is_open)
      expanded[std::to_string(id)] = false;
  }
  if (!expanded.empty())
    out["expanded"] = std::move(expanded);

  if (m_view && m_view->current_group_id() != 0)
    out["currentGroupId"] = m_view->current_group_id();

  return out;
}

void GUI::apply_shape_list_ui_from_json_(const nlohmann::json& j)
{
  using namespace nlohmann;
  m_shape_list_expanded.clear();
  if (m_view)
    m_view->set_current_group_id(0);

  if (!j.contains("ui") || !j["ui"].is_object())
    return;

  const json& ui = j["ui"];
  if (!ui.contains("shapeList") || !ui["shapeList"].is_object())
    return;

  const json& sl = ui["shapeList"];
  if (sl.contains("expanded") && sl["expanded"].is_object())
  {
    for (auto it = sl["expanded"].begin(); it != sl["expanded"].end(); ++it)
    {
      if (!it.value().is_boolean())
        continue;

      try
      {
        const Shape_id id         = static_cast<Shape_id>(std::stoull(it.key()));
        m_shape_list_expanded[id] = it.value().get<bool>();
      }
      catch (...)
      {
      }
    }
  }

  if (m_view && sl.contains("currentGroupId") && sl["currentGroupId"].is_number_unsigned())
    m_view->set_current_group_id(sl["currentGroupId"].get<Shape_id>());
}

nlohmann::json GUI::sketch_list_ui_to_json_() const
{
  using namespace nlohmann;
  json out;
  out["scrollY"] = m_sketch_list_scroll_y;

  json rows = json::object();
  for (const Sketch::sptr& sketch : m_view->get_sketches())
  {
    EZY_ASSERT(sketch);
    const auto it = m_sketch_list_ui.find(sketch->get_id());
    if (it == m_sketch_list_ui.end())
      continue;

    const Sketch_list_row_ui& ui = it->second;
    if (!ui.expanded && !ui.dimensions && !ui.nodes && !ui.edges && !ui.faces)
      continue;

    json row;
    if (ui.expanded)
      row["expanded"] = true;
    if (ui.dimensions)
      row["dimensions"] = true;
    if (ui.nodes)
      row["nodes"] = true;
    if (ui.edges)
      row["edges"] = true;
    if (ui.faces)
      row["faces"] = true;
    rows[std::to_string(sketch->get_id())] = std::move(row);
  }
  if (!rows.empty())
    out["rows"] = std::move(rows);

  return out;
}

void GUI::apply_sketch_list_ui_from_json_(const nlohmann::json& j)
{
  using namespace nlohmann;
  clear_sketch_list_ui_();

  if (!j.contains("ui") || !j["ui"].is_object())
    return;

  const json& ui = j["ui"];
  if (!ui.contains("sketchList") || !ui["sketchList"].is_object())
    return;

  const json& sl = ui["sketchList"];
  if (sl.contains("scrollY") && sl["scrollY"].is_number())
  {
    m_sketch_list_scroll_y       = sl["scrollY"].get<float>();
    m_sketch_list_scroll_restore = true;
  }

  if (!sl.contains("rows") || !sl["rows"].is_object())
    return;

  for (const auto& [key, row] : sl["rows"].items())
  {
    if (!row.is_object() || key.empty())
      continue;

    char*                    end    = nullptr;
    const unsigned long long parsed = std::strtoull(key.c_str(), &end, 10);
    if (!end || *end != '\0')
      continue;

    const size_t        id     = static_cast<size_t>(parsed);
    Sketch_list_row_ui& ui_row = m_sketch_list_ui[id];
    if (row.contains("expanded") && row["expanded"].is_boolean())
      ui_row.expanded = row["expanded"].get<bool>();
    if (row.contains("dimensions") && row["dimensions"].is_boolean())
      ui_row.dimensions = row["dimensions"].get<bool>();
    if (row.contains("nodes") && row["nodes"].is_boolean())
      ui_row.nodes = row["nodes"].get<bool>();
    if (row.contains("edges") && row["edges"].is_boolean())
      ui_row.edges = row["edges"].get<bool>();
    if (row.contains("faces") && row["faces"].is_boolean())
      ui_row.faces = row["faces"].get<bool>();
  }
}

std::string GUI::serialized_project_json_() const
{
  using namespace nlohmann;
  std::string project_json = m_view->to_json();
  json        j            = json::parse(project_json);
  j["mode"]                = static_cast<int>(get_mode());
  j["ui"]["sketchList"]    = sketch_list_ui_to_json_();
  j["ui"]["shapeList"]     = shape_list_ui_to_json_();
  return j.dump(2);
}

std::vector<uint8_t> GUI::serialized_project_ezy_() const
{
  const std::string manifest = serialized_project_json_();
  return pack_ezy(manifest, m_view->asset_store());
}

void GUI::save_startup_project_()
{
  const std::vector<uint8_t> ezy_bytes = serialized_project_ezy_();
  if (!settings::save_user_startup_project(ezy_bytes))
  {
    show_message("Could not save startup project.");
    return;
  }

#ifndef __EMSCRIPTEN__
  const std::filesystem::path p = settings::user_startup_project_path();
  if (!p.empty())
    log_message("Startup saved to: " + p.string());
#endif
  show_message("Startup project saved. It will load automatically the next time you start EzyCad.");
}

void GUI::clear_saved_startup_project_()
{
  settings::clear_user_startup_project();
  show_message("Saved startup cleared. Next launch uses the install default (res/default.ezy).");
}

void GUI::on_mouse_pos(const ScreenCoords& screen_coords)
{
  m_view->on_mouse_move(screen_coords);

  switch (get_mode())
  {
  case Mode::Move:
    if (Status s = m_view->shp_move().move_selected(screen_coords); !s.is_ok())
      show_message(s.message());

    break;

  case Mode::Rotate:
    if (Status s = m_view->shp_rotate().rotate_selected(screen_coords); !s.is_ok())
      show_message(s.message());

    break;

  case Mode::Scale:
    if (Status s = m_view->shp_scale().scale_selected(screen_coords); !s.is_ok())
      show_message(s.message());

    break;

  case Mode::Shape_cyl_align:
    if (Status s = m_view->shp_cyl_align().drag_depth(screen_coords); !s.is_ok())
      show_message(s.message());

    break;

  case Mode::Shape_polar_duplicate:
    if (Status s = m_view->shp_polar_dup().move_point(screen_coords); !s.is_ok())
      show_message(s.message());

    break;

    // clang-format off
    case Mode::Sketch_add_node:
    case Mode::Sketch_add_edge:
    case Mode::Sketch_add_multi_edges:
    case Mode::Sketch_operation_axis:
    case Mode::Sketch_add_square:
    case Mode::Sketch_add_rectangle:
    case Mode::Sketch_add_rectangle_center_pt:
    case Mode::Sketch_add_circle:
    case Mode::Sketch_add_slot:
    case Mode::Sketch_add_seg_circle_arc:
    case Mode::Sketch_dim_anno:           m_view->curr_sketch().sketch_pt_move(screen_coords);  break;
    case Mode::Sketch_face_extrude:       m_view->sketch_face_extrude(screen_coords, true);     break;
    // clang-format on
  default:
    break;
  }
}

void GUI::mirror_selected_sketch_edges() { m_view->curr_sketch().mirror_selected_edges(); }

void GUI::on_left_click_(const ScreenCoords& screen_coords)
{
  switch (m_mode)
  {
    // clang-format off
  case Mode::Move:                m_view->shp_move().finalize();                      break;
  case Mode::Rotate:              m_view->shp_rotate().finalize();                    break;
  case Mode::Scale:               m_view->shp_scale().finalize();                     break;
  case Mode::Shape_cyl_align:
    if (m_view->shp_cyl_align().is_dragging())
      m_view->shp_cyl_align().finalize();
    else if (Status s = m_view->shp_cyl_align().pick(screen_coords); !s.is_ok())
      show_message(s.message());
    break;
  case Mode::Sketch_face_extrude: m_view->sketch_face_extrude(screen_coords, false);  break;
    // clang-format on

  case Mode::Sketch_add_node:
  case Mode::Sketch_add_edge:
  case Mode::Sketch_add_multi_edges:
  case Mode::Sketch_add_seg_circle_arc:
  case Mode::Sketch_add_square:
  case Mode::Sketch_add_rectangle:
  case Mode::Sketch_add_rectangle_center_pt:
  case Mode::Sketch_add_circle:
  case Mode::Sketch_add_slot:
    hide_dist_edit();
    m_view->curr_sketch().add_sketch_pt(screen_coords);
    break;

  case Mode::Sketch_operation_axis:
    // Only treat LMB as "place axis point" while *defining* the axis.
    // Once an axis exists, we stay in this mode so the Options panel can show
    // the Mirror/Revolve/Clear buttons. Further clicks must be allowed to
    // select sketch edges/faces (via AIS selection) without redefining the axis.
    // To redefine, the user must first use the "Clear axis" button.
    if (!m_view->curr_sketch().has_operation_axis())
    {
      hide_dist_edit();
      m_view->curr_sketch().add_sketch_pt(screen_coords);
    }
    break;

  case Mode::Shape_chamfer:
    if (Status s = m_view->shp_chamfer().add_chamfer(screen_coords, m_chamfer_mode); !s.is_ok())
      show_message(s.message());

    break;

  case Mode::Shape_fillet:
    if (Status s = m_view->shp_fillet().add_fillet(screen_coords, m_fillet_mode); !s.is_ok())
      show_message(s.message());

    break;

  case Mode::Shape_polar_duplicate:
    if (Status s = m_view->shp_polar_dup().add_point(screen_coords); !s.is_ok())
      show_message(s.message());

    break;

  default:
    break;
  }
}

void GUI::sketch_left_click(const ScreenCoords& screen_coords)
{
  m_view->on_mouse_move(screen_coords);
  on_left_click_(screen_coords);
}

void GUI::on_mouse_button(int button, int action, int mods)
{
  const ScreenCoords screen_coords = cursor_screen_coords();

  if (button == GLFW_MOUSE_BUTTON_LEFT && action == GLFW_PRESS && mods == 0)
    if (try_underlay_calib_click_(screen_coords))
    {
      m_view->on_mouse_move(screen_coords);
      m_view->ctx().UpdateCurrentViewer();
      return;
    }

  // Sample before the view call: Occt_view advances or finalizes an active extrude on LMB press.
  // Skipping on_left_click_ prevents the same click from re-picking the face (or restarting height).
  const bool extrude_finalize_on_press = button == GLFW_MOUSE_BUTTON_LEFT && action == GLFW_PRESS && mods == 0 &&
                                         m_mode == Mode::Sketch_face_extrude && m_view->shp_extrude().has_active_extrusion();

  m_view->on_mouse_button(button, action, mods);

  m_view->on_mouse_move(screen_coords);
  m_view->ctx().UpdateCurrentViewer();

  if (button == GLFW_MOUSE_BUTTON_LEFT && action == GLFW_PRESS && mods == 0 && !extrude_finalize_on_press)
    on_left_click_(screen_coords);
  else if (button == GLFW_MOUSE_BUTTON_RIGHT && action == GLFW_PRESS && mods == 0)
    // Right button is to finalize the current operation.
    switch (m_mode)
    {
    case Mode::Sketch_add_edge:
      Sketch::set_edge_from_center(m_edge_from_center);
      Sketch::set_add_mid_pt_edges(m_add_mid_pt_line_edges);
      m_view->curr_sketch().finalize_elm();
      break;

    case Mode::Sketch_add_multi_edges:
      Sketch::set_add_mid_pt_edges(m_add_mid_pt_line_edges);
      m_view->curr_sketch().finalize_elm();
      break;

    default:
      break;
    }
}

void GUI::on_mouse_scroll(double xoffset, double yoffset)
{
  EZY_ASSERT(m_glfw_window != nullptr);

  const bool shift_finer = glfwGetKey(m_glfw_window, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS ||
                           glfwGetKey(m_glfw_window, GLFW_KEY_RIGHT_SHIFT) == GLFW_PRESS;

  m_view->on_mouse_scroll(xoffset, yoffset, shift_finer);
}

void GUI::on_resize(int width, int height) { m_view->on_resize(width, height); }

void GUI::setup_log_redirection_()
{
  // Store original stream buffers
  m_original_cout_buf = std::cout.rdbuf();
  m_original_cerr_buf = std::cerr.rdbuf();

  // Create custom stream buffers
  m_cout_log_buf = new Log_strm(*this, m_original_cout_buf);
  m_cerr_log_buf = new Log_strm(*this, m_original_cerr_buf);

  // Redirect stdout and stderr
  std::cout.rdbuf(m_cout_log_buf);
  std::cerr.rdbuf(m_cerr_log_buf);
}

void GUI::cleanup_log_redirection_()
{
  // Restore original stream buffers
  if (m_original_cout_buf)
    std::cout.rdbuf(m_original_cout_buf);

  if (m_original_cerr_buf)
    std::cerr.rdbuf(m_original_cerr_buf);

  // Delete custom stream buffers
  delete m_cout_log_buf;
  delete m_cerr_log_buf;

  m_cout_log_buf      = nullptr;
  m_cerr_log_buf      = nullptr;
  m_original_cout_buf = nullptr;
  m_original_cerr_buf = nullptr;
}

// Import/export related
void GUI::open_export_units_dialog_(Export_format fmt)
{
  m_export_pending_fmt = fmt;
  // Defaults match prior fixed behavior: STEP/IGES mm, STL/PLY inches.
  switch (fmt)
  {
  case Export_format::Step:
  case Export_format::Iges:
    m_export_unit = Export_unit::Millimeter;
    break;
  case Export_format::Stl:
  case Export_format::Ply:
    m_export_unit = Export_unit::Inch;
    break;
  }
  m_open_export_units_modal = true;
}

void GUI::export_units_dialog_()
{
  if (m_open_export_units_modal)
  {
    m_export_units_modal_open = true;
    ImGui::OpenPopup("Export units");
    m_open_export_units_modal = false;
  }

  if (!ImGui::BeginPopupModal("Export units", &m_export_units_modal_open, ImGuiWindowFlags_AlwaysAutoResize))
    return;

  const char* fmt_label = "STEP";
  switch (m_export_pending_fmt)
  {
  case Export_format::Step:
    break;
  case Export_format::Iges:
    fmt_label = "IGES";
    break;
  case Export_format::Stl:
    fmt_label = "STL";
    break;
  case Export_format::Ply:
    fmt_label = "PLY";
    break;
  }

  ImGui::Text("Export %s in which units?", fmt_label);
  ImGui::Spacing();

  if (ImGui::RadioButton("Inches", m_export_unit == Export_unit::Inch))
    m_export_unit = Export_unit::Inch;
  if (ImGui::RadioButton("Millimeters", m_export_unit == Export_unit::Millimeter))
    m_export_unit = Export_unit::Millimeter;

  ImGui::Spacing();
  if (m_export_pending_fmt == Export_format::Stl || m_export_pending_fmt == Export_format::Ply)
    ImGui::TextWrapped("STL and PLY have no unit metadata; vertex coordinates will be in the chosen unit.");

  ImGui::Spacing();
  if (ImGui::Button("Export", ImVec2(120.0f, 0.0f)))
  {
    const Export_format fmt  = m_export_pending_fmt;
    const Export_unit   unit = m_export_unit;
    ImGui::CloseCurrentPopup();
    m_export_units_modal_open = false;
    export_file_dialog_(fmt, unit);
  }
  ImGui::SameLine();
  if (ImGui::Button("Cancel", ImVec2(120.0f, 0.0f)))
  {
    ImGui::CloseCurrentPopup();
    m_export_units_modal_open = false;
  }

  ImGui::EndPopup();
}

void GUI::export_file_dialog_(Export_format fmt, Export_unit unit)
{
#ifndef __EMSCRIPTEN__
  const char* title       = "Export STEP";
  const char* def_name    = "export.step";
  const char* filter_pat  = "*.step";
  const char* filter_desc = "STEP files";
  switch (fmt)
  {
  case Export_format::Step:
    break;
  case Export_format::Iges:
    title       = "Export IGES";
    def_name    = "export.igs";
    filter_pat  = "*.igs";
    filter_desc = "IGES files";
    break;
  case Export_format::Stl:
    title       = "Export STL";
    def_name    = "export.stl";
    filter_pat  = "*.stl";
    filter_desc = "STL files";
    break;
  case Export_format::Ply:
    title       = "Export PLY";
    def_name    = "export.ply";
    filter_pat  = "*.ply";
    filter_desc = "PLY files";
    break;
  }

  char const* filter_patterns[1] = {filter_pat};
  char const* selected           = tinyfd_saveFileDialog(title, def_name, 1, filter_patterns, filter_desc);
  if (!selected)
  {
    show_message("Export canceled");
    return;
  }

  const Status s = m_view->export_document(fmt, unit, selected);
  if (!s.is_ok())
    show_message(s.message());
  else
    show_message("Exported: " + std::filesystem::path(selected).filename().string());
#else
  const char* mem_path = "/ezycad_export.step";
  std::string download_name{"export.step"};
  switch (fmt)
  {
  case Export_format::Step:
    break;
  case Export_format::Iges:
    mem_path      = "/ezycad_export.igs";
    download_name = "export.igs";
    break;
  case Export_format::Stl:
    mem_path      = "/ezycad_export.stl";
    download_name = "export.stl";
    break;
  case Export_format::Ply:
    mem_path      = "/ezycad_export.ply";
    download_name = "export.ply";
    break;
  }
  const Status s = m_view->export_document(fmt, unit, mem_path);
  if (!s.is_ok())
  {
    show_message(s.message());
    return;
  }
  std::ifstream in(mem_path, std::ios::binary);
  if (!in)
  {
    show_message("Export read failed.");
    return;
  }
  const std::string bytes((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
  download_blob_async(download_name, bytes);
  show_message("Exported: " + download_name);
#endif
}

void GUI::import_file_dialog_()
{
#ifndef __EMSCRIPTEN__
  // Native: Use tinyfiledialogs
  char const* filter_patterns[3] = {"*.step", "*.stp", "*.ply"};
  char const* selected           = tinyfd_openFileDialog("Import STEP or PLY", "", 3, filter_patterns, "STEP / PLY files", 0);

  if (selected)
  {
    // Binary mode required for PLY (mesh payload may contain 0x1A; Windows text mode treats that as EOF).
    std::ifstream file(selected, std::ios::binary);
    if (!file.is_open())
    {
      show_message("Error opening: " + std::filesystem::path(selected).filename().string());
      return;
    }

    const std::string file_bytes{std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>()};
    if (!file_bytes.empty())
      on_inspector_file(selected, file_bytes);
    else
      show_message("Error opening: " + std::filesystem::path(selected).filename().string());
  }
#else
  import_file_dialog_async();
#endif
}

// New, open, save related
void GUI::new_project_()
{
  m_last_saved_path.clear();
  clear_sketch_list_ui_();
  m_view->new_file();
}

void GUI::open_file_dialog_()
{
#ifndef __EMSCRIPTEN__
  // Native: Use tinyfiledialogs
  char const* filter_patterns[1] = {"*.ezy"};                                   // Restrict to .ezy files
  char const* selected           = tinyfd_openFileDialog("Open EzyCad project", // Dialog title
                                                         "",                    // Default path (empty for OS default)
                                                         1,                     // Number of filter patterns
                                                         filter_patterns,       // Filter patterns (*.ezy)
                                                         "EzyCad Files",        // Filter description
                                                         0                      // Single file selection
            );
  if (selected)
  {
    std::ifstream     file(selected, std::ios::binary);
    const std::string file_bytes{std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>()};
    if (file.good() && !file_bytes.empty())
      on_file(selected, file_bytes);

    else
      show_message("Error opening: " + std::filesystem::path(selected).filename().string());
  }
#else
  // Emscripten: Call async version (synchronous fallback for simplicity)
  open_file_dialog_async();
#endif
}

void GUI::save_file_dialog_()
{
  const std::vector<uint8_t> ezy_bytes = serialized_project_ezy_();

#ifndef __EMSCRIPTEN__
  std::string file;
  if (!m_last_saved_path.empty())
    file = m_last_saved_path; // Reuse last saved path
  else
  {
    char const* filter_patterns[1] = {"*.ezy"};
    char const* selected = tinyfd_saveFileDialog("Save EzyCad Project", "project.ezy", 1, filter_patterns, "EzyCad Files");
    if (selected)
    {
      file              = selected;
      m_last_saved_path = file; // Update last saved path
    }
  }
  if (!file.empty())
  {
    auto describe_save_failure = [&](const char* stage) -> std::string
    {
      const int          err  = errno;
      const std::string  name = std::filesystem::path(file).filename().string();
      std::ostringstream msg;
      msg << "Could not save \"" << name << "\".\n\n";
      msg << "Path:\n" << file << "\n\n";
      msg << "Failed while: " << stage << "\n";
      if (err != 0)
      {
        msg << "System error: ";
#ifdef _MSC_VER
        char err_buf[256] = {};
        if (strerror_s(err_buf, sizeof(err_buf), err) == 0)
          msg << err_buf;
        else
          msg << "code " << err;
#else
        const char* err_str = std::strerror(err);
        msg << (err_str ? err_str : "unknown");
#endif
        msg << " (" << err << ")\n";
      }
      msg << "\n";
      if (err == EACCES || err == EPERM
#ifdef EROFS
          || err == EROFS
#endif
      )
        msg << "The file may be open in another program, or you may not have permission to write there. "
               "Close the file elsewhere and try again.";
      else if (err == ENOSPC)
        msg << "There may not be enough free disk space.";
      else if (err == ENOENT)
        msg << "The destination folder may not exist.";
      else
        msg << "Check that the path is writable and the file is not locked by another application.";
      return msg.str();
    };

    errno = 0;
    std::ofstream out(file, std::ios::binary);
    if (!out.is_open())
    {
      show_error_dialog("Save failed", describe_save_failure("opening the file for write"));
    }
    else
    {
      errno = 0;
      out.write(reinterpret_cast<const char*>(ezy_bytes.data()), static_cast<std::streamsize>(ezy_bytes.size()));
      out.flush();
      if (!out.good())
      {
        show_error_dialog("Save failed", describe_save_failure("writing file data"));
      }
      else
      {
        out.close();
        if (!out)
          show_error_dialog("Save failed", describe_save_failure("closing the file"));
        else
          show_message("Saved: " + std::filesystem::path(file).filename().string());
      }
    }
  }
  else
    show_message("Save canceled");
#else
  if (ezy_bytes.empty())
  {
    show_error_dialog("Save failed",
                      "Could not save the project.\n\nFailed while: building project data\n\n"
                      "The serialized project was empty. Try again, or use File -> Save settings if only preferences "
                      "changed.");
    return;
  }
  std::string default_file =
      m_last_saved_path.empty() ? "project.ezy" : std::filesystem::path(m_last_saved_path).filename().string();
  save_file_dialog_async("Save EzyCad project", default_file, ezy_bytes);
#endif
}

void GUI::on_file(const std::string& file_path, const std::string& file_bytes, bool announce_load)
{
  using namespace nlohmann;

  log_message("on_file: path=" + file_path + " bytes=" + std::to_string(file_bytes.size()) +
              " zip=" + (is_ezy_zip(file_bytes) ? "yes" : "no") + " json=" + (is_ezy_json(file_bytes) ? "yes" : "no"));

  m_view->push_undo_snapshot();
  const std::optional<std::string> manifest = manifest_from_project_file_(file_bytes, *m_view, true);
  if (!manifest)
    log_message("on_file: manifest_from_project_file_ FAILED");
  else
    log_message("on_file: manifest ok, len=" + std::to_string(manifest->size()) +
                " valid=" + (is_valid_project_manifest_(*manifest) ? "yes" : "no"));

  if (!manifest || !is_valid_project_manifest_(*manifest))
  {
    m_view->pop_undo_snapshot();
    show_message("Invalid EzyCad project: " + std::filesystem::path(file_path).filename().string());
    return;
  }

  const json j = json::parse(*manifest);
  m_view->load(*manifest);
  log_message("on_file: load complete");
  apply_sketch_list_ui_from_json_(j);
  apply_shape_list_ui_from_json_(j);
  m_last_saved_path = file_path;
  Mode opened_mode  = Mode::Normal;
  if (j.contains("mode") && j["mode"].is_number_integer())
  {
    const int idx = j["mode"].get<int>();
    if (idx >= 0 && idx < static_cast<int>(Mode::_count))
      opened_mode = static_cast<Mode>(idx);
  }
  set_mode(opened_mode);
#ifndef __EMSCRIPTEN__
  if (file_path != "(startup)" && !file_path.empty() && file_path != "res/default.ezy")
    persist_last_opened_project_path_(file_path);
#endif
  if (announce_load)
    show_message("Opened: " + std::filesystem::path(file_path).filename().string());
}

bool GUI::on_import_file(const std::string& file_path, const std::string& file_data, const Step_import_mode step_mode)
{
  std::string ext = std::filesystem::path(file_path).extension().string();
  for (char& c : ext)
    c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));

  if (ext == ".ply")
  {
    if (!m_view->import_ply(file_data))
    {
      show_message("PLY import failed.");
      return false;
    }

    show_message("Imported: " + std::filesystem::path(file_path).filename().string());
    return true;
  }

  if (Status st = m_view->import_step(file_data, step_mode); !st.is_ok())
  {
    show_message(st.message());
    return false;
  }

  const std::string base = "Imported: " + std::filesystem::path(file_path).filename().string();
  switch (step_mode)
  {
  case Step_import_mode::Union_shapes:
    show_message("Imported (union): " + std::filesystem::path(file_path).filename().string());
    break;
  case Step_import_mode::Flat_solids:
    show_message("Imported (flat): " + std::filesystem::path(file_path).filename().string());
    break;
  case Step_import_mode::Preserve_hierarchy:
  default:
    show_message(base);
    break;
  }
  return true;
}

void GUI::on_inspector_file(const std::string& file_path, const std::string& file_data)
{
  open_file_inspector_(file_path, file_data);
}

#ifdef __EMSCRIPTEN__
void GUI::open_file_dialog_async()
{
  EM_ASM({
    var input           = document.createElement('input');
    input.type          = 'file';
    input.accept        = '.ezy';
    input.style.display = 'none';
    document.body.appendChild(input);
    input.onchange = function(e)
    {
      var file = e.target.files[0];
      if (file)
      {
        var reader    = new FileReader();
        reader.onload = function(e)
        {
          var contents = new Uint8Array(e.target.result);
          var fileName = file.name;
          // Allocate heap memory for contents
          var length      = contents.length;
          var contentsPtr = _malloc(length);
          HEAPU8.set(contents, contentsPtr);
          // Call C++ callback with path and contents
          Module.ccall('on_file_selected', null, [ 'string', 'number', 'number' ], [ fileName, contentsPtr, length ]);
          _free(contentsPtr);
        };
        reader.readAsArrayBuffer(file);
      }
      document.body.removeChild(input);
    };
    input.click();
  });
}
void GUI::import_file_dialog_async()
{
  EM_ASM({
    var input           = document.createElement('input');
    input.type          = 'file';
    input.accept        = '.step,.stp,.ply';
    input.style.display = 'none';
    document.body.appendChild(input);
    input.onchange = function(e)
    {
      var file = e.target.files[0];
      if (file)
      {
        var reader    = new FileReader();
        reader.onload = function(e)
        {
          var contents    = new Uint8Array(e.target.result);
          var fileName    = file.name;
          var length      = contents.length;
          var contentsPtr = _malloc(length);
          HEAPU8.set(contents, contentsPtr);
          // File -> Import opens the Import dialog (metadata, then Import into project).
          Module.ccall('on_inspector_file_selected', null, [ 'string', 'number', 'number' ], [ fileName, contentsPtr, length ]);
          _free(contentsPtr);
        };
        reader.readAsArrayBuffer(file);
      }
      document.body.removeChild(input);
    };
    input.click();
  });
}
void GUI::sketch_underlay_file_dialog_async()
{
  EM_ASM({
    var input           = document.createElement('input');
    input.type          = 'file';
    input.accept        = 'image/png,image/jpeg,image/bmp,.png,.jpg,.jpeg,.bmp';
    input.style.display = 'none';
    document.body.appendChild(input);
    input.onchange = function(e)
    {
      var file = e.target.files[0];
      if (file)
      {
        var reader    = new FileReader();
        reader.onload = function(e)
        {
          var contents    = new Uint8Array(e.target.result);
          var fileName    = file.name;
          var length      = contents.length;
          var contentsPtr = _malloc(length);
          HEAPU8.set(contents, contentsPtr);
          Module.ccall('on_sketch_underlay_selected', null, [ 'string', 'number', 'number' ],
                       [ fileName, contentsPtr, length ]);
          _free(contentsPtr);
        };
        reader.readAsArrayBuffer(file);
      }
      document.body.removeChild(input);
    };
    input.click();
  });
}
void GUI::save_file_dialog_async(const char* title, const std::string& default_file, const std::vector<uint8_t>& ezy_bytes)
{
  (void)title;
  EM_ASM_ARGS(
      {
        try
        {
          var data = HEAPU8.subarray($0, $0 + $1);
          var blob = new Blob([data],
                              {
                                type:
                                  'application/octet-stream'
                              });
          var url    = URL.createObjectURL(blob);
          var a      = document.createElement('a');
          a.href     = url;
          a.download = UTF8ToString($2);
          document.body.appendChild(a);
          a.click();
          document.body.removeChild(a);
          URL.revokeObjectURL(url);
          Module.ccall('on_save_file_selected', null, ['string'], [UTF8ToString($2)]);
        }
        catch (e)
        {
          var msg = (e && e.message) ? e.message : String(e);
          Module.ccall('on_save_file_failed', null, ['string'], [msg]);
        }
      },
      ezy_bytes.data(), ezy_bytes.size(), default_file.c_str());
}
void GUI::note_saved_project_filename(const std::string& filename)
{
  if (!filename.empty())
    m_last_saved_path = filename;
}
void GUI::download_blob_async(const std::string& default_filename, const std::string& data)
{
  EM_ASM_ARGS(
      {
        var blob = new Blob([HEAPU8.subarray($0, $0 + $1)],
                            {
                              type:
                                'application/octet-stream'
                            });
        var url    = URL.createObjectURL(blob);
        var a      = document.createElement('a');
        a.href     = url;
        a.download = UTF8ToString($2);
        document.body.appendChild(a);
        a.click();
        document.body.removeChild(a);
        URL.revokeObjectURL(url);
      },
      data.data(), data.size(), default_filename.c_str());
}
// C-style callback for Emscripten
extern "C" void on_file_selected(const char* file_path, char* contents, int length)
{
  const std::string file_bytes(contents, static_cast<size_t>(length));
  GUI::instance().on_file(file_path, file_bytes);
}
extern "C" void on_import_file_selected(const char* file_path, char* contents, int length)
{
  const std::string file_bytes(contents, static_cast<size_t>(length));
  GUI::instance().on_import_file(file_path, file_bytes);
}
extern "C" void on_inspector_file_selected(const char* file_path, char* contents, int length)
{
  const std::string file_bytes(contents, static_cast<size_t>(length));
  GUI::instance().on_inspector_file(file_path, file_bytes);
}
extern "C" void on_sketch_underlay_selected(const char* file_path, char* contents, int length)
{
  const std::string file_bytes(contents, static_cast<size_t>(length));
  GUI::instance().on_sketch_underlay_file(file_path, file_bytes);
}
extern "C" void on_save_file_selected(const char* file_name)
{
  GUI& g = GUI::instance();
  if (file_name)
    g.note_saved_project_filename(file_name);

  g.show_message(std::string("Saved: ") + (file_name ? file_name : ""));
}
extern "C" void on_save_file_failed(const char* reason)
{
  // Browser UIs often also report that the download / save did not complete; this ImGui
  // modal is our in-app explanation and does not replace that browser message.
  std::ostringstream msg;
  msg << "Could not download the project file.\n\n";
  if (reason && reason[0] != '\0')
    msg << "Browser error: " << reason << "\n\n";
  msg << "Check that downloads are allowed in this browser, then try File -> Save again.";
  GUI::instance().show_error_dialog("Save failed", msg.str());
}
#endif