"""

SaveUtils.py  -  core logic for the SaveUtils FreeCAD addon.

"""

import re

import os

import datetime

import FreeCAD

import FreeCADGui

from PySide import QtCore, QtGui

# Imported only from InitGui.py, i.e. always in a GUI session — see the note

# there about why FreeCAD.GuiUp must not gate these imports.

QT_TRANSLATE_NOOP = FreeCAD.Qt.QT_TRANSLATE_NOOP

FreeCAD.Console.PrintLog("=== SaveUtils: SaveUtils.py loading ===\n")

# ---------------------------------------------------------------------------

# Regex patterns

# ---------------------------------------------------------------------------

_TS_PATTERN = re.compile(r"-\d{8}-\d{6}\.FCStd$", re.IGNORECASE)

# Unbounded digit count, so counters that grow past -99 keep incrementing

# instead of colliding on the same name

_INC_SCAN_PATTERN = re.compile(r"-(\d+)\.FCStd$", re.IGNORECASE)

_EXT_PATTERN = re.compile(r"\.FCStd$", re.IGNORECASE)

def _strip_fcstd(path):

    return _EXT_PATTERN.sub("", path)

def _active_document():

    doc = FreeCAD.ActiveDocument

    if doc is None:

        QtGui.QMessageBox.warning(

            FreeCADGui.getMainWindow(), "SaveUtils", "No active document."

        )

    return doc

def _ask_filename(title, current=""):

    """Ask for a base filename. Returns the raw path, or None if cancelled."""

    start = current or os.path.expanduser("~/untitled.FCStd")

    parent = FreeCADGui.getMainWindow()

    flt = "FreeCAD files (*.FCStd)"

    # We derive a different name from whatever is picked, so Qt's overwrite

    # confirmation would be warning about a file we are never going to write.

    try:

        dont_confirm = QtGui.QFileDialog.Option.DontConfirmOverwrite

        path, _ = QtGui.QFileDialog.getSaveFileName(

            parent, title, start, flt, "", dont_confirm

        )

    except Exception:

        path, _ = QtGui.QFileDialog.getSaveFileName(parent, title, start, flt)

    return path or None

def _error(exc):

    QtGui.QMessageBox.critical(

        FreeCADGui.getMainWindow(),

        "SaveUtils error",

        f"Could not save file:\n{exc}",

    )

    return False

def _clear_modified(doc):

    """Clear the GUI's unsaved-changes marker — the * in the title bar.

    The asterisk is driven by the Gui document's own modified flag, which does

    not reliably follow an App-level saveAs(). Only ever called straight after a

    successful save, when there genuinely are no unsaved changes left.

    """

    try:

        gui_doc = FreeCADGui.getDocument(doc.Name)

    except Exception:

        return

    try:

        if getattr(gui_doc, "Modified", False):

            gui_doc.Modified = False

    except Exception:

        FreeCAD.Console.PrintLog(

            "=== SaveUtils: could not clear the modified flag ===\n"

        )

def _save_as(new_path):

    """Save the active document as `new_path` and keep working in it."""

    doc = FreeCAD.ActiveDocument

    try:

        doc.saveAs(new_path)

    except Exception as exc:

        return _error(exc)

    _clear_modified(doc)

    FreeCAD.Console.PrintMessage(f"SaveUtils: saved as '{new_path}'\n")

    return True

def _timestamp_base(path):

    """Strip a trailing -YYYYMMDD-HHMMSS and the .FCStd extension."""

    if _TS_PATTERN.search(path):

        return _TS_PATTERN.sub("", path)

    return _strip_fcstd(path)

def _increment_base(path):

    """Strip a trailing -NN and the .FCStd extension."""

    # A -YYYYMMDD-HHMMSS tail also ends in digits; keep it whole rather than

    # incrementing the time portion into a bogus timestamp

    if not _TS_PATTERN.search(path):

        m = _INC_SCAN_PATTERN.search(path)

        if m:

            return path[: m.start()]

    return _strip_fcstd(path)

