install.py

#!/usr/bin/env python3
"""Filanex filament profile installer for Bambu Studio.

Run from the unzipped bundle directory (alongside additions.json and
BBL/filament/).

Strictly additive design with first-class upgrade and uninstall support.
A tracking file at `system/.polymaker-install.json` records exactly which
files and BBL.json entries this installer owns, along with SHA-256 hashes
of each installed file. That ownership record is what makes upgrade
(replace ours, leave the rest) and uninstall (remove ours, leave the
rest) possible without ever touching anything that wasn't ours to touch.

Subcommands:
    install     Fresh install if not previously installed; upgrade if a
                tracking file is present. Default if no subcommand given.
    upgrade     Same as install but errors if no previous install detected.
    uninstall   Remove every file and BBL.json entry recorded as ours.
                Files modified since install (hash mismatch) are kept by
                default; pass --force to delete anyway.
    status      Print current install state and exit. Read-only.

What every run does, regardless of subcommand:
    1. Locates your Bambu Studio user-data system/ folder (per OS).
    2. Detects whether Bambu Studio is running; asks you to close it.
    3. Sanity-checks the target looks like a real Bambu Studio install.
    4. Backs up the current BBL.json + BBL/filament/ to a timestamped
       folder under system/ (skip with --no-backup).

Requires Python 3.9+. No external packages.
"""
from __future__ import annotations

import argparse
import datetime as dt
import hashlib
import json
import os
import platform
import shutil
import subprocess
import sys
import time
from pathlib import Path

# When run as a PyInstaller .exe, __file__ points at PyInstaller's
# temporary extraction dir (sys._MEIPASS), not where the user put the
# .exe. We need the latter -- the bundle's additions.json + BBL/filament/
# live next to the .exe, not next to the bootloader's unpack dir.
if getattr(sys, "frozen", False):
    HERE = Path(sys.executable).resolve().parent
else:
    HERE = Path(__file__).resolve().parent

TRACKING_FILENAME = ".polymaker-install.json"
TRACKING_TOOL = "polymaker-installer/1"

# Installer-binary version. Bumped when the installer .exe itself
# changes (new wizard pages, new install logic, bug fixes). Independent
# of the database version (which lives in VERSION at the repo root and
# bumps when chemistry changes). The wizard fetches additions.json from
# DISTRIBUTION_BASE_URL on startup and compares its `installer_version`
# field to this constant; if remote is newer, it offers a self-update.
# bundle_bbl_inject.py parses this constant out of install.py and stamps
# it into the additions.json it ships, so they always match per release.
INSTALLER_VERSION = "1.2.4"

# Stable URL for the `update` subcommand. Points at the BBL-injection
# bundle on the project's default branch via GitHub raw. Override with
# the POLYMAKER_DISTRIBUTION_URL env var (useful for local testing or
# a different hosting plan -- see question 4 in QUESTIONS_FOR_MIKE.md).
DISTRIBUTION_BASE_URL = os.environ.get(
    "POLYMAKER_DISTRIBUTION_URL",
    "https://raw.githubusercontent.com/Cstm3DBldr/Filanex"
    "/main/install",
)

SYSTEM_DIR_DEFAULTS: dict[str, Path | None] = {
    "Windows": (Path(os.environ["APPDATA"]) / "BambuStudio" / "system")
        if os.environ.get("APPDATA") else None,
    "Darwin":  Path.home() / "Library" / "Application Support" / "BambuStudio" / "system",
    "Linux":   Path.home() / ".config" / "BambuStudio" / "system",
}

# Where the installer remembers the user's last picker selection so a
# repeat run starts pre-checked the same way (instead of forcing the
# user to uncheck the same lines every single time). Lives OUTSIDE
# Bambu Studio's system/ folder on purpose: uninstall + reinstall
# should preserve the user's last picks.
PREFS_DIR_DEFAULTS: dict[str, Path | None] = {
    "Windows": (Path(os.environ["APPDATA"]) / "PolymakerInstaller")
        if os.environ.get("APPDATA") else None,
    "Darwin":  Path.home() / "Library" / "Application Support" / "PolymakerInstaller",
    "Linux":   Path.home() / ".config" / "polymaker-installer",
}
PREFS_FILENAME = "picker-prefs.json"

PROCESS_NAMES = {
    "Windows": ["bambu-studio.exe", "BambuStudio.exe", "Bambu Studio.exe"],
    "Darwin":  ["BambuStudio", "Bambu Studio"],
    "Linux":   ["bambu-studio", "BambuStudio"],
}


# ---------------------------------------------------------------------------
# Output helpers
# ---------------------------------------------------------------------------

def banner(msg: str) -> None:
    line = "=" * max(len(msg), 60)
    print(f"\n{line}\n{msg}\n{line}\n")


def section(msg: str) -> None:
    print(f"\n--- {msg} ---")


# Throttle so a 16k-file install doesn't generate 16k stdout lines.
# Tighter than 50 -- want visible bar motion even when files are tiny
# JSONs that copy in <1ms each. 16k / 25 = 640 markers across an
# install, ~2 per Tk paint frame at 100ms polls. Visible motion.
_PROGRESS_EVERY_N = 25


def _emit_progress(verb: str, current: int, total: int) -> None:
    """Emit a structured progress marker. The wizard parses these out
    of stdout to drive a determinate progress bar; CLI users just see
    them in the log. Throttled to roughly every _PROGRESS_EVERY_N
    items + always on the final tick so the bar always reaches 100%.
    """
    if total <= 0:
        return
    if current == total or current % _PROGRESS_EVERY_N == 0 or current == 1:
        print(f"[PROGRESS {verb}] {current}/{total}", flush=True)


def _emit_phase(label: str) -> None:
    """Emit a phase-change marker. Non-counted phases (loading the
    bundle, filtering selection, writing BBL.json, updating the
    slicer's enable list) still take perceptible time but have no
    natural per-item progress. This marker lets the wizard at least
    update the label so the user sees motion through each step.

    Encoded as a degenerate [PROGRESS] marker with 0/0 so the GUI
    parser recognizes it via the same regex but treats total=0 as
    "label-only update, don't touch the bar percentage".
    """
    print(f"[PROGRESS {label}] 0/0", flush=True)


# ---------------------------------------------------------------------------
# Hashing + JSON IO
# ---------------------------------------------------------------------------

def file_sha256(p: Path) -> str:
    h = hashlib.sha256()
    with open(p, "rb") as f:
        for chunk in iter(lambda: f.read(8192), b""):
            h.update(chunk)
    return h.hexdigest()


def atomic_write_json(path: Path, data: object) -> None:
    """Write JSON via temp file + os.replace so a crash mid-write can't
    leave the target half-written."""
    tmp = path.with_suffix(path.suffix + ".tmp")
    tmp.write_text(json.dumps(data, indent=4) + "\n", encoding="utf-8")
    os.replace(tmp, path)


# ---------------------------------------------------------------------------
# Environment detection
# ---------------------------------------------------------------------------

def detect_system_dir(override: Path | None) -> Path:
    if override is not None:
        return override.expanduser().resolve()
    osname = platform.system()
    p = SYSTEM_DIR_DEFAULTS.get(osname)
    if p is None:
        sys.exit(f"Unsupported OS: {osname}. Pass --system-dir to override.")
    return p


def detect_user_printers(system_dir: Path) -> set[str]:
    """Detect which Bambu printers the user has configured / actively
    uses in Bambu Studio. Returns a set of canonical printer names like
    {"H2C", "X1 Carbon", "A1 mini"} -- empty set if detection fails or
    the user has no clear printer preference.

    Three signals, in order of authority:
      1. BambuStudio.conf field `user_last_selected_machine` -- the
         printer the user most recently picked in the slicer UI.
      2. BambuStudio.conf field `machine` -- the printer in the active
         project.
      3. Existing filament profiles in <system_dir>/BBL/filament/ that
         reference specific printers in their compatible_printers list.

    The detection feeds the install pipeline's printer filter -- if the
    user has only an H2C, we won't install filament leaves whose
    compatible_printers is exclusively for other printers (eliminating
    the "Unsupported" flood in the slicer's filament dropdown).

    Returns an empty set if we can't make a confident determination;
    the caller should treat that as "install for all printers" (current
    behavior pre-filter).
    """
    found: set[str] = set()
    # system_dir is typically <appdata>/BambuStudio/system; the conf
    # lives one level up.
    conf_path = system_dir.parent / "BambuStudio.conf"
    if conf_path.exists():
        try:
            text = conf_path.read_text(encoding="utf-8", errors="ignore")
        except Exception:
            text = ""
        # Parse simple JSON-style "key": "value" pairs we care about.
        # The conf is a JSON object but we only need a couple of fields,
        # so regex-grep is more resilient to malformed input than full
        # json.loads.
        import re as _re
        for key in ("user_last_selected_machine", "machine"):
            m = _re.search(rf'"{key}"\s*:\s*"([^"]+)"', text)
            if m:
                # Value might be a machine GUID (printer-side internal
                # ID) or a human name like "Bambu Lab H2C 0.4 nozzle".
                # We only care about the human names.
                val = m.group(1).strip()
                if val.startswith("Bambu Lab "):
                    # Strip "Bambu Lab " prefix and " <nozzle> nozzle" suffix
                    # to get the canonical printer name (e.g. "H2C", "X1 Carbon").
                    body = val[len("Bambu Lab "):].strip()
                    body = _re.sub(r"\s+\d\.\d nozzle$", "", body).strip()
                    if body:
                        found.add(body)
    # Also harvest any printer names referenced in filament-list-additions
    # tracking file (printers the user has installed Filanex profiles for).
    # This handles the multi-printer case where the user added profiles
    # for several printers across past install runs.
    tracking = system_dir / TRACKING_FILENAME
    if tracking.exists():
        try:
            t = json.loads(tracking.read_text(encoding="utf-8"))
            for entry in t.get("entries", []):
                name = entry.get("name", "")
                # Names look like "<line> @Bambu Lab <printer> <nozzle> nozzle"
                # or "<line> @BBL <short> <nozzle> nozzle".
                import re as _re
                m = _re.search(r"@Bambu Lab (.+?) \d\.\d nozzle$", name)
                if m:
                    found.add(m.group(1).strip())
                else:
                    m = _re.search(r"@BBL ([A-Za-z0-9]+) \d\.\d nozzle$", name)
                    if m:
                        # Short name -> canonical (e.g. X1C -> "X1 Carbon",
                        # H2DP -> "H2D Pro"). Hardcoded a few common
                        # abbreviations; unknowns get passed through.
                        short = m.group(1)
                        canonical = {
                            "X1C": "X1 Carbon",
                            "H2DP": "H2D Pro",
                            "A1M": "A1 mini",
                        }.get(short, short)
                        found.add(canonical)
        except Exception:
            pass
    return found


def printer_matches_entry(entry_name: str, allowed_printers: set[str]) -> bool:
    """Return True if entry_name's printer (parsed from "@Bambu Lab X"
    or "@BBL X" suffix) is in allowed_printers, OR the entry is a @base
    (no printer-specific binding) OR allowed_printers is empty (filter
    disabled).

    Handles both naming conventions:
      "Polymaker PA12-CF @BBL H2C 0.4 nozzle"        -> printer="H2C"
      "Fiberon PA12-CF10 @Bambu Lab H2C 0.4 nozzle"  -> printer="H2C"
    """
    if not allowed_printers:
        return True  # filter disabled
    if " @base" in entry_name:
        return True  # @base files always kept; leaves anchor them
    import re as _re
    # "@Bambu Lab <printer> <nozzle> nozzle"
    m = _re.search(r"@Bambu Lab (.+?) \d\.\d nozzle$", entry_name)
    if m:
        return m.group(1).strip() in allowed_printers
    # "@BBL <short> <nozzle> nozzle"
    m = _re.search(r"@BBL ([A-Za-z0-9]+) \d\.\d nozzle$", entry_name)
    if m:
        short = m.group(1)
        canonical = {
            "X1C": "X1 Carbon",
            "H2DP": "H2D Pro",
            "A1M": "A1 mini",
        }.get(short, short)
        return canonical in allowed_printers or short in allowed_printers
    return True  # unparseable -- keep to be safe


