# 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

#############################################
##                                         ##
##   Open Plugins In Editor Patcher 0.96   ##
##          www.tormachtips.com            ##
##                                         ##
#############################################

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

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

CURRENT_VER                  = "0.96"
SCRIPT_NAME                  = "Open Plugins In Editor Patcher"
DESCRIPTION                  = "Patches PathPilot so files under /home/operator/gcode/python open in the editor instead of being loaded as G-code."
ENABLED                      = 1
DEV_MACHINE                  = 0
DEV_MACHINE_FLAG             = "/home/operator/gcode/python/dev_machine.txt"
MARKER                       = "# BEAGLE: OPEN PLUGINS IN GEDIT PATCH INSTALLED"
PATCH_LOCK_PATH              = "/tmp/tt_pathpilot_file_patch.lock"
TARGET_REL_PATH              = os.path.join("python", "ui_common.py")
PATCH_LOCK_TIMEOUT_SECONDS   = 30.0

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 is disabled." % SCRIPT_NAME, constants.ALARM_LEVEL_QUIET)
            self.error_handler.write("[%s] To enable it, open the script, find ENABLED = 0, and change it 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_success_dialog(self):
        dialog = gtk.MessageDialog(
            None,
            gtk.DIALOG_DESTROY_WITH_PARENT,
            gtk.MESSAGE_INFO,
            gtk.BUTTONS_OK,
            "Plugin/script editor 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 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 atomic_write_file(self, target_path, content):
        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)
        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)

    def patch_content(self, content):
        original_content = content
        logfile_block_pattern = re.compile(
            r'(?P<indent>^[ \t]*)elif path\.find\([\'"]/gcode/logfiles/[\'"]\) != -1:[^\n]*\n'
            r'(?P=indent)[ \t]*self\.error_handler\.write\([\'"]file exists in logfiles path %s[\'"] % path, ALARM_LEVEL_DEBUG\)\n'
            r'(?P=indent)[ \t]*subprocess\.Popen\(\[[\'"]editscript[\'"], path\]\)',
            re.MULTILINE)

        def replace_logfile_block(match):
            indent = match.group('indent')
            original_block = match.group(0)
            injected_block = (
                indent + MARKER + "\n" +
                indent + "# BEAGLE: OPEN PLUGINS IN GEDIT PATCH START\n" +
                indent + "elif path.startswith('/home/operator/gcode/python/') and os.path.isfile(path):\n" +
                indent + "    self.error_handler.write(\"Assuming %s is a plugin; opening in editor.\" % path, ALARM_LEVEL_QUIET)\n" +
                indent + "    subprocess.Popen(['editscript', path])\n" +
                indent + "# BEAGLE: OPEN PLUGINS IN GEDIT PATCH END"
                )
            return injected_block + "\n\n" + original_block
        
        self.debug("Searching for logfile editor OEM block.")
        content, count = logfile_block_pattern.subn(replace_logfile_block, content, count=1)
        self.debug("Logfile editor replacement count: %d" % count)
        if count < 1:
            raise RuntimeError("Target logfile editor block not found. Patch skipped.")
        if content == original_content:
            raise RuntimeError("Patch produced no content changes.")
        return content

    def try_patch(self):
        backup_path = ""
        try:
            version_path = "v%d.%d.%d" % (version_list[0], version_list[1], version_list[2])
            target_path = os.path.join("/home/operator", version_path, TARGET_REL_PATH)
            self.debug("Resolved PathPilot version path: %s" % version_path)
            self.debug("Target file: %s" % target_path)
            self.debug("Patch marker: %s" % MARKER)
            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
                self.debug("Reading target file: %s" % target_path)
                with open(target_path, "r") as f:
                    content = f.read()
                self.debug("Read %d bytes from target file." % len(content))
                if MARKER in content:
                    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.")
                    return False
                self.debug("Marker not found; patch will be attempted.")
                patched_content = self.patch_content(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] Please reboot or restart PathPilot." % SCRIPT_NAME, constants.ALARM_LEVEL_MEDIUM)
            self.error_handler.write(" ", constants.ALARM_LEVEL_QUIET)
            glib.idle_add(self.show_success_dialog)
        except Exception as e:
            self.error_handler.write("[%s] Error: %s" % (SCRIPT_NAME, str(e)), constants.ALARM_LEVEL_LOW)
        return False

DESCRIPTION_LONG = """In PathPilot's file tab, certain file types 
    open in their respective viewers. PDFs open in a PDF viewer. Images open in 
    an image viewer. Log files open in the text editor.</font></p>
    <p><font face="Verdana" size="2">This script forces anything clicked on from 
    /home/operator/gcode/python to open in the text editor instead of as an NC 
    file (which they never are).</font></p>
        <p><font face="Verdana" size="2"><a href="plugins/output.htm">"""