def _next_increment(base):

    """Return the lowest unused -NN counter for `base` (path without .FCStd)."""

    directory = os.path.dirname(base) or "."

    stem = os.path.basename(base)

    highest = 0

    try:

        entries = os.listdir(directory)

    except OSError:

        entries = []

    prefix = f"{stem.lower()}-"

    for name in entries:

        if not name.lower().startswith(prefix):

            continue

        m = _INC_SCAN_PATTERN.search(name)

        # Only count siblings whose counter directly follows the stem, so

        # "design-detail-01.FCStd" is not mistaken for a "design" increment.

        if m and m.start() == len(stem):

            highest = max(highest, int(m.group(1)))

    return highest + 1

def _timestamp_name(base):

    stamp = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")

    return f"{base}-{stamp}.FCStd"

def _increment_name(base):

    return f"{base}-{_next_increment(base):02d}.FCStd"

# ---------------------------------------------------------------------------

# Commands

# ---------------------------------------------------------------------------

def _save_derived(prompt, title, strip_tail, make_name):

    """Save the document under a name derived from a base, and switch to it.

    `strip_tail` removes any existing suffix so repeated use does not stack them

    up; `make_name` builds the new filename. The base comes from the open

    document, or from a file dialog when `prompt` is set — or when the document

    has never been saved and so has no name to derive from.

    """

    doc = _active_document()

    if doc is None:

        return

    path = doc.FileName

    if prompt or not path:

        path = _ask_filename(title, path)

        if path is None:

            return

    _save_as(make_name(strip_tail(path)))

class CmdSaveTimestamp:

    """File > Save with Timestamp — auto-named from the open document."""

    def GetResources(self):

        return {

            "MenuText": "Save with Timestamp",

            "ToolTip": "Save as <name>-YYYYMMDD-HHMMSS.FCStd and keep working in it",

            "Pixmap": "",

        }

    def IsActive(self):

        return FreeCAD.ActiveDocument is not None

    def Activated(self):

        _save_derived(

            False, "Save with Timestamp", _timestamp_base, _timestamp_name

        )

class CmdSaveIncrement:

    """File > Save Increment — auto-named from the open document."""

    def GetResources(self):

        return {

            "MenuText": "Save Increment",

            "ToolTip": "Save as the next <name>-NN.FCStd and keep working in it",

            "Pixmap": "",

        }

    def IsActive(self):

        return FreeCAD.ActiveDocument is not None

    def Activated(self):

        _save_derived(False, "Save Increment", _increment_base, _increment_name)

class CmdSaveAsTimestamp:

    """File > Save As with Timestamp — base filename chosen in a dialog."""

    def GetResources(self):

        return {

            "MenuText": "Save As with Timestamp",

            "ToolTip": "Choose a base filename, then save as <base>-YYYYMMDD-HHMMSS.FCStd",

            "Pixmap": "",

        }

    def IsActive(self):

        return FreeCAD.ActiveDocument is not None

    def Activated(self):

        _save_derived(

            True,

            "Save As with Timestamp – choose base filename",

            _timestamp_base,

            _timestamp_name,

        )

class CmdSaveAsIncrement:

    """File > Save As Increment — base filename chosen in a dialog."""

    def GetResources(self):

        return {

            "MenuText": "Save As Increment",

            "ToolTip": "Choose a base filename, then save as the next <base>-NN.FCStd",

            "Pixmap": "",

        }

    def IsActive(self):

        return FreeCAD.ActiveDocument is not None

    def Activated(self):

        _save_derived(

            True,

            "Save As Increment – choose base filename",

            _increment_base,

            _increment_name,

        )

# ---------------------------------------------------------------------------

# Menu injection

# ---------------------------------------------------------------------------

_commands_registered = False

def install_safely():

    """Entry point for InitGui.py.

    Called from a QTimer slot, so an escaping exception would propagate into

    Qt's event loop. Report it and carry on instead.

    """

    try:

        install()

    except Exception as exc:

        FreeCAD.Console.PrintError(f"=== SaveUtils install error: {exc} ===\n")