def find_bambu_process() -> tuple[bool, Path | None]:
    osname = platform.system()
    names = PROCESS_NAMES.get(osname, [])

    # On Windows, every subprocess.run from a --windowed (no-console)
    # PyInstaller .exe pops a brief cmd window. With this code being
    # called repeatedly from the wizard's preflight step (3+ subprocesses
    # per check, often called twice in a row), the screen flashes hard
    # enough to be a real photosensitive-epilepsy hazard. CREATE_NO_WINDOW
    # (0x08000000) suppresses the console window for the spawned
    # subprocess.
    nw_flags = 0x08000000 if osname == "Windows" else 0

    if osname == "Windows":
        for name in names:
            base = name.removesuffix(".exe")
            ps = (
                f"(Get-Process -Name '{base}' -ErrorAction SilentlyContinue | "
                f"Select-Object -First 1).Path"
            )
            r = subprocess.run(
                ["powershell", "-NoProfile", "-Command", ps],
                capture_output=True, text=True,
                creationflags=nw_flags,
            )
            path = r.stdout.strip()
            if path:
                return True, Path(path)
            r = subprocess.run(
                ["tasklist", "/FI", f"IMAGENAME eq {name}", "/NH"],
                capture_output=True, text=True,
                creationflags=nw_flags,
            )
            if name.lower() in r.stdout.lower():
                return True, None
        return False, None

    if osname == "Darwin":
        for name in names:
            r = subprocess.run(
                ["pgrep", "-x", name], capture_output=True, text=True,
            )
            if r.returncode == 0:
                return True, None
        return False, None

    if osname == "Linux":
        for name in names:
            r = subprocess.run(
                ["pgrep", "-x", name], capture_output=True, text=True,
            )
            if r.returncode == 0:
                pid = r.stdout.strip().splitlines()[0]
                exe = Path(f"/proc/{pid}/exe")
                if exe.exists():
                    try:
                        return True, exe.resolve()
                    except OSError:
                        return True, None
                return True, None
        return False, None

    return False, None


def find_bambu_install_path() -> Path | None:
    """Locate Bambu Studio's executable WITHOUT requiring it to be
    running. Used so the wizard's Re-launch Bambu Studio button works
    even when Bambu wasn't already open at install time (the normal
    flow: user closes Bambu, runs installer, expects to launch it
    after).

    Returns None if no install can be located -- caller should hide
    the button or message the user to launch Bambu manually.
    """
    osname = platform.system()
    if osname == "Windows":
        candidates: list[Path] = []
        # Standard Program Files installs
        for pf in (
            os.environ.get("ProgramFiles"),
            os.environ.get("ProgramFiles(x86)"),
            os.environ.get("LOCALAPPDATA"),
        ):
            if not pf:
                continue
            base = Path(pf)
            for subdir in (
                base / "Bambu Studio" / "bambu-studio.exe",
                base / "BambuStudio" / "bambu-studio.exe",
                base / "Programs" / "Bambu Studio" / "bambu-studio.exe",
                base / "Programs" / "BambuStudio" / "bambu-studio.exe",
            ):
                candidates.append(subdir)
        # Windows registry: HKLM Uninstall key for any "Bambu Studio"
        # entry's InstallLocation. PowerShell because the stdlib's
        # winreg requires extra plumbing we don't need here.
        try:
            ps = (
                "Get-ItemProperty 'HKLM:\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\*', "
                "'HKLM:\\SOFTWARE\\WOW6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\*' "
                "-ErrorAction SilentlyContinue | "
                "Where-Object { $_.DisplayName -like '*Bambu Studio*' } | "
                "Select-Object -ExpandProperty InstallLocation -First 1"
            )
            r = subprocess.run(
                ["powershell", "-NoProfile", "-Command", ps],
                capture_output=True, text=True, timeout=5,
                creationflags=0x08000000,
            )
            loc = r.stdout.strip()
            if loc:
                candidates.append(Path(loc) / "bambu-studio.exe")
        except Exception:
            pass
        for c in candidates:
            try:
                if c.is_file():
                    return c.resolve()
            except OSError:
                continue
        return None
    if osname == "Darwin":
        for p in (
            Path("/Applications/BambuStudio.app/Contents/MacOS/BambuStudio"),
            Path("/Applications/Bambu Studio.app/Contents/MacOS/Bambu Studio"),
        ):
            if p.is_file():
                return p
        return None
    # Linux: best-effort, common install locations + which()
    if osname == "Linux":
        for name in ("bambu-studio", "BambuStudio"):
            r = subprocess.run(["which", name], capture_output=True, text=True)
            if r.returncode == 0 and r.stdout.strip():
                return Path(r.stdout.strip())
        for p in (
            Path("/usr/bin/bambu-studio"),
            Path("/usr/local/bin/bambu-studio"),
            Path("/opt/BambuStudio/bambu-studio"),
        ):
            if p.is_file():
                return p
    return None


def wait_for_close() -> None:
    while True:
        input("Press Enter once Bambu Studio is fully closed... ")
        time.sleep(1)
        running, _ = find_bambu_process()
        if not running:
            print("Confirmed closed.")
            return
        print("Bambu Studio still appears to be running. Close it and try again.")


# ---------------------------------------------------------------------------
# Sanity checks
# ---------------------------------------------------------------------------

def sanity_check_target(system_dir: Path) -> None:
    if not system_dir.exists():
        sys.exit(
            f"\nERROR: System folder doesn't exist:\n  {system_dir}\n"
            f"\nHas Bambu Studio been launched at least once on this account?"
        )
    if not system_dir.is_dir():
        sys.exit(f"\nERROR: Not a directory: {system_dir}")
    bbl_json = system_dir / "BBL.json"
    bbl_dir = system_dir / "BBL"
    if not bbl_json.exists() or not bbl_dir.is_dir():
        sys.exit(
            f"\nERROR: {system_dir} doesn't look like a Bambu Studio system\n"
            f"folder. Expected to find BBL.json and a BBL/ folder inside."
        )


def sanity_check_source(need_bundle: bool) -> tuple[Path | None, Path | None]:
    """Returns (additions_path, filament_dir). Both None if uninstall mode
    and bundle isn't needed."""
    if not need_bundle:
        return None, None
    src_additions = HERE / "additions.json"
    src_filament_dir = HERE / "BBL" / "filament"
    if not src_additions.exists():
        sys.exit(
            f"ERROR: Bundle is missing additions.json. Expected at:\n"
            f"  {src_additions}\n"
            f"Run this from inside the unzipped bundle directory."
        )
    if not src_filament_dir.is_dir():
        sys.exit(
            f"ERROR: Bundle is missing BBL/filament/. Expected at:\n"
            f"  {src_filament_dir}"
        )
    return src_additions, src_filament_dir


# ---------------------------------------------------------------------------
# Backup
# ---------------------------------------------------------------------------

# Number of timestamped _backup-* folders kept in system/. Older ones
# get pruned automatically after each new backup so they don't pile up.
BACKUP_RETENTION = 5


def back_up(system_dir: Path) -> Path:
    ts = dt.datetime.now().strftime("%Y%m%d-%H%M%S")
    backup_dir = system_dir / f"_backup-{ts}"
    backup_dir.mkdir()
    bbl_json = system_dir / "BBL.json"
    if bbl_json.exists():
        shutil.copy2(bbl_json, backup_dir / "BBL.json")
    filament_dir = system_dir / "BBL" / "filament"
    if filament_dir.exists():
        # Instrumented per-file copy instead of shutil.copytree so we
        # can emit progress markers. With 16k existing profile JSONs
        # this loop is the BIGGEST silent freeze in an install --
        # without progress here the bar appears stuck before the
        # main file-write loop even starts.
        dst_filament = backup_dir / "BBL" / "filament"
        dst_filament.mkdir(parents=True)
        all_files = [p for p in filament_dir.rglob("*") if p.is_file()]
        total = len(all_files)
        for i, src in enumerate(all_files, 1):
            rel = src.relative_to(filament_dir)
            dst = dst_filament / rel
            dst.parent.mkdir(parents=True, exist_ok=True)
            shutil.copy2(src, dst)
            _emit_progress("Backing up existing", i, total)
    tracking = system_dir / TRACKING_FILENAME
    if tracking.exists():
        shutil.copy2(tracking, backup_dir / TRACKING_FILENAME)
    _prune_old_backups(system_dir)
    return backup_dir


def _prune_old_backups(system_dir: Path, keep: int = BACKUP_RETENTION) -> None:
    """Keep the newest `keep` _backup-* folders; delete older ones.
    The folder name's YYYYMMDD-HHMMSS timestamp sorts lexicographically
    the same as chronologically, so a string sort is enough."""
    backups = sorted(
        (p for p in system_dir.iterdir()
         if p.is_dir() and p.name.startswith("_backup-")),
        key=lambda p: p.name,
        reverse=True,
    )
    pruned = 0
    for old in backups[keep:]:
        try:
            shutil.rmtree(old)
            pruned += 1
        except OSError as e:
            print(f"  WARN: couldn't remove old backup {old.name}: {e}")
    if pruned:
        print(f"  Pruned {pruned} old backup(s); keeping the newest "
              f"{min(len(backups), keep)}.")


# Vendors whose Bambu-Studio-shipped legacy subfolder files we sweep
# during install. Bambu Studio's filament folder contains both:
#   - Top-level files: <line> @Bambu Lab <printer> <nozzle> nozzle.json
#     (new naming, what we overlay)
#   - Vendor subfolders: BBL/filament/<vendor>/<line> @BBL <short>.json
#     (Bambu's older naming, predates the @Bambu Lab convention)
#
# The subfolder legacy files persist in user installs and pollute the
# slicer's dropdown with "Unsupported" entries on printers they
# weren't tested for (typically X1C and H2D only -- so on H2C they all
# appear unsupported). We disable them by renaming .json -> .filanex-
# disabled (rather than deleting outright) so the user can restore
# manually if Bambu's profile-sync re-adds them or if needed for
# debugging.
LEGACY_SUBFOLDER_VENDORS = {"Polymaker"}


def disable_bambu_legacy_subfolders(system_dir: Path) -> int:
    """Walk BBL/filament/<vendor>/ for vendors in LEGACY_SUBFOLDER_VENDORS
    and rename every *.json -> *.filanex-disabled. Bambu Studio's
    profile loader only loads .json files so the renamed ones become
    invisible. Returns the count of files disabled."""
    filament_dir = system_dir / "BBL" / "filament"
    if not filament_dir.exists():
        return 0
    disabled = 0
    for vendor in LEGACY_SUBFOLDER_VENDORS:
        vdir = filament_dir / vendor
        if not vdir.is_dir():
            continue
        for f in vdir.iterdir():
            if not f.is_file() or f.suffix != ".json":
                continue
            new_path = f.with_suffix(".filanex-disabled")
            try:
                f.rename(new_path)
                disabled += 1
            except OSError as e:
                print(f"  WARN: couldn't disable legacy {f.name}: {e}")
    return disabled


# Top-level Bambu stock Polymaker files we DON'T overlay (different
# printer/nozzle combos or SKUs we don't have) get renamed to
# .filanex-bambu-backup at install time. This eliminates all setting_id
# collision risk in Bambu Studio's GFSL-prefix namespace: with all
# Bambu stock Polymaker files disabled, the only profiles in that
# namespace are ours, so the slicer can't accidentally hide our leaves
# via dedupe-by-setting_id.
#
# Restoration: rename .filanex-bambu-backup -> .json (manual or on
# uninstall).
BACKUP_EXT = ".filanex-bambu-backup"


# Polymaker brand prefixes used to detect Bambu's stock Polymaker files
# by filename (Bambu's stock LEAVES often have filament_vendor=None
# because it's set only at @base level; matching the @base/leaf chain
# is fragile, so we match by filename brand prefix instead, which
# Bambu has been consistent about).
POLYMAKER_BRAND_PREFIXES = (
    "PolyLite ", "PolyTerra ", "Polymaker ", "Panchroma ", "Fiberon ",
    "PolyFlex ", "PolyMax ", "PolyMide ", "PolySmooth", "PolySupport",
    "PolyCast", "PolyDissolve", "PolySonic ", "PolyWood",
)


# Vendor -> brand prefixes for the full Bambu-stock wipe. When the
# user ticks a vendor in the picker, every Bambu stock file matching
# one of that vendor's brand prefixes (root + subfolder, @base + leaf)
# gets renamed to .json.filanex-bambu-backup. Bambu's stock disappears
# from the picker; only our overlay remains. Uninstall reverses every
# backup.
#
# Vendor key here MUST match the vendor field in our bundle entries
# (the same field the picker uses to track selection). Brand prefixes
# match how Bambu names their files -- different sub-brands like
# PolyLite and PolyTerra both live under the "Polymaker" picker vendor.
VENDOR_TO_BAMBU_BRAND_PREFIXES: dict[str, tuple[str, ...]] = {
    "Polymaker": POLYMAKER_BRAND_PREFIXES,
    "Overture": ("Overture ",),
    "SUNLU": ("SUNLU ",),
    "eSUN": ("eSUN ",),
}


