# coding: utf-8
# python 2 only

# Copyright (c) 2026 TormachTips.com. All rights reserved.
# Licensed under the TormachTips Personal Use License.
# Permission is granted only for private personal use and private personal modification.
# No sharing, publication, distribution, resale, sublicensing, screenshots, code excerpts,
# benchmarks, or videos are permitted without prior written permission.
# Requests:         tormach.1100m@gmail.com
# Information page: https://tormachtips.com/plugins.htm

###################################################
##                                               ##
##     Persistent Status Window F1 Key 0.96      ##
##             www.tormachtips.com               ##
##                                               ##
###################################################

# 0.96 - Added shared file lock, chronological backups, atomic writes, executable-bit restore, and verbose patch debug logging. - 5/02/2026
# 0.95 - Public beta. - 2/02/2026

import os
import re
import time
import fcntl
import shutil
import stat
import gtk
import glib
import constants
from ui_hooks import plugin, version_list

CURRENT_VER                  = "0.96"
SCRIPT_NAME                  = "Persistent F1 Status Key"
DESCRIPTION                  = "Forces PathPilot to stay on the Status page when F1 is pressed instead of returning when F1 is released."
ENABLED                      = 1
DEV_MACHINE                  = 0
DEV_MACHINE_FLAG             = "/home/operator/gcode/python/dev_machine.txt"
TARGET_FILE                  = os.path.join("python", "tormach_mill_ui.py")
MARKER                       = "# BEAGLE: PERSISTENT F1 STATUS PAGE PATCH INSTALLED"
PATCH_START                  = "# BEAGLE: PERSISTENT F1 STATUS PAGE PATCH START"
PATCH_NOTE                   = "# BEAGLE: ORIGINAL F1 RELEASE RETURN LINE DISABLED"
PATCH_END                    = "# BEAGLE: PERSISTENT F1 STATUS PAGE PATCH END"
PATCH_LOCK_PATH              = "/tmp/tt_pathpilot_file_patch.lock"
PATCH_LOCK_TIMEOUT_SECONDS   = 10
TARGET_LINE                  = "ui_misc.set_current_notebook_page_by_id(self.notebook, self.prev_notebook_page_id)"