def install():

    """Register the commands and put them in the File menu. Safe to call again."""

    global _commands_registered

    FreeCAD.Console.PrintLog("=== SaveUtils: install() called ===\n")

    if not _commands_registered:

        # Command names are kept as they were so existing keyboard shortcuts

        # still resolve, even though the classes behind them were renamed.

        FreeCADGui.addCommand("SaveUtils_SaveTimestamp", CmdSaveTimestamp())

        FreeCADGui.addCommand("SaveUtils_SaveIncrement", CmdSaveIncrement())

        FreeCADGui.addCommand("SaveUtils_Timestamp", CmdSaveAsTimestamp())

        FreeCADGui.addCommand("SaveUtils_Increment", CmdSaveAsIncrement())

        _commands_registered = True

    _inject_menu()

# Menu text, tooltip and command name for each item, in display order

_ITEMS = [

    (

        "Save with Timestamp",

        "Save as <name>-YYYYMMDD-HHMMSS.FCStd and keep working in it",

        "SaveUtils_SaveTimestamp",

    ),

    (

        "Save Increment",

        "Save as the next <name>-NN.FCStd and keep working in it",

        "SaveUtils_SaveIncrement",

    ),

    (

        "Save As with Timestamp",

        "Choose a base filename, then save as <base>-YYYYMMDD-HHMMSS.FCStd",

        "SaveUtils_Timestamp",

    ),

    (

        "Save As Increment",

        "Choose a base filename, then save as the next <base>-NN.FCStd",

        "SaveUtils_Increment",

    ),

]

_ITEM_TEXTS = {text for text, _, _ in _ITEMS}

def _alive(obj):

    """True if the C++ half of a PySide wrapper still exists.

    Deliberately catches everything: this is only ever used to decide whether

    touching `obj` is safe, so it must not be able to raise on its own.

    """

    if obj is None:

        return False

    try:

        obj.objectName()

        return True

    except Exception:

        return False

def _addr(obj):

    """Identity of the underlying C++ object, so recreations are visible."""

    if obj is None:

        return "None"

    try:

        import shiboken6

        return hex(shiboken6.getCppPointer(obj)[0])

    except Exception:

        try:

            return f"py:{id(obj):x}"

        except Exception:

            return "?"