def restore_disabled_bambu_legacy_subfolders(system_dir: Path) -> int:
    """Reverse disable_bambu_legacy_subfolders by renaming
    .filanex-disabled files back to .json in BBL/filament/<vendor>/
    subfolders. Used on uninstall to leave Bambu's stock state intact.
    Returns count restored."""
    filament_dir = system_dir / "BBL" / "filament"
    if not filament_dir.exists():
        return 0
    restored = 0
    for vendor in LEGACY_SUBFOLDER_VENDORS:
        vdir = filament_dir / vendor
        if not vdir.is_dir():
            continue
        for f in vdir.iterdir():
            if not f.is_file() or f.suffix != ".filanex-disabled":
                continue
            target = f.with_suffix(".json")
            if target.exists():
                # Original already exists (e.g. Bambu's profile-sync
                # re-downloaded); delete the disabled copy to avoid
                # duplicate confusion.
                try:
                    f.unlink()
                except OSError:
                    pass
                continue
            try:
                f.rename(target)
                restored += 1
            except OSError as e:
                print(f"  WARN: couldn't restore legacy {f.name}: {e}")
    return restored


def backup_bambu_stock_for_picked_vendors(
    filament_dir: Path,
    our_filenames: set[str],
    picked_vendors: set[str],
) -> tuple[int, int]:
    """Wholesale Bambu-stock removal for every vendor the user ticked
    in the picker. Scans BBL/filament/ (root AND every subfolder) for
    .json files matching one of the brand prefixes mapped to the
    picked vendors, renaming each to .json.filanex-bambu-backup.

    Why: Bambu's stock files for vendors we overlay (Polymaker,
    Overture, SUNLU, eSUN) ship aimed at specific printers (mostly
    H2D / X1C / X1E / H2D Pro / H2S). They show up as "Unsupported"
    entries in the picker for any printer the file's
    compatible_printers list doesn't include. Our overlay covers
    every printer comprehensively, so leaving Bambu's stock in place
    just creates Unsupported noise. User explicitly asked: "the
    installer should look for the stock installed files remove them
    and install our own."

    Granularity: VENDOR-level. Tick Polymaker -> back up every
    PolyLite / PolyTerra / Fiberon / Panchroma / Polymaker* /
    PolyMax / PolyMide / etc. file. Don't tick Polymaker -> Bambu's
    stock stays in place untouched (you keep their broken-on-H2C
    files, you fix it yourself via Bambu Studio).

    Skip rules:
    - Files OUR overlay writes at the same filename get overwritten
      during the file-write step -- no backup needed.
    - Files in folders starting with "_" (system reserved).
    - Subfolders are walked too, since Bambu ships some legacy
      Polymaker files under BBL/filament/Polymaker/.

    Restoration: restore_all_bambu_polymaker_backups (walks the
    same dirs looking for .filanex-bambu-backup) renames them all
    back to .json on uninstall.

    Returns (backed_up_count, vendors_skipped_no_pick)."""
    if not filament_dir.exists():
        return (0, 0)

    # Build the set of brand prefixes we should target this run
    # based on which vendors the user picked. If the user picked
    # nothing relevant (e.g. only Anycubic, which Bambu doesn't
    # ship), the prefix set is empty and we do nothing.
    target_prefixes: list[str] = []
    vendors_in_play = 0
    for vendor, prefixes in VENDOR_TO_BAMBU_BRAND_PREFIXES.items():
        if vendor in picked_vendors:
            vendors_in_play += 1
            target_prefixes.extend(prefixes)
    if not target_prefixes:
        return (0, len(VENDOR_TO_BAMBU_BRAND_PREFIXES) - vendors_in_play)

    def _walk_target_files():
        # Root .json files
        for f in filament_dir.iterdir():
            if f.is_file() and f.suffix == ".json":
                yield f
        # Subfolder .json files (Bambu's Polymaker/ legacy folder, etc.)
        for sub in filament_dir.iterdir():
            if not sub.is_dir():
                continue
            if sub.name.startswith("_"):
                continue
            for f in sub.iterdir():
                if f.is_file() and f.suffix == ".json":
                    yield f

    # Pass 1: classify every .json. A file is a REMOVAL CANDIDATE if it
    # matches a picked-vendor prefix AND is Bambu's own (from != "User").
    # Everything else is a KEEPER: our previously-written profiles
    # (from=="User", refreshed by the write step -> idempotent re-runs),
    # and any non-picked-vendor Bambu file. We also record the `inherits`
    # targets keepers still depend on, to guard against orphaning them.
    candidates: list[tuple[Path, str]] = []   # (path, profile "name")
    kept_inherits: set[str] = set()
    for f in _walk_target_files():
        name = f.name
        try:
            d = json.loads(f.read_text(encoding="utf-8"))
        except Exception:
            d = {}
        is_target = any(name.startswith(p) for p in target_prefixes)
        if is_target and d.get("from") != "User":
            candidates.append((f, d.get("name") or name[:-5]))
        else:
            inh = d.get("inherits")
            if inh:
                kept_inherits.add(inh)

    # Pass 2: back up + remove the whole Bambu chain (@base, mid-level
    # parents, and leaves) for picked vendors. Renaming to
    # .filanex-bambu-backup both removes it from Bambu's active set AND
    # preserves the exact bytes for Uninstall to restore. Our flat leaves
    # (inherits=None) don't depend on the @base, so removing the whole
    # chain leaves nothing to orphan -- unlike the old leaf-only sweep
    # that preserved @base and left the "both intact" clutter behind.
    backed_up = 0
    for f, prof_name in candidates:
        # Inheritance guard (belt-and-suspenders vs the #22/#23 breakage):
        # never remove a file another RETAINED profile still inherits from.
        # Only trips on rare cross-brand inheritance; a fully-replaced line
        # has no external inheritors once its leaves are gone.
        if prof_name in kept_inherits:
            print(f"  KEEP (still inherited by a retained profile): {f.name}")
            continue
        new_path = f.parent / (f.name + BACKUP_EXT)
        if new_path.exists():
            # Prior-run backup already preserves the original; this
            # current .json is a fresh re-download from Bambu's CDN.
            # Delete the redundant copy.
            try:
                f.unlink()
                backed_up += 1
            except OSError as e:
                print(f"  WARN: couldn't remove duplicate Bambu stock {f.name}: {e}")
            continue
        try:
            f.rename(new_path)
            backed_up += 1
        except OSError as e:
            print(f"  WARN: couldn't back up Bambu stock {f.name}: {e}")
    return (backed_up, len(VENDOR_TO_BAMBU_BRAND_PREFIXES) - vendors_in_play)


def cleanup_user_folder_polymaker_copies(system_dir: Path) -> int:
    """Scan user/<id>/filament/ for Bambu Studio auto-copy files
    (* - Copy.json / * - Copy.info) whose base name matches one of our
    Polymaker brand prefixes. Move them to a timestamped backup folder
    under user/<id>/_filanex-userfile-backup-<timestamp>/.

    Why: Bambu Studio creates "<name> - Copy" auto-saves when the user
    clicks Edit/Save-As on a stock profile. These accumulate over
    install/uninstall cycles and show up as Unsupported entries
    (compatible_printers is often empty on auto-copies). The user has
    no use for these; they were created accidentally during prior
    install testing.

    Backup-then-move is reversible: the timestamped folder lets the
    user restore manually if they discover a copy they actually wanted.

    Returns count moved."""
    # system_dir is .../BambuStudio/system; user folder is sibling
    user_root = system_dir.parent / "user"
    if not user_root.exists():
        return 0
    moved = 0
    timestamp = dt.datetime.now().strftime("%Y%m%d-%H%M%S")
    for user_id_dir in user_root.iterdir():
        if not user_id_dir.is_dir():
            continue
        filament_dir = user_id_dir / "filament"
        if not filament_dir.is_dir():
            continue
        backup_dir = None  # lazy create per user-id
        for f in filament_dir.iterdir():
            if not f.is_file():
                continue
            if f.suffix not in (".json", ".info"):
                continue
            name = f.name
            # Bambu Studio's auto-copy filename pattern
            if " - Copy" not in name:
                continue
            stem = f.stem
            if not any(stem.startswith(p) for p in POLYMAKER_BRAND_PREFIXES):
                continue
            if backup_dir is None:
                backup_dir = (
                    user_id_dir / f"_filanex-userfile-backup-{timestamp}"
                )
                try:
                    backup_dir.mkdir(exist_ok=True)
                except OSError as e:
                    print(f"  WARN: couldn't create backup dir {backup_dir}: {e}")
                    backup_dir = None
                    continue
            try:
                shutil.move(str(f), str(backup_dir / name))
                moved += 1
            except OSError as e:
                print(f"  WARN: couldn't move user copy {f.name}: {e}")
    return moved


def cleanup_user_base_synced_files(
    system_dir: Path, picked_vendors: set[str],
) -> int:
    """Back up cloud-synced Bambu user-base filament files in
    user/<id>/filament/base/ that match picked vendor brand prefixes.

    Why this exists (the long version):
      Bambu Studio syncs the user's Bambu Lab cloud filament library
      down into user/<id>/filament/base/. The contents are per-printer
      Bambu stock leaves (Fiberon ASA-CF08 @Bambu Lab H2D 0.4 nozzle
      etc.) with single-printer compatible_printers. When the user's
      current printer isn't covered by ANY of these (e.g. H2C user
      with cloud entries only for H2D/H2S/X1/X2D), the picker shows
      the lines under Unsupported.

      This was the actual root cause of the "5 persistent Fiberon
      entries in Unsupported" issue Mike chased for an hour -- the
      system/, Program Files/, and even our overlay were all clean,
      but this third location (which I'd never inspected) held the
      stock leaves causing the Unsupported display.

      sync_user_preset = false in Preferences should prevent the
      cloud pull, but past sync state still lingers in the folder.

    Returns count moved (counts .json + .info pairs separately).
    """
    user_root = system_dir.parent / "user"
    if not user_root.exists():
        return 0

    # Compute target prefixes from picked vendors
    target_prefixes: list[str] = []
    for vendor, prefixes in VENDOR_TO_BAMBU_BRAND_PREFIXES.items():
        if vendor in picked_vendors:
            target_prefixes.extend(prefixes)
    if not target_prefixes:
        return 0

    moved = 0
    timestamp = dt.datetime.now().strftime("%Y%m%d-%H%M%S")
    for user_id_dir in user_root.iterdir():
        if not user_id_dir.is_dir():
            continue
        base_dir = user_id_dir / "filament" / "base"
        if not base_dir.is_dir():
            continue
        backup_dir = None
        for f in base_dir.iterdir():
            if not f.is_file():
                continue
            if f.suffix not in (".json", ".info"):
                continue
            name = f.name
            if not any(name.startswith(p) for p in target_prefixes):
                continue
            if backup_dir is None:
                backup_dir = (
                    user_id_dir / f"_filanex-userbase-backup-{timestamp}"
                )
                try:
                    backup_dir.mkdir(exist_ok=True)
                except OSError as e:
                    print(f"  WARN: couldn't create backup dir {backup_dir}: {e}")
                    backup_dir = None
                    continue
            try:
                shutil.move(str(f), str(backup_dir / name))
                moved += 1
            except OSError as e:
                print(f"  WARN: couldn't move user base file {f.name}: {e}")
    return moved


def deep_wipe_bambu_install_resources(picked_vendors: set[str]) -> tuple[int, bool]:
    """Back up files in Bambu Studio's bundled resources folder
    (<Program Files>/Bambu Studio/resources/profiles/BBL/filament/)
    that match picked vendor brand prefixes.

    Why: Bambu Studio's install_bundles_rsrc() hardcodes
    "always update configs from resource to vendor for BBL", meaning
    every startup it copies bundled resources into system/. Wiping
    only system/ means Bambu re-installs the stock files on next
    launch. Wiping the SOURCE (Program Files) stops the re-extraction.

    Requirements:
      - Admin privileges (Program Files is protected). If we can't
        write, log a warning and skip -- not a fatal error.
      - Bambu Studio not running (file locks otherwise).

    Survives until Bambu Studio updates (a Bambu update overwrites
    Program Files). User must re-run install.exe as admin after each
    Bambu Studio update.

    Returns (count_backed_up, ran_with_admin).
    """
    bambu_resource = Path(
        r"C:\Program Files\Bambu Studio\resources\profiles\BBL\filament"
    )
    if not bambu_resource.exists():
        return (0, False)

    # Probe write access -- the cleanest test for admin
    probe = bambu_resource / ".filanex_write_probe"
    try:
        probe.touch()
        probe.unlink()
    except (PermissionError, OSError):
        return (0, False)

    # Compute target prefixes from picked vendors
    target_prefixes: list[str] = []
    for vendor, prefixes in VENDOR_TO_BAMBU_BRAND_PREFIXES.items():
        if vendor in picked_vendors:
            target_prefixes.extend(prefixes)
    if not target_prefixes:
        return (0, True)

    backed_up = 0
    for f in bambu_resource.iterdir():
        if not f.is_file() or f.suffix != ".json":
            continue
        name = f.name
        if not any(name.startswith(p) for p in target_prefixes):
            continue
        new_path = f.parent / (f.name + BACKUP_EXT)
        if new_path.exists():
            # Prior backup exists; current .json is from a Bambu update.
            try:
                f.unlink()
                backed_up += 1
            except OSError as e:
                print(f"  WARN: couldn't remove duplicate {name}: {e}")
            continue
        try:
            f.rename(new_path)
            backed_up += 1
        except OSError as e:
            print(f"  WARN: couldn't back up {name}: {e}")
    return (backed_up, True)