class TTFilePatchLock(object):
    def __init__(self, owner, error_handler, lock_path, timeout_seconds):
        self.owner = owner
        self.error_handler = error_handler
        self.lock_path = lock_path
        self.timeout_seconds = timeout_seconds
        self.fp = None

    def write(self, message):
        try:
            self.error_handler.write("[%s] %s" % (self.owner, message), constants.ALARM_LEVEL_QUIET)
        except:
            pass

    def __enter__(self):
        start_time = time.time()
        self.write("Opening patch lock file: %s" % self.lock_path)
        self.fp = open(self.lock_path, "a+")
        self.write("Waiting for patch lock: %s" % self.lock_path)
        while True:
            try:
                fcntl.flock(self.fp.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
                self.write("Patch lock acquired: %s" % self.lock_path)
                return self
            except IOError:
                elapsed = time.time() - start_time
                if elapsed >= self.timeout_seconds:
                    self.write("Patch lock timeout after %.1f seconds: %s" % (elapsed, self.lock_path))
                    raise RuntimeError("Timed out waiting for patch lock: %s" % self.lock_path)
                time.sleep(0.1)

    def __exit__(self, exc_type, exc_value, traceback_obj):
        try:
            if self.fp:
                self.write("Releasing patch lock: %s" % self.lock_path)
                fcntl.flock(self.fp.fileno(), fcntl.LOCK_UN)
                self.write("Patch lock released: %s" % self.lock_path)
        finally:
            try:
                if self.fp:
                    self.fp.close()
                    self.write("Closed patch lock file: %s" % self.lock_path)
            except:
                pass
        return False

class UserPlugin(plugin):
    def __init__(self):
        plugin.__init__(self, '%s %s' % (SCRIPT_NAME, CURRENT_VER))
        dev_machine_found = os.path.exists(DEV_MACHINE_FLAG)
        if dev_machine_found:
            plugin_enabled = DEV_MACHINE
        else:
            plugin_enabled = ENABLED
        if plugin_enabled:
            glib.timeout_add(3000, self.try_patch)
            return
        if dev_machine_found:
            self.error_handler.write("[%s] Dev machine found. Plugin loaded, but disabled by DEV_MACHINE." % SCRIPT_NAME, constants.ALARM_LEVEL_QUIET)
        else:
            self.error_handler.write("[%s] Plugin loaded, but disabled." % SCRIPT_NAME, constants.ALARM_LEVEL_QUIET)
            self.error_handler.write("[%s] To enable, open script, find ENABLED = 0 and change to ENABLED = 1." % SCRIPT_NAME, constants.ALARM_LEVEL_QUIET)

    def debug(self, message):
        self.error_handler.write("[%s] %s" % (SCRIPT_NAME, message), constants.ALARM_LEVEL_QUIET)

    def show_nonblocking_dialog(self):
        dialog = gtk.MessageDialog(
            None,
            gtk.DIALOG_DESTROY_WITH_PARENT,
            gtk.MESSAGE_INFO,
            gtk.BUTTONS_OK,
            "Persistent F1 Status page patch successfully applied.\n\n"
            "Please reboot or restart PathPilot for the change to take effect.")
        dialog.set_title(SCRIPT_NAME)
        dialog.set_keep_above(True)
        dialog.set_modal(False)

        def on_response(widget, response_id):
            widget.destroy()
        dialog.connect("response", on_response)
        dialog.show_all()

    def safe_script_name(self):
        safe_name = SCRIPT_NAME.lower()
        safe_name = safe_name.replace(" ", "_")
        safe_name = re.sub(r"[^a-z0-9_]+", "_", safe_name)
        return safe_name

    def get_target_path(self):
        version_path = "v%d.%d.%d" % (version_list[0], version_list[1], version_list[2])
        version_root = os.path.join("/home/operator", version_path)
        return os.path.join(version_root, TARGET_FILE)

    def read_file(self, path):
        self.debug("Reading file: %s" % path)
        with open(path, "r") as f:
            content = f.read()
        self.debug("Read %d bytes from file: %s" % (len(content), path))
        return content

    def make_chronological_backup(self, target_path):
        timestamp = time.strftime("%Y%m%d_%H%M%S")
        safe_name = self.safe_script_name()
        backup_path = "%s.%s.%s.bak" % (target_path, timestamp, safe_name)
        counter = 1
        final_path = backup_path
        while os.path.exists(final_path):
            final_path = "%s.%03d" % (backup_path, counter)
            counter += 1
        self.debug("Creating chronological backup.")
        self.debug("Backup source: %s" % target_path)
        self.debug("Backup target: %s" % final_path)
        shutil.copy2(target_path, final_path)
        self.debug("Backup complete: %s" % final_path)
        return final_path

    def chmod_executable(self, target_path):
        current_mode = os.stat(target_path).st_mode
        executable_mode = current_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH
        self.debug("Restoring executable bit.")
        self.debug("chmod target: %s" % target_path)
        self.debug("chmod mode before: %o" % current_mode)
        self.debug("chmod mode after: %o" % executable_mode)
        os.chmod(target_path, executable_mode)
        if not os.access(target_path, os.X_OK):
            raise RuntimeError("File is not executable after chmod: %s" % target_path)
        self.debug("Executable permission confirmed: %s" % target_path)

    def atomic_write_file(self, target_path, content):
        original_stat = os.stat(target_path)
        temp_path = "%s.%s.%d.tmp" % (
            target_path,
            self.safe_script_name(),
            os.getpid())
        self.debug("Writing temporary patched file: %s" % temp_path)
        with open(temp_path, "w") as f:
            f.write(content)
        self.debug("Temporary patched file written: %s" % temp_path)
        try:
            os.chmod(temp_path, original_stat.st_mode)
            self.debug("Copied original file mode to temporary file: %o" % original_stat.st_mode)
        except Exception as e:
            self.debug("Could not copy original mode to temporary file: %s" % str(e))
        try:
            os.chown(temp_path, original_stat.st_uid, original_stat.st_gid)
            self.debug("Copied original owner/group to temporary file.")
        except Exception as e:
            self.debug("Could not copy original owner/group to temporary file: %s" % str(e))
        self.debug("Renaming temporary file over target.")
        self.debug("Rename source: %s" % temp_path)
        self.debug("Rename target: %s" % target_path)
        os.rename(temp_path, target_path)
        self.debug("Atomic rename complete: %s" % target_path)
        self.chmod_executable(target_path)

    def validate_python_content(self, target_path, content):
        try:
            compile(content, target_path, "exec")
            self.debug("Python syntax validation passed: %s" % target_path)
        except Exception as e:
            raise RuntimeError("Patched file failed Python syntax validation: %s" % str(e))

    def patch_content(self, content):
        if MARKER in content:
            self.debug("Patch marker already present.")
            return content, False
        lines = content.splitlines(True)
        out = []
        patched = False
        for line in lines:
            if not patched and TARGET_LINE in line and not line.strip().startswith("#"):
                indent = line[:len(line) - len(line.lstrip())]
                original_line = line[len(indent):].rstrip("\n")
                self.debug("Target F1 release return line found.")
                out.append(indent + MARKER + "\n")
                out.append(indent + PATCH_START + "\n")
                out.append(indent + PATCH_NOTE + "\n")
                out.append(indent + "# " + original_line + "\n")
                out.append(indent + PATCH_END + "\n")
                patched = True
            else:
                out.append(line)
        if not patched:
            raise RuntimeError("Target F1 release return line not found. Patch skipped.")
        patched_content = "".join(out)
        if patched_content == content:
            raise RuntimeError("Patch produced no content changes.")
        return patched_content, True

    def try_patch(self):
        backup_path = ""
        try:
            target_path = self.get_target_path()
            self.debug("Target file: %s" % target_path)
            self.debug("Patch marker: %s" % MARKER)
            self.debug("Target line: %s" % TARGET_LINE)
            with TTFilePatchLock(SCRIPT_NAME, self.error_handler, PATCH_LOCK_PATH, PATCH_LOCK_TIMEOUT_SECONDS):
                self.debug("Inside locked patch section.")
                if not os.path.exists(target_path):
                    self.error_handler.write("[%s] File not found: %s" % (SCRIPT_NAME, target_path), constants.ALARM_LEVEL_LOW)
                    return False
                content = self.read_file(target_path)
                patched_content, changed = self.patch_content(content)
                if not changed:
                    self.error_handler.write("[%s] Already patched. No changes made." % SCRIPT_NAME, constants.ALARM_LEVEL_QUIET)
                    self.debug("Marker found; exiting without backup or write.")
                    if not os.access(target_path, os.X_OK):
                        self.debug("Patch marker exists, but file is not executable. Restoring executable bit.")
                        self.chmod_executable(target_path)
                    return False
                self.validate_python_content(target_path, patched_content)
                self.debug("Patch content generated.")
                self.debug("Original byte count: %d" % len(content))
                self.debug("Patched byte count: %d" % len(patched_content))
                backup_path = self.make_chronological_backup(target_path)
                self.atomic_write_file(target_path, patched_content)
                self.debug("Leaving locked patch section after successful write.")
            self.error_handler.write(" ", constants.ALARM_LEVEL_QUIET)
            self.error_handler.write("[%s] Patch applied to: %s" % (SCRIPT_NAME, target_path), constants.ALARM_LEVEL_MEDIUM)
            self.error_handler.write("[%s] Backup created: %s" % (SCRIPT_NAME, backup_path), constants.ALARM_LEVEL_MEDIUM)
            self.error_handler.write("[%s] Executable permission confirmed on patched file." % SCRIPT_NAME, constants.ALARM_LEVEL_MEDIUM)
            self.error_handler.write("[%s] Please reboot or restart PathPilot." % SCRIPT_NAME, constants.ALARM_LEVEL_MEDIUM)
            self.error_handler.write(" ", constants.ALARM_LEVEL_QUIET)
            glib.idle_add(self.show_nonblocking_dialog)
        except Exception as e:
            self.error_handler.write("[%s] Error: %s" % (SCRIPT_NAME, str(e)), constants.ALARM_LEVEL_LOW)
        return False

DESCRIPTION_LONG = """<font face=verdana size=2>PathPilot 
    normally uses the F1 key as a shortcut to show the Status Window.<br>
    However, this view is *temporary* — the moment you release F1, the UI 
    snaps<br>
    back to the previous screen. This plugin disables that automatic return,<br>
    letting the Status Window stay visible until you choose to leave it."""