def report():

    """Diagnostics. Run from FreeCAD's Python console:

        import SaveUtils; SaveUtils.report()

    Everything is collected before anything is printed: writing to the Report

    view can pump the event loop, and FreeCAD may destroy menus while it does,

    which would invalidate the wrappers mid-report.

    """

    lines = []

    try:

        mw = FreeCADGui.getMainWindow()

        lines.append(f"commands registered : {_commands_registered}")

        lines.append(f"main window         : {_addr(mw)} alive={_alive(mw)}")

        if not _alive(mw):

            return _emit(lines)

        menubar = mw.menuBar()

        lines.append(

            f"menu bar            : {_addr(menubar)} alive={_alive(menubar)} "

            f"visible={menubar.isVisible()} native={menubar.isNativeMenuBar()}"

        )

        lines.append("menu bar entries    : text | objectName | visible | addr")

        for action in menubar.actions():

            try:

                menu = action.menu()

                if menu is None:

                    lines.append(f"    (no submenu) {action.text()!r}")

                    continue

                lines.append(

                    f"    {action.text()!r} | {menu.objectName()!r} | "

                    f"{action.isVisible()} | {_addr(menu)}"

                )

            except RuntimeError:

                lines.append("    <dead QMenu wrapper>")

        file_menu = _find_file_menu(menubar)

        lines.append(

            f"resolved File menu  : {_addr(file_menu)} alive={_alive(file_menu)}"

        )

        lines.append(

            f"hooked menu         : {_addr(_hooked_menu)} "

            f"alive={_alive(_hooked_menu)} same={_hooked_menu is file_menu}"

        )

        lines.append(

            f"our actions         : {len(_our_actions)} tracked, "

            f"{sum(1 for a in _our_actions if _alive(a))} alive"

        )

        lines.append(f"Show-event watcher  : {'installed' if _watcher else 'NOT installed'}")

        if _alive(file_menu):

            lines.append("File menu contents  :")

            for act in file_menu.actions():

                try:

                    mark = "   <-- ours" if act.text() in _ITEM_TEXTS else ""

                    label = "--separator--" if act.isSeparator() else act.text()

                    lines.append(f"    {label!r} visible={act.isVisible()}{mark}")

                except RuntimeError:

                    lines.append("    <dead QAction wrapper>")

        # Every QMenu anywhere under the main window that looks like a File menu.

        # If the one shown on screen is not the one we resolved, it shows up here.

        try:

            menu_cls = None

            for action in menubar.actions():

                try:

                    if action.menu() is not None:

                        menu_cls = type(action.menu())

                        break

                except RuntimeError:

                    continue

            candidates = mw.findChildren(menu_cls) if menu_cls else []

            lines.append(f"all QMenus under mw : {len(candidates)}")

            for m in candidates:

                try:

                    if "file" in m.objectName().replace("&", "").strip().lower():

                        parent = m.parent()

                        lines.append(

                            f"    {m.objectName()!r} addr={_addr(m)} "

                            f"actions={len(m.actions())} "

                            f"parent={type(parent).__name__ if parent else None}"

                        )

                except RuntimeError:

                    lines.append("    <dead QMenu wrapper>")

        except Exception as exc:

            lines.append(f"child scan failed   : {exc!r}")

    except Exception as exc:

        lines.append(f"report failed: {exc!r}")

    return _emit(lines)

def _emit(lines):

    text = "\n".join(["=== SaveUtils report ==="] + lines)

    # print() lands in the Python console, where whoever ran report() is looking

    print(text)

    return None

def force():

    """Re-run installation right now, then report. For use from the console."""

    install_safely()

    return report()

def _menu_entries(menubar):

    """[(action, menu, objectName, text)] for every live menu in the menu bar.

    FreeCAD tears menus down and rebuilds them on workbench switches, so the menu

    bar can hand back wrappers whose underlying C++ QMenu is already gone.

    Touching one of those raises RuntimeError rather than returning None.

    """

    entries = []

    for action in menubar.actions():

        try:

            menu = action.menu()

            if menu is None:

                continue

            entries.append(

                (

                    action,

                    menu,

                    menu.objectName().replace("&", "").strip().lower(),

                    action.text().replace("&", "").strip().lower(),

                )

            )

        except RuntimeError:

            continue

    return entries

def _find_file_menu(menubar):

    # Match on objectName first (most reliable), then on display text

    matches = [e for e in _menu_entries(menubar) if e[2] == "file" or e[3] == "file"]

    if not matches:

        return None

    # A rebuild can leave a detached File menu behind. Injecting into that one

    # succeeds silently and shows nothing, so prefer a menu the user can open.

    for action, menu, _, _ in matches:

        if action.isVisible() and _alive(menu):

            return menu

    menu = matches[0][1]

    return menu if _alive(menu) else None

_our_actions = []

def _add_items(file_menu):

    """Put the SaveUtils entries into `file_menu`. No-op if they are there."""

    global _our_actions

    existing = {act.text() for act in file_menu.actions()}

    if existing & _ITEM_TEXTS:

        return False

    # A rebuild can strip our items while leaving the separator we added, so

    # clear out whatever is left of the last injection before adding a new one.

    for act in _our_actions:

        try:

            file_menu.removeAction(act)

        except RuntimeError:

            pass

    _our_actions = []

    new_actions = []

    for text, tip, command in _ITEMS:

        action = QtGui.QAction(text, file_menu)

        action.setToolTip(tip)

        # Bind the command name per-iteration so every lambda keeps its own

        action.triggered.connect(

            lambda checked=False, cmd=command: FreeCADGui.runCommand(cmd)

        )

        new_actions.append(action)

    # Insert before the first separator

    insert_before = next((a for a in file_menu.actions() if a.isSeparator()), None)

    if insert_before:

        for action in new_actions:

            file_menu.insertAction(insert_before, action)

        new_actions.append(file_menu.insertSeparator(insert_before))

    else:

        new_actions.append(file_menu.addSeparator())

        for action in new_actions[:-1]:

            file_menu.addAction(action)

    _our_actions = [a for a in new_actions if a is not None]

    return True