def restore_all_bambu_polymaker_backups(filament_dir: Path) -> int:
    """Restore ALL Bambu Polymaker .filanex-bambu-backup files by
    renaming back to .json. The disable-and-rename approach turned out
    to break Bambu's multi-level inheritance chains: even non-@base
    mid-level leaves (e.g. "PolyLite PLA @BBL X1C.json") are referenced
    via `inherits` by other Bambu profiles in subfolders (e.g.
    "P1P/PolyLite PLA @BBL P1P 0.2 nozzle.json" inherits from
    "PolyLite PLA @BBL X1C"). Disabling any of those breaks the
    inheritance chain and Bambu Studio throws "Failed loading
    configuration file" at startup.

    Whole-chain replace (current): the installer backs up Bambu's ENTIRE
    stock chain for picked vendors (@base + mid-level parents + leaves) so
    our profiles stand alone. This restore reverses that exactly -- every
    .filanex-bambu-backup renames back to .json, returning the slicer to
    its original state. cmd_uninstall deletes our tracked files BEFORE
    calling this, so the original names are free; the target.exists()
    branch below is a defensive overwrite (Bambu's original wins).

    Restoring is idempotent and safe. Returns count restored."""
    if not filament_dir.exists():
        return 0
    restored = 0

    def _walk_all_files():
        for f in filament_dir.iterdir():
            if f.is_file():
                yield f
        for sub in filament_dir.iterdir():
            if not sub.is_dir():
                continue
            if sub.name.startswith("_"):
                continue
            for f in sub.iterdir():
                if f.is_file():
                    yield f

    for f in _walk_all_files():
        if not f.name.endswith(".json" + BACKUP_EXT):
            continue
        original_name = f.name[: -len(BACKUP_EXT)]
        target = f.parent / original_name
        if target.exists():
            # A leftover (our overlay, normally already deleted by
            # uninstall) occupies the original name -- Bambu's original
            # takes precedence, so clear it and restore.
            try:
                target.unlink()
            except OSError:
                # Can't clear the leftover; drop the redundant backup so
                # we don't leave a stray .filanex-bambu-backup behind.
                try:
                    f.unlink()
                except OSError:
                    pass
                continue
        try:
            f.rename(target)
            restored += 1
        except OSError as e:
            print(f"  WARN: couldn't restore Bambu file {f.name}: {e}")
    return restored


# ---------------------------------------------------------------------------
# Tracking file
# ---------------------------------------------------------------------------

def tracking_path(system_dir: Path) -> Path:
    return system_dir / TRACKING_FILENAME


def load_tracking(system_dir: Path) -> dict | None:
    p = tracking_path(system_dir)
    if not p.exists():
        return None
    try:
        return json.loads(p.read_text(encoding="utf-8"))
    except json.JSONDecodeError:
        print(f"WARNING: Tracking file at {p} is not valid JSON. Treating as no install.")
        return None


def save_tracking(system_dir: Path, tracking: dict) -> None:
    atomic_write_json(tracking_path(system_dir), tracking)


def build_tracking(
    installed_files: list[dict],
    installed_entries: list[dict],
    database_version: str | None = None,
) -> dict:
    return {
        "tool": TRACKING_TOOL,
        "installed_at": dt.datetime.now(dt.timezone.utc).isoformat(timespec="seconds"),
        "bundle_database_version": database_version,
        "filament_files": installed_files,   # [{filename, sha256}]
        "filament_list_entries": installed_entries,  # [{name, sub_path}]
    }


# ---------------------------------------------------------------------------
# Picker preferences (remembered selection across runs)
# ---------------------------------------------------------------------------

def prefs_path() -> Path | None:
    """Per-user JSON file remembering the picker's last selection.
    Returns None on platforms we don't have a default for."""
    base = PREFS_DIR_DEFAULTS.get(platform.system())
    if base is None:
        return None
    return base / PREFS_FILENAME


def load_picker_prefs() -> dict | None:
    """Load remembered selection. Returns None if not present / invalid
    / on any error -- caller should fall back to its default state."""
    p = prefs_path()
    if p is None or not p.exists():
        return None
    try:
        return json.loads(p.read_text(encoding="utf-8"))
    except Exception:
        return None


def save_picker_prefs(prefs: dict) -> None:
    """Persist the picker's current selection. Best-effort: silently
    swallows errors so a permission glitch on the prefs dir can never
    break the install. Creates the parent dir on demand."""
    p = prefs_path()
    if p is None:
        return
    try:
        p.parent.mkdir(parents=True, exist_ok=True)
        atomic_write_json(p, prefs)
    except Exception as e:
        print(f"  (prefs save skipped: {e})")


# ---------------------------------------------------------------------------
# Bundle introspection
# ---------------------------------------------------------------------------

def load_bundle(src_additions: Path, src_filament_dir: Path) -> dict:
    """Returns {entries, files, database_version, _src_filament_dir}.

    `files` is a dict[filename -> sha256_or_None]. SHAs are computed
    LAZILY (set to None here) and filled in by hash_bundle_files()
    after selection filtering -- there's no point hashing 16k files
    when the user only picked 1.3k. _src_filament_dir is stashed so
    the later hash step knows where to read each file from."""
    _emit_phase("Reading bundle manifest")
    doc = json.loads(src_additions.read_text(encoding="utf-8"))
    entries = doc["filament_list_additions"]
    database_version = doc.get("database_version")
    # Enumerate filenames only -- defer hashing.
    files: dict[str, str | None] = {
        p.name: None
        for p in src_filament_dir.iterdir()
        if p.is_file()
    }
    return {
        "entries": entries,
        "files": files,
        "database_version": database_version,
        "_src_filament_dir": src_filament_dir,
    }


def hash_bundle_files(bundle: dict) -> None:
    """Populate sha256 for every file in bundle['files'] whose value
    is still None. Called after filter_bundle_by_selection so we
    only hash what the user actually picked."""
    src_dir: Path = bundle.get("_src_filament_dir")
    pending = [name for name, sha in bundle["files"].items() if sha is None]
    total = len(pending)
    if total == 0:
        return
    _emit_phase("Hashing selected bundle files")
    for i, name in enumerate(pending, 1):
        bundle["files"][name] = file_sha256(src_dir / name)
        _emit_progress("Hashing selected bundle files", i, total)


# ---------------------------------------------------------------------------
# Manifest manipulation
# ---------------------------------------------------------------------------

def manifest_add_entries(
    user_bbl: dict, entries_to_add: list[dict],
    our_prev_names: set[str] | None = None,
) -> tuple[list[dict], list[dict], list[dict]]:
    """Append entries whose name isn't already in filament_list. Returns
    (added, already_ours, foreign):
      - added: entries new to BBL.json this run (we appended them)
      - already_ours: in BBL.json AND in our previous tracking
                      (re-install case -- we owned these before)
      - foreign: in BBL.json but NOT in our tracking (user added them
                 or another tool put them there; we don't claim them)

    The two skipped categories matter for the install summary: a
    re-install user seeing "1376 entries skipped (not ours)" thinks
    something broke, when really 1376 entries are just from their
    previous Filanex install."""
    existing = {e["name"] for e in user_bbl.get("filament_list", [])}
    our_prev = our_prev_names or set()
    added: list[dict] = []
    already_ours: list[dict] = []
    foreign: list[dict] = []
    for entry in entries_to_add:
        if entry["name"] in existing:
            if entry["name"] in our_prev:
                already_ours.append(entry)
            else:
                foreign.append(entry)
            continue
        user_bbl.setdefault("filament_list", []).append(entry)
        existing.add(entry["name"])
        added.append(entry)
    return added, already_ours, foreign


def manifest_remove_entries(user_bbl: dict, names_to_remove: set[str]) -> int:
    """Remove all filament_list entries whose name is in names_to_remove.
    Returns count removed."""
    fl = user_bbl.get("filament_list", [])
    new_fl = [e for e in fl if e["name"] not in names_to_remove]
    removed = len(fl) - len(new_fl)
    user_bbl["filament_list"] = new_fl
    return removed


def enable_filaments_in_user_conf(
    system_dir: Path, names_to_enable: list[str], names_to_disable: list[str] | None = None,
) -> tuple[int, int] | None:
    """Add `names_to_enable` to BambuStudio.conf's top-level
    `filaments` list (the per-user enabled-filaments registry that
    drives the in-slicer dropdown). Without this, profile JSONs ship
    into BBL.json but stay invisible until the user manually clicks
    them through "Add/Remove filaments".

    Returns (n_added, n_already_enabled) or None if the conf can't be
    located / parsed (best-effort -- never fail the install).

    Bambu Studio is closed during install (we enforce that earlier),
    so this is a safe time to rewrite. Atomic write + .bak retained.
    """
    import hashlib

    # system_dir is .../BambuStudio/system/; conf is one level up
    conf_path = system_dir.parent / "BambuStudio.conf"
    if not conf_path.is_file():
        return None
    try:
        text = conf_path.read_text(encoding="utf-8")
        # File is one JSON object plus a trailing "# MD5 checksum <hex>"
        # comment Bambu Studio uses to detect tampering. Decode just
        # the JSON, modify, re-encode, recompute MD5.
        decoder = json.JSONDecoder()
        conf, json_end = decoder.raw_decode(text, 0)
    except Exception:
        return None

    if not isinstance(conf, dict):
        return None
    current = conf.get("filaments")
    if not isinstance(current, list):
        # Some user states have no filaments key yet -- create it.
        current = []

    enabled_set = set(current)
    n_already = 0
    n_added = 0
    for name in names_to_enable:
        if name in enabled_set:
            n_already += 1
            continue
        current.append(name)
        enabled_set.add(name)
        n_added += 1

    if names_to_disable:
        disable_set = set(names_to_disable)
        current = [n for n in current if n not in disable_set]

    conf["filaments"] = current

    # Write back: JSON re-encoded, MD5 over the JSON bytes only.
    new_json = json.dumps(conf, indent=4, ensure_ascii=False)
    md5 = hashlib.md5(new_json.encode("utf-8")).hexdigest().upper()
    new_text = f"{new_json}\n# MD5 checksum {md5}\n"

    # Backup the existing conf next to itself.
    bak_path = conf_path.with_suffix(conf_path.suffix + ".filanex-bak")
    try:
        bak_path.write_text(text, encoding="utf-8")
    except OSError:
        pass  # best-effort

    atomic_write_text(conf_path, new_text)
    return n_added, n_already


def atomic_write_text(path: Path, text: str) -> None:
    """Same atomicity guarantee as atomic_write_json: write next-door
    then os.replace. Used for non-JSON files we still need to write
    safely (BambuStudio.conf -- JSON+MD5-comment hybrid)."""
    tmp = path.with_suffix(path.suffix + ".tmp")
    tmp.write_text(text, encoding="utf-8")
    os.replace(tmp, path)


# ---------------------------------------------------------------------------
# Install / Upgrade
# ---------------------------------------------------------------------------

def filter_bundle_by_selection(bundle: dict, selection,
                                printer_filter: set[str] | None = None) -> dict:
    """Return a new bundle dict keeping only entries / files whose
    (vendor, line, material) is in selection.profile_keys AND -- if
    `printer_filter` is provided -- whose printer (parsed from the
    entry name) is in that set.

    Bucketing must match picker.build_tree() exactly or selections
    silently drop. Newer bundles (>= db v1.1.3) ship explicit
    vendor/line/material/is_base fields on every addition; use those
    directly. Older bundles only have `name`, so fall back to the
    legacy regex-based parse_entry_name() with whatever vendor field
    happens to be there.

    @base entries are always kept when ANY material in their (vendor,
    line) is picked -- they're chemistry roots and the picker doesn't
    show them as user-pickable items.

    printer_filter: when non-empty, drops leaves whose printer isn't
    in the set. Eliminates "Unsupported"-section flood in Bambu Studio
    for users with one or two printers (they don't need ~10 printers'
    worth of leaves for every line). @base entries are never filtered
    by printer (they have no printer binding).
    """
    from picker import parse_entry_name

    # The picker is the single source of truth for what gets installed.
    # No force-install bypass. If the user wants a vendor's overlay,
    # they tick it; if they don't, we don't install it. Previous
    # FORCE_INSTALL_VENDORS = {"Polymaker"} rule was reverted because
    # it shipped 2,651 Polymaker entries even when the user wanted
    # something smaller -- which is exactly what the picker is for.

    keep_names: set[str] = set()
    for entry in bundle["entries"]:
        if entry.get("is_base"):
            # @base files are kept only when the user picked the
            # SPECIFIC (vendor, line, material) for that @base -- not
            # just any material in the (vendor, line). Each @base has
            # its own material (e.g. "PolyLite PLA @Polymaker base"
            # is material=PLA; "PolyLite PLA Glow @base" is material=
            # "PLA Glow"). Without this check, picking PolyLite HT-PLA
            # would also keep the PolyLite PLA @base, but no PLA
            # leaves get kept, leaving an orphan @base in the user's
            # filament library that Bambu Studio shows as a broken
            # "Unsupported" entry.
            v = entry.get("vendor")
            l = entry.get("line")
            m = entry.get("material")
            if v is not None and l is not None and m is not None and (v, l, m) in selection.profile_keys:
                keep_names.add(entry["name"])
            continue
        # Prefer explicit picker fields over name-regex (the regex
        # silently mis-buckets vendor-prefixed names like
        # "Anycubic PLA @BBL X1C 0.4 nozzle" as vendor="Other").
        if "vendor" in entry and "line" in entry and "material" in entry:
            tup = (entry["vendor"], entry["line"], entry["material"])
        else:
            parsed = parse_entry_name(entry["name"], entry.get("vendor"))
            if parsed is None:
                keep_names.add(entry["name"])
                continue
            tup = parsed
        if tup not in selection.profile_keys:
            continue
        # Apply printer filter for leaves.
        if printer_filter and not printer_matches_entry(entry["name"], printer_filter):
            continue
        keep_names.add(entry["name"])
    filtered_entries = [e for e in bundle["entries"] if e["name"] in keep_names]
    keep_filenames = {e["sub_path"].split("/")[-1] for e in filtered_entries}
    filtered_files = {
        fn: sha for fn, sha in bundle["files"].items() if fn in keep_filenames
    }
    return {
        "entries": filtered_entries,
        "files": filtered_files,
        "database_version": bundle.get("database_version"),
        "_src_filament_dir": bundle.get("_src_filament_dir"),
    }


def cmd_install(
    system_dir: Path, src_additions: Path, src_filament_dir: Path,
    force: bool, selection=None, auto_fetch: bool = True,
) -> int:
    """Fresh install if no tracking file; otherwise upgrade.
    If `selection` is provided, the bundle is filtered to just the
    user's picks before applying.

    When auto_fetch is True (the default for CLI runs), the latest data
    is fetched from DISTRIBUTION_BASE_URL first -- if a newer version is
    available online, the install uses that data instead of whatever
    shipped with the .exe. Falls back to the bundled data when offline /
    fetch fails / versions match. The wizard sets auto_fetch=False
    because it does the fetch earlier (so new vendors/lines/materials
    can appear in the picker)."""
    if auto_fetch:
        fetched_dir = _try_auto_fetch_bundle(src_additions)
        if fetched_dir is not None:
            src_additions = fetched_dir / "additions.json"
            src_filament_dir = fetched_dir / "BBL" / "filament"

    tracking = load_tracking(system_dir)
    is_upgrade = tracking is not None
    bundle = load_bundle(src_additions, src_filament_dir)

    if selection is not None:
        _emit_phase("Filtering selection")
        before_entries = len(bundle["entries"])
        before_files = len(bundle["files"])
        # NOTE: per-printer auto-filter was tried briefly but reverted --
        # users who swap printers regularly need ALL leaves installed.
        # Bambu Studio's own slicer handles per-printer compatibility
        # (showing only matching leaves for the currently-selected
        # printer); the "Unsupported" section listing leaves for other
        # printers is the slicer's correct UX, not a problem to fix.
        bundle = filter_bundle_by_selection(bundle, selection)
        print(
            f"  Filtered bundle by user selection: "
            f"{len(bundle['entries'])}/{before_entries} entries, "
            f"{len(bundle['files'])}/{before_files} files."
        )
    # Hash only what we're actually about to install. Order matters:
    # this MUST run after filtering so the 16k bundle's unused files
    # don't get hashed when the user only picked a small subset.
    hash_bundle_files(bundle)

    if is_upgrade:
        return _do_upgrade(system_dir, tracking, bundle, src_filament_dir, force)
    return _do_fresh_install(system_dir, bundle, src_filament_dir)


def _do_fresh_install(
    system_dir: Path, bundle: dict, src_filament_dir: Path
) -> int:
    section("Fresh install")
    target_filament = system_dir / "BBL" / "filament"
    target_filament.mkdir(parents=True, exist_ok=True)

    # Files: copy ones that don't exist; INHERIT ones that already exist
    # with our exact content (record them in tracking so future
    # upgrade/uninstall handles them); SKIP ones with different content
    # (someone else's file -- not ours to touch).
    installed_files: list[dict] = []
    files_added = files_inherited = files_skipped = 0
    total_files = len(bundle["files"])
    for i, (filename, sha) in enumerate(bundle["files"].items(), 1):
        src = src_filament_dir / filename
        dst = target_filament / filename
        if dst.exists():
            try:
                live_sha = file_sha256(dst)
            except OSError:
                files_skipped += 1
                _emit_progress("Installing files", i, total_files)
                continue
            if live_sha == sha:
                # Same content -- claim as ours.
                installed_files.append({"filename": filename, "sha256": sha})
                files_inherited += 1
            else:
                files_skipped += 1
            _emit_progress("Installing files", i, total_files)
            continue
        shutil.copy2(src, dst)
        installed_files.append({"filename": filename, "sha256": sha})
        files_added += 1
        _emit_progress("Installing files", i, total_files)

    # Manifest entries: claim names already in the user's filament_list
    # too (inheritance) -- if BBL.json already has "PolyLite ASA @BBL ..."
    # listed and the file at that sub_path matches our hash, we own it
    # for tracking purposes.
    user_bbl_path = system_dir / "BBL.json"
    user_bbl = json.loads(user_bbl_path.read_text(encoding="utf-8"))
    existing_by_name = {e["name"]: e for e in user_bbl.get("filament_list", [])}
    added_entries: list[dict] = []
    inherited_entries: list[dict] = []
    for entry in bundle["entries"]:
        if entry["name"] in existing_by_name:
            inherited_entries.append(existing_by_name[entry["name"]])
        else:
            user_bbl.setdefault("filament_list", []).append(entry)
            existing_by_name[entry["name"]] = entry
            added_entries.append(entry)
    if added_entries:
        _emit_phase("Updating BBL.json")
        atomic_write_json(user_bbl_path, user_bbl)

    _emit_phase("Saving install record")
    save_tracking(system_dir, build_tracking(
        installed_files, added_entries + inherited_entries,
        database_version=bundle.get("database_version"),
    ))

    # Auto-enable in user's filament dropdown (best-effort). On a
    # FRESH install we enable everything we just placed -- there's no
    # prior user state to preserve. Inherited entries (matched by hash
    # but already on disk) get enabled too since the user has no
    # historical disable choice for them.
    _emit_phase("Enabling in Bambu Studio dropdown")
    enable_names = [e["name"] for e in added_entries + inherited_entries]
    enable_result = enable_filaments_in_user_conf(system_dir, enable_names)

    # Disable Bambu's legacy vendor-subfolder files (BBL/filament/Polymaker/
    # etc.) so they stop polluting the slicer dropdown as Unsupported
    # entries on printers they weren't tested for.
    _emit_phase("Disabling Bambu's legacy vendor-subfolder files")
    legacy_disabled = disable_bambu_legacy_subfolders(system_dir)

    # Wholesale Bambu-stock removal for picked vendors. For every
    # vendor the user ticked in the picker (Polymaker, Overture,
    # SUNLU, eSUN), back up Bambu's stock files matching that
    # vendor's brand prefixes (root + subfolders, @base + leaves).
    # Bambu's stock disappears from the picker; only our overlay
    # remains, so users stop seeing Unsupported entries for any
    # vendor we cover.
    _emit_phase("Removing Bambu stock files for picked vendors")
    our_filenames = set(bundle["files"].keys())
    picked_vendors = {e.get("vendor") for e in bundle["entries"] if e.get("vendor")}
    bambu_root_backed_up, vendors_not_picked = (
        backup_bambu_stock_for_picked_vendors(
            target_filament, our_filenames, picked_vendors,
        )
    )

    # Clean up Bambu Studio's auto-copy files (* - Copy.json/.info) in
    # the user folder for any Polymaker SKU. These are leftovers from
    # accidental Edit/Save-As clicks and have empty compatible_printers
    # so they always show as Unsupported.
    _emit_phase("Cleaning up Bambu Studio auto-copy files in user folder")
    user_copies_moved = cleanup_user_folder_polymaker_copies(system_dir)

    # Wipe cloud-synced Bambu user-base profiles for picked vendors.
    # user/<id>/filament/base/ holds per-printer Bambu stock leaves
    # the cloud library pushed down (often single-printer compat,
    # missing H2C variants). These were the actual root cause of
    # the persistent Fiberon-in-Unsupported issue.
    _emit_phase("Cleaning cloud-synced user-base for picked vendors")
    user_base_moved = cleanup_user_base_synced_files(system_dir, picked_vendors)

    # Deep wipe: Bambu Studio's bundled resources in Program Files.
    # install_bundles_rsrc() re-extracts these at every launch
    # (hardcoded "always update for BBL"), so wiping only system/
    # leaves stock files coming back. Requires admin. If we're not
    # running elevated, log a warning and skip -- not fatal.
    _emit_phase("Deep wipe of Bambu Studio install resources (admin)")
    deep_wiped, deep_wipe_ran = deep_wipe_bambu_install_resources(picked_vendors)

    # NOTE: We do NOT restore .filanex-bambu-backup files on install --
    # those are exactly the Bambu stock files we just wiped to fix
    # Unsupported entries. Restoring them would undo the wipe in the
    # same run. Restoration only happens on uninstall.
    bambu_restored = 0

    print(f"  Files added:         {files_added}")
    print(f"  Files inherited:     {files_inherited}  "
          f"(existing files with matching content -- now tracked)")
    print(f"  Files skipped:       {files_skipped}  "
          f"(existing files with different content -- not ours)")
    print(f"  Legacy stock disabled: {legacy_disabled}  "
          f"(Bambu BBL/filament/Polymaker/* renamed to .filanex-disabled)")
    if bambu_root_backed_up:
        print(f"  Bambu stock backed up: {bambu_root_backed_up}  "
              f"(every file for picked vendors -> .filanex-bambu-backup)")
    if user_copies_moved:
        print(f"  User-folder copies moved: {user_copies_moved}  "
              f"(* - Copy.json/.info -> _filanex-userfile-backup-<timestamp>/)")
    if user_base_moved:
        print(f"  Cloud-sync user-base moved: {user_base_moved}  "
              f"(user/<id>/filament/base/* -> _filanex-userbase-backup-<timestamp>/)")
    if deep_wipe_ran:
        print(f"  Deep wipe (Program Files): {deep_wiped}  "
              f"(Bambu Studio install resources -> .filanex-bambu-backup)")
    else:
        print(f"  Deep wipe (Program Files): SKIPPED  "
              f"(re-run as Administrator to wipe Bambu's bundled resources too)")
    if bambu_restored:
        print(f"  Bambu stock restored: {bambu_restored}  "
              f"(undoing prior over-aggressive disable that broke inheritance)")
    print(f"  Entries appended:    {len(added_entries)}")
    print(f"  Entries inherited:   {len(inherited_entries)}")
    if enable_result is None:
        print(f"  Auto-enable in slicer:  SKIPPED (conf not found/parseable)")
    else:
        n_added, n_already = enable_result
        print(f"  Auto-enabled in slicer: {n_added} newly enabled, "
              f"{n_already} already enabled")
    print(f"  Tracking written:    {tracking_path(system_dir)}")
    print()
    print("=" * 60)
    print(f"  INSTALL COMPLETE -- {files_added + files_inherited} "
          f"files now tracked, {len(added_entries) + len(inherited_entries)} "
          f"entries.")
    print("=" * 60)
    if not installed_files and not added_entries and not inherited_entries:
        print("\nNothing changed -- target had no overlap with the bundle.")
    return 0