def _is_file_menu(obj):

    """True if `obj` is a QMenu that FreeCAD built as the File menu."""

    try:

        # QMenu, not merely any QObject that happens to be named "file"

        if not hasattr(obj, "insertSeparator") or not hasattr(obj, "actions"):

            return False

        return obj.objectName().replace("&", "").strip().lower() == "file"

    except Exception:

        return False

class _MenuWatcher(QtCore.QObject):

    """Injects the entries whenever a File menu is about to be shown.

    FreeCAD destroys and recreates the File QMenu, which takes any aboutToShow

    connection — and every action we previously inserted — with it. Filtering

    Show events at application level catches whichever menu object exists at

    the moment it is displayed, so recreation stops mattering.

    """

    def eventFilter(self, obj, event):

        try:

            if event.type() == _SHOW_EVENT and _is_file_menu(obj):

                _add_items(obj)

        except Exception:

            pass

        # Never consume the event

        return False

try:

    _SHOW_EVENT = QtCore.QEvent.Type.Show

except AttributeError:  # older bindings expose the enum unscoped

    _SHOW_EVENT = QtCore.QEvent.Show

_watcher = None

def _install_watcher():

    """Install the app-wide Show filter once."""

    global _watcher

    if _watcher is not None:

        return

    # QCoreApplication lives in QtCore, so this works regardless of how the

    # PySide shim splits QtGui/QtWidgets across Qt versions.

    app = QtCore.QCoreApplication.instance()

    if app is None:

        return

    _watcher = _MenuWatcher()

    app.installEventFilter(_watcher)

    FreeCAD.Console.PrintLog("=== SaveUtils: menu watcher installed ===\n")

_hooked_menu = None

def _on_file_menu_about_to_show():

    """Re-add the entries just before the menu is displayed.

    FreeCAD's MenuManager rebuilds the File menu on workbench switches and drops

    any action it does not own, so a one-shot injection does not survive. Doing

    it here means the items are present whenever the menu is actually opened.

    """

    global _hooked_menu

    try:

        if _hooked_menu is not None:

            _add_items(_hooked_menu)

    except RuntimeError:

        _hooked_menu = None

def _inject_menu():

    global _hooked_menu

    # Works even if the File menu below is never found or is later replaced

    _install_watcher()

    mw = FreeCADGui.getMainWindow()

    if mw is None:

        FreeCAD.Console.PrintError("=== SaveUtils: main window not found ===\n")

        return

    menubar = mw.menuBar()

    file_menu = _find_file_menu(menubar)

    if file_menu is None:

        FreeCAD.Console.PrintError("=== SaveUtils: File menu not found ===\n")

        found = [(e[3], e[2]) for e in _menu_entries(menubar)]

        FreeCAD.Console.PrintMessage(f"=== SaveUtils: menus found: {found} ===\n")

        return

    try:

        if _hooked_menu is not file_menu:

            file_menu.aboutToShow.connect(_on_file_menu_about_to_show)

            _hooked_menu = file_menu

        added = _add_items(file_menu)

    except RuntimeError as exc:

        # File menu was destroyed underneath us mid-rebuild; the next workbench

        # activation will inject into the replacement.

        FreeCAD.Console.PrintLog(f"=== SaveUtils: menu went away ({exc}) ===\n")

        _hooked_menu = None

        return

    FreeCAD.Console.PrintLog(

        "=== SaveUtils: menu items injected ===\n"

        if added

        else "=== SaveUtils: already installed, skipping ===\n"

    )