def _do_upgrade(
    system_dir: Path, tracking: dict, bundle: dict,
    src_filament_dir: Path, force: bool,
) -> int:
    section(f"Upgrade (previous install: {tracking.get('installed_at', '?')})")
    target_filament = system_dir / "BBL" / "filament"

    prev_files = {f["filename"]: f["sha256"] for f in tracking["filament_files"]}
    prev_entry_names = {e["name"] for e in tracking["filament_list_entries"]}
    new_files = bundle["files"]
    new_entry_names = {e["name"] for e in bundle["entries"]}

    # File reconciliation. Invariant: post-upgrade tracking includes ONLY
    # files we previously owned (still in bundle) plus files we wrote in
    # this run. Files the user added independently -- even if they happen
    # to match our bundle by name + content -- are NOT claimed.
    files_replaced = files_unchanged = files_kept_modified = 0
    files_added = files_removed = files_remove_kept = files_unowned = 0
    new_owned_files: list[dict] = []

    total_new_files = len(new_files)
    for i, (filename, new_sha) in enumerate(new_files.items(), 1):
        src = src_filament_dir / filename
        dst = target_filament / filename
        prev_sha = prev_files.get(filename)
        we_previously_owned = prev_sha is not None

        if dst.exists():
            live_sha = file_sha256(dst)
            if not we_previously_owned:
                # User added a file matching one of our names. Don't touch
                # the file (skip-existing) AND don't claim ownership.
                files_unowned += 1
                _emit_progress("Upgrading files", i, total_new_files)
                continue
            if live_sha == new_sha:
                # We owned it; it's already the new version. Keep ownership.
                files_unchanged += 1
                new_owned_files.append({"filename": filename, "sha256": new_sha})
                _emit_progress("Upgrading files", i, total_new_files)
                continue
            # We owned it; live hash differs from our new bundle. Always
            # overwrite -- the file lives in <system>/BBL/filament/ which
            # is the slicer's read-only stock-profile area. Anything in
            # there that we own should ALWAYS reflect our latest bundle.
            #
            # Hash mismatches from prev_sha happen for two reasons in this
            # folder, neither of which is "user customization":
            #   1. Bambu Studio's profile-sync downloaded a stock-profile
            #      update from Bambu's CDN since our last install.
            #      Without overwriting, our overlay reverts to whatever
            #      Bambu's server pushed (often broken values we
            #      explicitly fixed -- e.g. PA-CF stock = 40°C bed).
            #   2. Stale install from an older Filanex version. Latest
            #      bundle should always win for our own profiles.
            #
            # Real user customizations save to user/<id>/filament/ (a
            # different folder Bambu Studio writes to when users save
            # tweaks via the UI). That folder is untouched by us.
            shutil.copy2(src, dst)
            files_replaced += 1
            new_owned_files.append({"filename": filename, "sha256": new_sha})
        else:
            # File absent. Write it and claim it.
            shutil.copy2(src, dst)
            files_added += 1
            new_owned_files.append({"filename": filename, "sha256": new_sha})
        _emit_progress("Upgrading files", i, total_new_files)

    # Files that were in the previous install but no longer in the bundle.
    obsolete_filenames = set(prev_files) - set(new_files)
    total_obsolete = len(obsolete_filenames)
    for i, filename in enumerate(sorted(obsolete_filenames), 1):
        dst = target_filament / filename
        if not dst.exists():
            _emit_progress("Cleaning obsolete", i, total_obsolete)
            continue
        live_sha = file_sha256(dst)
        prev_sha = prev_files[filename]
        # Same logic as the upgrade branch above: anything we previously
        # owned that's now obsolete (rolled out of the bundle) is always
        # deleted. Hash mismatch doesn't indicate user customization in
        # the system/BBL/filament/ folder -- user customs go to
        # user/<id>/filament/ instead.
        dst.unlink()
        files_removed += 1
        _emit_progress("Cleaning obsolete", i, total_obsolete)

    # Manifest reconciliation. Same invariant: post-upgrade tracking
    # includes only entries we previously owned (still in bundle) plus
    # entries we appended in this run.
    user_bbl_path = system_dir / "BBL.json"
    user_bbl = json.loads(user_bbl_path.read_text(encoding="utf-8"))

    # 1. Drop entries we previously owned but are no longer in bundle.
    obsolete_names = prev_entry_names - new_entry_names
    entries_removed = manifest_remove_entries(user_bbl, obsolete_names)

    # 2. Update sub_path on previously-owned entries if our bundle
    # changed it. This DOES touch user_bbl, but only on entries we
    # already owned -- safe.
    new_entry_by_name = {e["name"]: e for e in bundle["entries"]}
    sub_path_updates = 0
    for e in user_bbl.get("filament_list", []):
        n = e["name"]
        if n in prev_entry_names and n in new_entry_by_name:
            new_sub = new_entry_by_name[n]["sub_path"]
            if e["sub_path"] != new_sub:
                e["sub_path"] = new_sub
                sub_path_updates += 1

    # 3. Append new entries (skip-existing). We track only what we
    # actually appended in this run. The three-way split distinguishes:
    #   - added: brand new entries
    #   - already_ours: in BBL.json AND in our previous tracking
    #     (re-install scenario -- we owned these from a past run)
    #   - foreign: in BBL.json but NOT in our tracking (user added
    #     a profile with the same name independently)
    added_entries, already_ours_entries, foreign_entries = manifest_add_entries(
        user_bbl, bundle["entries"], our_prev_names=prev_entry_names,
    )

    _emit_phase("Updating BBL.json")
    atomic_write_json(user_bbl_path, user_bbl)

    # Post-upgrade ownership = previously owned (still in bundle) + newly
    # appended in this run. Anything the user owns independently stays
    # outside our tracking.
    still_owned_names = prev_entry_names & new_entry_names
    newly_added_names = {e["name"] for e in added_entries}
    new_owned_entries = [
        e for e in bundle["entries"]
        if e["name"] in still_owned_names or e["name"] in newly_added_names
    ]
    _emit_phase("Saving install record")
    save_tracking(system_dir, build_tracking(
        new_owned_files, new_owned_entries,
        database_version=bundle.get("database_version"),
    ))

    # Auto-enable ONLY the entries we added this run (not previously-
    # owned ones that the user may have intentionally disabled since).
    # Re-enabling everything every install would clobber the user's
    # disable choices -- a regression they reported. Disable any
    # obsolete entries (we used to own them, no longer in bundle) so
    # the dropdown doesn't accumulate dead references.
    _emit_phase("Enabling in Bambu Studio dropdown")
    enable_names = [e["name"] for e in added_entries]
    disable_names = list(obsolete_names)
    enable_result = enable_filaments_in_user_conf(
        system_dir, enable_names, disable_names,
    )

    # Disable Bambu's legacy vendor-subfolder files.
    _emit_phase("Disabling Bambu's legacy vendor-subfolder files")
    legacy_disabled = disable_bambu_legacy_subfolders(system_dir)

    # Wholesale Bambu-stock removal for picked vendors. See
    # _do_install for rationale.
    _emit_phase("Removing Bambu stock files for picked vendors")
    our_filenames = set(bundle["files"].keys())
    picked_vendors = {e.get("vendor") for e in bundle["entries"] if e.get("vendor")}
    bambu_root_backed_up, _ = backup_bambu_stock_for_picked_vendors(
        target_filament, our_filenames, picked_vendors,
    )

    # Clean up Bambu Studio's auto-copy files (* - Copy.json/.info) in
    # the user folder for any Polymaker SKU.
    _emit_phase("Cleaning up Bambu Studio auto-copy files in user folder")
    user_copies_moved = cleanup_user_folder_polymaker_copies(system_dir)

    # Wipe cloud-synced Bambu user-base profiles. See _do_install.
    _emit_phase("Cleaning cloud-synced user-base for picked vendors")
    user_base_moved = cleanup_user_base_synced_files(system_dir, picked_vendors)

    # Deep wipe: Bambu Studio's bundled resources in Program Files.
    # See _do_install.
    _emit_phase("Deep wipe of Bambu Studio install resources (admin)")
    deep_wiped, deep_wipe_ran = deep_wipe_bambu_install_resources(picked_vendors)

    # NOTE: We do NOT restore .filanex-bambu-backup files on upgrade
    # either -- those are Bambu stock files the previous install wiped
    # to fix Unsupported entries. Restoring them would re-introduce
    # the Unsupported entries we just removed. Restoration only
    # happens on uninstall.
    bambu_restored = 0

    print(f"  Files added:                       {files_added}")
    print(f"  Files replaced:                    {files_replaced}")
    print(f"  Files unchanged:                   {files_unchanged}")
    print(f"  Files removed:                     {files_removed}")
    print(f"  Legacy stock disabled:             {legacy_disabled}  "
          f"(Bambu's BBL/filament/Polymaker/*.json renamed .filanex-disabled)")
    if bambu_root_backed_up:
        print(f"  Bambu stock backed up:             {bambu_root_backed_up}  "
              f"(every file for picked vendors -> .filanex-bambu-backup)")
    if user_copies_moved:
        print(f"  User-folder copies moved:          {user_copies_moved}  "
              f"(* - Copy.json/.info -> _filanex-userfile-backup-<timestamp>/)")
    if user_base_moved:
        print(f"  Cloud-sync user-base moved:        {user_base_moved}  "
              f"(user/<id>/filament/base/* -> _filanex-userbase-backup-<timestamp>/)")
    if deep_wipe_ran:
        print(f"  Deep wipe (Program Files):         {deep_wiped}  "
              f"(Bambu Studio install resources -> .filanex-bambu-backup)")
    else:
        print(f"  Deep wipe (Program Files):         SKIPPED  "
              f"(re-run as Administrator to wipe Bambu's bundled resources too)")
    if bambu_restored:
        print(f"  Bambu stock restored:              {bambu_restored}  "
              f"(fixes 'Failed loading configuration file' errors from prior install)")
    print(f"  Files matching name but not ours:  {files_unowned}")
    print(f"  Entries added (new this run):      {len(added_entries)}")
    print(f"  Entries already from prior install:{len(already_ours_entries)}")
    if foreign_entries:
        print(f"  Entries from other sources:        {len(foreign_entries)}  "
              f"(user or another tool added these with the same name; we don't claim them)")
    print(f"  Entries removed:                   {entries_removed}")
    print(f"  sub_path updates:                  {sub_path_updates}")
    if enable_result is None:
        print(f"  Auto-enable in slicer:             SKIPPED (conf not "
              f"found/parseable -- enable manually via Bambu Studio's "
              f"\"Add/Remove filaments\" dialog)")
    else:
        n_added, n_already = enable_result
        if not enable_names and not disable_names:
            print(f"  Auto-enable in slicer:             nothing to do "
                  f"(no new filaments this run -- your existing enable/"
                  f"disable choices preserved)")
        else:
            print(f"  Auto-enabled in slicer dropdown:   "
                  f"{n_added} newly enabled, {n_already} were already enabled")
    return 0


# ---------------------------------------------------------------------------
# Uninstall
# ---------------------------------------------------------------------------

def cmd_uninstall(system_dir: Path, force: bool) -> int:
    tracking = load_tracking(system_dir)
    if tracking is None:
        print("=" * 60)
        print("  NOTHING TO UNINSTALL")
        print("=" * 60)
        print()
        print("No tracking file found at:")
        print(f"  {tracking_path(system_dir)}")
        print()
        print("This means the installer didn't track any prior install.")
        print("If you have older Filanex files on disk from a previous")
        print("manual install, run Install first -- it will INHERIT any")
        print("existing files whose content matches the bundle, then a")
        print("future Uninstall will remove them.")
        return 0

    section(f"Uninstall (installed at: {tracking.get('installed_at', '?')})")
    target_filament = system_dir / "BBL" / "filament"

    files_removed = files_kept_modified = 0
    total_to_remove = len(tracking["filament_files"])
    for i, entry in enumerate(tracking["filament_files"], 1):
        filename = entry["filename"]
        recorded_sha = entry["sha256"]
        dst = target_filament / filename
        if not dst.exists():
            _emit_progress("Removing files", i, total_to_remove)
            continue
        # Always delete on uninstall. Files in <system>/BBL/filament/
        # that we own are stock-overrides; user customizations live in
        # user/<id>/filament/ instead. Hash mismatches here would be
        # Bambu's profile-sync changing our file, NOT user edits, so
        # there's no user work to preserve.
        dst.unlink()
        files_removed += 1
        _emit_progress("Removing files", i, total_to_remove)

    user_bbl_path = system_dir / "BBL.json"
    user_bbl = json.loads(user_bbl_path.read_text(encoding="utf-8"))
    names_to_remove = {e["name"] for e in tracking["filament_list_entries"]}
    entries_removed = manifest_remove_entries(user_bbl, names_to_remove)
    if entries_removed:
        atomic_write_json(user_bbl_path, user_bbl)

    # Also remove from user's enabled-filament dropdown so leftover
    # references don't appear as broken entries.
    enable_filaments_in_user_conf(
        system_dir, names_to_enable=[], names_to_disable=list(names_to_remove),
    )

    # Restore Bambu's stock state: undo subfolder disables and undo
    # root-level backups so the user's slicer is exactly as it was
    # before they ran the installer. Without these, uninstalling
    # Filanex would leave the user with NO Polymaker profiles (we
    # removed ours; Bambu's are still hidden as .filanex-disabled /
    # .filanex-bambu-backup).
    legacy_restored = restore_disabled_bambu_legacy_subfolders(system_dir)
    bambu_root_restored = restore_all_bambu_polymaker_backups(target_filament)
    if legacy_restored or bambu_root_restored:
        print(f"  Bambu stock restored:  "
              f"{legacy_restored} subfolder + {bambu_root_restored} root files")

    if files_kept_modified == 0:
        tracking_path(system_dir).unlink()
        print(f"  Tracking file removed.")
    else:
        # Keep tracking around so the user can retry uninstall after
        # reviewing the modified files. Remove only the cleanly-removed
        # entries from tracking.
        kept = [
            e for e in tracking["filament_files"]
            if (target_filament / e["filename"]).exists()
        ]
        tracking["filament_files"] = kept
        tracking["filament_list_entries"] = []
        save_tracking(system_dir, tracking)
        print(f"  Tracking updated; {files_kept_modified} files left for review.")
        print(f"  Re-run with --force to remove user-modified files anyway.")

    print(f"  Files removed:         {files_removed}")
    print(f"  User-modified kept:    {files_kept_modified}")
    print(f"  Manifest entries removed: {entries_removed}")
    print()
    print("=" * 60)
    if files_removed == 0 and entries_removed == 0:
        print("  UNINSTALL COMPLETE -- nothing to remove.")
    else:
        print(f"  UNINSTALL COMPLETE -- removed {files_removed} files "
              f"and {entries_removed} entries.")
    print("=" * 60)
    return 0


# ---------------------------------------------------------------------------
# Update -- fetch latest bundle from the stable URL, run install on it
# ---------------------------------------------------------------------------

def _http_get(url: str, *, timeout: int = 30) -> bytes:
    """Fetch a URL and return its body. Stdlib only -- no external deps."""
    import urllib.request
    req = urllib.request.Request(
        url, headers={"User-Agent": TRACKING_TOOL},
    )
    with urllib.request.urlopen(req, timeout=timeout) as resp:
        return resp.read()


def _parse_version(v: str) -> tuple[int, ...]:
    """Best-effort semver tuple. Non-numeric chunks become 0 so a weird
    string can never raise -- worst case it sorts oddly."""
    out: list[int] = []
    for chunk in v.split("."):
        try:
            out.append(int(chunk))
        except ValueError:
            out.append(0)
    return tuple(out)


def check_for_installer_update(timeout: int = 10) -> str | None:
    """Probe DISTRIBUTION_BASE_URL/additions.json for an `installer_version`
    newer than this build's INSTALLER_VERSION. Returns the remote version
    string if newer, else None. Returns None on any failure -- never
    raises so the wizard can call this on startup without a try/except."""
    try:
        text = _http_get(
            DISTRIBUTION_BASE_URL + "/additions.json", timeout=timeout
        ).decode("utf-8")
        doc = json.loads(text)
        remote = doc.get("installer_version")
        if not remote:
            return None
        if _parse_version(remote) > _parse_version(INSTALLER_VERSION):
            return remote
        return None
    except Exception:
        return None


def check_remote_versions(timeout: int = 10) -> dict | None:
    """One-shot probe that returns both remote installer_version AND
    remote database_version (the bundle's profile data version).
    Returns {'installer_version': str, 'database_version': str,
    'addition_count': int} or None on any failure. Used by the wizard
    so the user can see when only the data has changed but the .exe
    is current -- the common case after a chemistry/conflict-resolution
    bug fix where install.exe is unchanged but the bundle differs."""
    try:
        text = _http_get(
            DISTRIBUTION_BASE_URL + "/additions.json", timeout=timeout
        ).decode("utf-8")
        doc = json.loads(text)
        return {
            "installer_version": doc.get("installer_version") or "?",
            "database_version":  doc.get("database_version") or "?",
            "addition_count":    len(doc.get("filament_list_additions", [])),
        }
    except Exception:
        return None


def perform_self_update(remote_version: str) -> None:
    """Download install.exe from DISTRIBUTION_BASE_URL, atomically swap
    it for the running .exe, spawn the new one with --post-update, and
    return. The CALLER is responsible for exiting immediately so the new
    process has the .exe to itself.

    Windows can't delete a running .exe but it can rename one (the live
    process keeps its file handle by NTFS reference, not by name), so:
        current install.exe -> install.old.exe
        downloaded copy     -> install.exe
        spawn install.exe --post-update
        current process exits

    The post-update boot also tries to delete install.old.exe -- best
    effort, since the prior process may not have fully released its
    handle yet. A second startup picks up anything left behind.

    Raises on download failure / OS error so the caller can surface it.
    """
    if not getattr(sys, "frozen", False):
        raise RuntimeError(
            "Self-update is only supported in the .exe build. Re-clone "
            "the repo / pull from git for the .py path."
        )
    if platform.system() != "Windows":
        raise RuntimeError(
            "Self-update of install.exe is Windows-only -- non-Windows "
            "users run install.py from the repo."
        )

    current_exe = Path(sys.executable).resolve()
    new_exe = current_exe.with_name(current_exe.stem + ".new" + current_exe.suffix)
    old_exe = current_exe.with_name(current_exe.stem + ".old" + current_exe.suffix)

    print(f"Downloading installer v{remote_version}...")
    data = _http_get(DISTRIBUTION_BASE_URL + "/install.exe", timeout=180)
    print(f"  Got {len(data) // 1024} KB.")
    new_exe.write_bytes(data)

    # If a stale .old.exe is still here from a prior update, try to
    # remove it. May still be locked if anything else opened it; we'll
    # try again next launch.
    if old_exe.exists():
        try:
            old_exe.unlink()
        except OSError:
            pass

    os.rename(current_exe, old_exe)
    os.rename(new_exe, current_exe)

    # Detach the new process so it survives our exit. DETACHED_PROCESS
    # = no console attached (none in --windowed builds anyway),
    # CREATE_NEW_PROCESS_GROUP so the parent process group's signals
    # don't reach the child.
    DETACHED_PROCESS = 0x00000008
    CREATE_NEW_PROCESS_GROUP = 0x00000200
    subprocess.Popen(
        [str(current_exe), "--post-update"],
        creationflags=DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP,
        close_fds=True,
    )
    # Brief pause so the new process gets past its PyInstaller
    # bootloader's _MEI extraction + file-mapping phase before our
    # parent exits. Without this the parent occasionally sees a
    # MessageBox 'Failed to remove temporary directory _MEIxxxx'
    # when its own bootloader tries to clean up before the OS has
    # fully untangled the two processes' handles.
    time.sleep(0.5)


def cleanup_old_installer() -> None:
    """If a .old.exe sibling is on disk (left over by a recent
    self-update), try to delete it. Best-effort -- silent on failure
    because the prior process may still hold the handle for a moment."""
    if not getattr(sys, "frozen", False):
        return
    current_exe = Path(sys.executable).resolve()
    old_exe = current_exe.with_name(current_exe.stem + ".old" + current_exe.suffix)
    if old_exe.exists():
        try:
            old_exe.unlink()
        except OSError:
            pass


def _try_auto_fetch_bundle(local_additions: Path) -> Path | None:
    """Probe DISTRIBUTION_BASE_URL for a newer database_version than the
    bundled one. If newer, fetch the version-stamped install zip,
    extract additions.json + BBL/filament/ to a tempdir, and return
    that dir. Return None when versions match, when offline, or on
    any error -- the caller falls back to the bundled data, so this
    must never raise.
    """
    section("Checking for updated profile data")
    print(f"  Source: {DISTRIBUTION_BASE_URL}")
    try:
        if not local_additions.exists():
            print("  No local additions.json to compare against; using online copy if reachable.")
            local_version = None
        else:
            local_doc = json.loads(local_additions.read_text(encoding="utf-8"))
            local_version = local_doc.get("database_version")

        remote_text = _http_get(
            DISTRIBUTION_BASE_URL + "/additions.json", timeout=10
        ).decode("utf-8")
        remote_doc = json.loads(remote_text)
        remote_version = remote_doc.get("database_version")

        print(f"  Local version:  {local_version or '(unknown)'}")
        print(f"  Remote version: {remote_version or '(unknown)'}")

        if remote_version is not None and remote_version == local_version:
            print("  Up to date -- using bundled data.")
            return None

        print(f"  Newer data available; downloading...")
        import io
        import tempfile
        import zipfile
        # Zip filename is version-stamped (Filanex-install-v<X>.zip)
        # so each release is uniquely-named on the public repo. We
        # learned the remote version from additions.json above.
        zip_url = (
            DISTRIBUTION_BASE_URL + f"/Filanex-install-v{remote_version}.zip"
        )
        zip_bytes = _http_get(zip_url, timeout=60)
        print(f"  Got {len(zip_bytes) // 1024} KB.")

        workdir = Path(tempfile.mkdtemp(prefix="polymaker-autofetch-"))
        with zipfile.ZipFile(io.BytesIO(zip_bytes)) as zf:
            for info in zf.infolist():
                if info.filename == "additions.json":
                    zf.extract(info, workdir)
                elif info.filename.startswith("BBL/filament/"):
                    zf.extract(info, workdir)

        fetched_additions = workdir / "additions.json"
        fetched_filament = workdir / "BBL" / "filament"
        if not fetched_additions.exists() or not fetched_filament.is_dir():
            print("  Online zip missing expected files; using bundled data.")
            try:
                shutil.rmtree(workdir, ignore_errors=True)
            except Exception:
                pass
            return None

        print(f"  Using fetched data from {workdir}")
        return workdir
    except Exception as e:
        print(f"  Auto-fetch skipped ({type(e).__name__}: {e}); using bundled data.")
        return None


def cmd_update(
    system_dir: Path, force: bool, selection,
    no_backup: bool, was_running: bool, exe_path: Path | None,
    yes: bool,
) -> int:
    """Check the stable URL for a newer bundle. If newer, fetch it,
    extract additions.json + BBL/filament/, run install/upgrade against
    the freshly-fetched files."""
    section("Checking for updates")
    print(f"  Source: {DISTRIBUTION_BASE_URL}")

    # Fetch the slim additions.json first to compare versions cheaply.
    additions_url = DISTRIBUTION_BASE_URL + "/additions.json"
    try:
        additions_text = _http_get(additions_url).decode("utf-8")
    except Exception as e:
        print(f"  ERROR: couldn't fetch {additions_url}\n  {e}")
        return 1
    try:
        additions_doc = json.loads(additions_text)
    except json.JSONDecodeError as e:
        print(f"  ERROR: server returned non-JSON: {e}")
        return 1

    remote_version = additions_doc.get("database_version") or "(unknown)"
    tracking = load_tracking(system_dir)
    local_version = (
        tracking.get("bundle_database_version") if tracking else None
    ) or "(not installed)"
    print(f"  Local version:  {local_version}")
    print(f"  Remote version: {remote_version}")

    if local_version == remote_version:
        print()
        print("=" * 60)
        print(f"  ALREADY UP TO DATE -- both at version {remote_version}.")
        print(f"  Nothing fetched. No changes.")
        print("=" * 60)
        return 0

    print(f"\nUpdate available: {local_version} -> {remote_version}")
    if not yes:
        ok = input("Proceed with update? [Y/n] ").strip().lower()
        if ok not in ("", "y", "yes"):
            print("Aborted.")
            return 1

    # Fetch the bundle zip and extract the bits we need into a temp dir.
    # Filename is version-stamped (Filanex-install-v<X>.zip); we already
    # know the remote version from the version-check probe above.
    section("Downloading update")
    import io
    import tempfile
    import zipfile
    zip_url = (
        DISTRIBUTION_BASE_URL + f"/Filanex-install-v{remote_version}.zip"
    )
    print(f"  Fetching {zip_url} ...")
    try:
        zip_bytes = _http_get(zip_url, timeout=60)
    except Exception as e:
        print(f"  ERROR: couldn't fetch update zip\n  {e}")
        return 1
    print(f"  Got {len(zip_bytes) // 1024} KB.")

    workdir = Path(tempfile.mkdtemp(prefix="polymaker-update-"))
    try:
        with zipfile.ZipFile(io.BytesIO(zip_bytes)) as zf:
            for info in zf.infolist():
                if info.filename == "additions.json":
                    zf.extract(info, workdir)
                elif info.filename.startswith("BBL/filament/"):
                    zf.extract(info, workdir)
        fetched_additions = workdir / "additions.json"
        fetched_filament = workdir / "BBL" / "filament"
        if not fetched_additions.exists() or not fetched_filament.is_dir():
            print(f"  ERROR: zip didn't contain expected files; got "
                  f"{[p.name for p in workdir.rglob('*') if p.is_file()][:5]}")
            return 1

        # Run install/upgrade against the fetched bundle. The existing
        # cmd_install handles the "fresh install vs upgrade" branch
        # based on tracking presence; we just point it at the new bundle.
        if no_backup:
            print("\nSkipping backup (--no-backup).")
        else:
            section("Backup")
            backup = back_up(system_dir)
            print(f"  Backup at: {backup}")

        return cmd_install(
            system_dir, fetched_additions, fetched_filament, force,
            selection=selection,
        )
    finally:
        import shutil as _shutil
        _shutil.rmtree(workdir, ignore_errors=True)


# ---------------------------------------------------------------------------
# Status
# ---------------------------------------------------------------------------

def cmd_status(system_dir: Path) -> int:
    tracking = load_tracking(system_dir)
    if tracking is None:
        print("Filanex filament profiles: NOT INSTALLED")
        print(f"  (no tracking file at {tracking_path(system_dir)})")
        return 0

    print("Filanex filament profiles: INSTALLED")
    print(f"  Installed at:        {tracking.get('installed_at', '?')}")
    print(f"  Tracking tool:       {tracking.get('tool', '?')}")
    print(f"  Files tracked:       {len(tracking['filament_files'])}")
    print(f"  Manifest entries:    {len(tracking['filament_list_entries'])}")

    target_filament = system_dir / "BBL" / "filament"
    missing = modified = 0
    for entry in tracking["filament_files"]:
        dst = target_filament / entry["filename"]
        if not dst.exists():
            missing += 1
        elif file_sha256(dst) != entry["sha256"]:
            modified += 1
    print(f"  Files missing on disk: {missing}")
    print(f"  Files user-modified:   {modified}")
    return 0


# ---------------------------------------------------------------------------
# Re-launch
# ---------------------------------------------------------------------------

def relaunch(exe_path: Path) -> None:
    try:
        if platform.system() == "Darwin":
            subprocess.Popen(["open", "-a", "BambuStudio"])
        elif platform.system() == "Windows":
            # os.startfile uses ShellExecute under the hood -- it
            # returns immediately and the launched process has NO
            # connection back to our process (no inherited handles,
            # no parent-child relationship). subprocess.Popen even
            # with DETACHED_PROCESS still gets PyInstaller's bootloader
            # confused on exit, occasionally producing a "Failed to
            # remove temporary directory _MEIxxxx" MessageBox.
            # ShellExecute sidesteps this entirely.
            os.startfile(str(exe_path))
        else:
            subprocess.Popen([str(exe_path)], close_fds=True)
        print("Launched.")
    except Exception as e:
        print(f"Could not auto-launch: {e}")
        print(f"Launch manually from: {exe_path}")


# ---------------------------------------------------------------------------
# CLI
# ---------------------------------------------------------------------------

def make_parser() -> argparse.ArgumentParser:
    # Shared flags -- attached to both the top-level parser and every
    # subparser so they're accepted on either side of the subcommand name.
    flags = argparse.ArgumentParser(add_help=False)
    flags.add_argument("--system-dir", type=Path, default=None,
                       help="Override the auto-detected Bambu Studio system folder.")
    flags.add_argument("--no-backup", action="store_true",
                       help="Skip the backup of BBL.json + BBL/filament/.")
    flags.add_argument("--yes", action="store_true",
                       help="Don't prompt for confirmations.")
    flags.add_argument("--force", action="store_true",
                       help="Overwrite/delete user-modified files during "
                            "upgrade or uninstall (default: preserve).")
    flags.add_argument("--all", action="store_true",
                       help="Install everything to every enabled slicer; "
                            "skip the GUI picker.")
    flags.add_argument("--no-gui", action="store_true",
                       help="Headless mode -- don't open the picker. "
                            "Implies --all unless --selection is given.")
    flags.add_argument("--post-update", action="store_true",
                       help="Internal: set by the installer when it "
                            "relaunches itself after a self-update so "
                            "the welcome screen can confirm the update "
                            "succeeded.")
    flags.add_argument("--skip-update-check", action="store_true",
                       help="Skip the on-startup check for a newer "
                            "install.exe. The bundled data fetch on the "
                            "picker step still runs.")

    parser = argparse.ArgumentParser(
        parents=[flags],
        description="Install / upgrade / uninstall Filanex filament profiles in Bambu Studio.",
    )
    sub = parser.add_subparsers(dest="command", metavar="COMMAND")
    sub.add_parser("install", parents=[flags],
                   help="Install or upgrade (default).")
    sub.add_parser("upgrade", parents=[flags],
                   help="Upgrade only; error if not previously installed.")
    sub.add_parser("uninstall", parents=[flags],
                   help="Remove what this installer added.")
    sub.add_parser("update", parents=[flags],
                   help="Check the stable URL for a newer bundle and "
                        "apply it. Replaces the bundled data with the "
                        "online copy.")
    sub.add_parser("status", parents=[flags],
                   help="Show install state and exit.")
    return parser


def main() -> int:
    args = make_parser().parse_args()

    # If the prior run swapped in a new .exe and relaunched us, sweep
    # the leftover install.old.exe sibling now (file handle should be
    # released by now). Best-effort.
    cleanup_old_installer()

    # No subcommand AND not headless -> open the GUI wizard. CLI
    # subcommands (install / upgrade / uninstall / update / status)
    # remain available for power users + scripting.
    if args.command is None and not args.no_gui:
        try:
            import gui as _gui  # type: ignore
        except ImportError as e:
            print(f"GUI module unavailable ({e}); falling back to CLI install.")
        else:
            try:
                system_dir = detect_system_dir(args.system_dir)
                sanity_check_target(system_dir)
            except SystemExit as e:
                # In --windowed PyInstaller builds stdout / stderr go to
                # nowhere visible. Surface the failure via a messagebox.
                import tkinter as tk  # noqa: WPS433  (lazy on purpose)
                from tkinter import messagebox
                root = tk.Tk()
                root.withdraw()
                messagebox.showerror(
                    "Filanex installer",
                    str(e) if e.code else "Setup check failed.",
                )
                root.destroy()
                return 1
            return _gui.run(__import__(__name__), system_dir, args)

    cmd = args.command or "install"

    banner("Filanex filament profile installer for Bambu Studio")

    system_dir = detect_system_dir(args.system_dir)
    print(f"Target system folder: {system_dir}")

    if cmd == "status":
        sanity_check_target(system_dir)
        return cmd_status(system_dir)

    sanity_check_target(system_dir)
    need_bundle = cmd in ("install", "upgrade")
    src_additions, src_filament_dir = sanity_check_source(need_bundle)

    if cmd == "upgrade" and load_tracking(system_dir) is None:
        sys.exit(
            "ERROR: no tracking file found, nothing to upgrade. "
            "Run `install.py install` (or just `install.py`) first."
        )
    if cmd == "update" and load_tracking(system_dir) is None:
        # First-time installs should use `install` (with the bundled
        # data) rather than `update` (which fetches the latest online
        # version and applies it). Both work, but `update` makes the
        # roundtrip slower and less obvious.
        if not args.yes:
            print(
                "WARNING: nothing currently installed (no tracking file)."
                "\n         `update` will fetch and install the latest "
                "online bundle."
            )
            ok = input("Continue? [Y/n] ").strip().lower()
            if ok not in ("", "y", "yes"):
                print("Aborted.")
                return 1

    skip_running_check = os.environ.get("POLYMAKER_INSTALLER_SKIP_RUNNING_CHECK") == "1"
    if cmd in ("install", "upgrade", "uninstall", "update") and not skip_running_check:
        running, exe_path = find_bambu_process()
        was_running = running
        if running:
            print(
                f"\nBambu Studio appears to be running"
                + (f" ({exe_path})" if exe_path else "") + "."
                + "\nSave your work and close Bambu Studio before continuing."
            )
            wait_for_close()
        else:
            print("\nBambu Studio is not running. OK to proceed.")
            exe_path = None
    else:
        was_running = False
        exe_path = None

    if not args.yes:
        ok = input(
            f"\nProceed with {cmd!r} into {system_dir}? [Y/n] "
        ).strip().lower()
        if ok not in ("", "y", "yes"):
            print("Aborted.")
            return 1

    if not args.no_backup:
        section("Backup")
        backup = back_up(system_dir)
        print(f"  Backup at: {backup}")
    else:
        print("\nSkipping backup (--no-backup).")

    if cmd == "update":
        # Get a selection (picker or --all) so the fetched bundle is
        # filtered the same way local installs are.
        selection = None
        # `update` reads additions from the FETCHED zip, so we don't
        # have a local additions to feed the picker beforehand. Use
        # the local bundle's additions (if present) for the picker
        # tree -- that's a close-enough preview of what will be
        # installed; the actual filter applies to the fetched bundle.
        if (HERE / "additions.json").exists():
            additions_local = json.loads(
                (HERE / "additions.json").read_text(encoding="utf-8")
            )["filament_list_additions"]
            if args.all or args.no_gui:
                from picker import select_all
                selection = select_all(additions_local)
            else:
                from picker import show_picker
                selection = show_picker(additions_local)
                if selection.cancelled:
                    print("Cancelled by user.")
                    return 1
        else:
            # No local bundle to preview. Default to install-everything.
            print("(No local bundle present; will install everything from the fetched copy.)")
        rc = cmd_update(
            system_dir, args.force, selection,
            no_backup=args.no_backup, was_running=was_running,
            exe_path=exe_path, yes=args.yes,
        )
    elif cmd in ("install", "upgrade"):
        # Decide what to install: GUI picker (default, interactive) or
        # the full bundle (--all / --no-gui).
        selection = None
        if cmd in ("install", "upgrade") and src_additions is not None:
            additions = json.loads(src_additions.read_text(encoding="utf-8"))[
                "filament_list_additions"
            ]
            if args.all or args.no_gui:
                from picker import select_all
                selection = select_all(additions)
                print(f"\nSelection: install everything ({len(selection.profile_keys)} "
                      f"groups across {len(selection.slicers)} slicer(s)).")
            else:
                from picker import show_picker
                print("\nOpening selection window...")
                selection = show_picker(additions)
                if selection.cancelled:
                    print("Cancelled by user.")
                    return 1
                print(f"Selection: {len(selection.profile_keys)} groups across "
                      f"{len(selection.slicers)} slicer(s).")
            # For now only bambu_studio is implemented. Warn for any
            # other slicer the user picked (none will be checked yet
            # since the picker disables the others, but it's defensive).
            unsupported = selection.slicers - {"bambu_studio"}
            if unsupported:
                print(f"  Skipping not-yet-implemented slicers: "
                      f"{', '.join(sorted(unsupported))}")
            if "bambu_studio" not in selection.slicers:
                print("  ERROR: no implemented slicer in selection. "
                      "Bambu Studio is the only one wired up so far.")
                return 1
        rc = cmd_install(
            system_dir, src_additions, src_filament_dir, args.force,
            selection=selection,
        )
    elif cmd == "uninstall":
        rc = cmd_uninstall(system_dir, args.force)
    else:
        sys.exit(f"Unknown command: {cmd}")

    banner(f"{cmd.capitalize()} complete.")
    if cmd in ("install", "upgrade"):
        print("FIRST-LAUNCH STEP:")
        print("  When BBL.json changes, Bambu Studio may deselect your active")
        print("  printer. After launch, pick your printer in the top-left")
        print("  dropdown, then open Filament Settings (gear icon) to tick")
        print("  the Filanex lines you want.\n")

    if was_running and exe_path is not None:
        ans = "y" if args.yes else input(
            "Re-launch Bambu Studio now? [Y/n] "
        ).strip().lower()
        if ans in ("", "y", "yes"):
            relaunch(exe_path)
    elif was_running:
        print(
            "Note: Bambu Studio was running at start but I couldn't capture\n"
            "its executable path; please launch it manually."
        )

    return rc


if __name__ == "__main__":
    try:
        rc = main()
    except KeyboardInterrupt:
        print("\nInterrupted.")
        rc = 130
    # Keep the console open after a double-click on Windows. Skip if
    # we're not interactive (e.g. piped, tested, or run from a script).
    # In a --windowed PyInstaller build there is no console attached
    # to the process; sys.stdin is None and `.isatty()` would crash.
    if (sys.stdin is not None and sys.stdin.isatty()
            and platform.system() == "Windows"):
        try:
            input("\nPress Enter to exit... ")
        except EOFError:
            pass
    raise SystemExit(rc)