Tinta4Plus.py

#!/usr/bin/env python3
"""
Copyright (c) 2025 Jon Cox (joncox123). All rights reserved.

WARNING: This software is provided "AS IS", without any warranty of any kind. It may contain bugs or other defects
that result in data loss, corruption, hardware damage or other issues. Use at your own risk.
It may temporarily or permanently render your hardware inoperable.
It may corrupt or damage the Embedded Controller or eInk T-CON controller in your laptop.
The author is not responsible for any damage, data loss or lost productivity caused by use of this software. 
By downloading and using this software you agree to these terms and acknowledge the risks involved.
"""

"""
ThinkBook Plus Gen 4 IRU E-Ink Control GUI (tkinter version)
Unprivileged GUI that communicates with privileged helper daemon

No root/sudo required for this GUI
Communicates via Unix socket with helper daemon
"""

import tkinter as tk
from tkinter import ttk, scrolledtext, messagebox
import subprocess
import sys
import os
import time
import threading
import logging
import random
import webbrowser
import json
from datetime import datetime

try:
    import sv_ttk
    HAS_SV_TTK = True
except ImportError:
    HAS_SV_TTK = False

from HelperClient import HelperClient
from DisplayManager import DisplayManager
from ThemeManager import ThemeManager
from ResumeCheck import ResumeCheck

class FloatingRefreshButton:
    """Floating refresh button window that stays on top"""

    def __init__(self, parent, on_refresh_callback, logger):
        """Initialize the floating refresh button

        Args:
            parent: Parent tkinter window
            on_refresh_callback: Function to call when button is pressed
            logger: Logger instance
        """
        self.parent = parent
        self.on_refresh_callback = on_refresh_callback
        self.logger = logger

        # Drag state
        self._drag_start_x = 0
        self._drag_start_y = 0
        self._is_dragging = False

        # Create a new top-level window
        self.window = tk.Toplevel(parent)
        self.window.title("")  # Empty title

        # Remove window decorations (titlebar, close button, etc.)
        self.window.overrideredirect(True)

        # Set size to 75x75
        self.window.geometry("75x75")

        # Make window always stay on top
        self.window.attributes('-topmost', True)

        # Make window semi-transparent (0.5 = 50% opacity)
        self.window.attributes('-alpha', 0.5)

        # Position window on left side, halfway down
        # Get screen height to calculate vertical center
        screen_height = self.window.winfo_screenheight()
        y_position = (screen_height // 2) - 37  # Center the 75px button
        x_position = 0  # Left edge of screen

        self.window.geometry(f"75x75+{x_position}+{y_position}")

        # Set window background to light blue
        self.window.config(bg='lightblue')

        # Create the refresh button that fills the entire window
        # Using a unicode circular arrow character as refresh icon
        # Note: highlightthickness=0 removes focus border, bd=0 removes button border
        self.button = tk.Button(
            self.window,
            text="⟳",  # Circular arrow refresh symbol
            font=('TkDefaultFont', 54),  # Scaled down from 72 to fit 75x75
            command=self._on_click,
            relief=tk.FLAT,
            bd=0,
            bg='lightblue',
            activebackground='skyblue',
            highlightthickness=0
        )
        self.button.pack(fill=tk.BOTH, expand=True)

        # Bind hover effects
        self.button.bind("<Enter>", self._on_hover_enter)
        self.button.bind("<Leave>", self._on_hover_leave)

        # Bind drag events
        self.button.bind("<ButtonPress-1>", self._on_drag_start)
        self.button.bind("<B1-Motion>", self._on_drag_motion)
        self.button.bind("<ButtonRelease-1>", self._on_drag_release)

        self.logger.info("Floating refresh button created")

    def _on_click(self):
        """Handle button click (only if not dragging)"""
        if not self._is_dragging:
            self.logger.info("Floating refresh button clicked")
            if self.on_refresh_callback:
                self.on_refresh_callback()

    def _on_drag_start(self, event):
        """Handle start of drag operation"""
        self._drag_start_x = event.x
        self._drag_start_y = event.y
        self._is_dragging = False

    def _on_drag_motion(self, event):
        """Handle drag motion"""
        # Calculate distance moved
        dx = event.x - self._drag_start_x
        dy = event.y - self._drag_start_y

        # If moved more than a few pixels, consider it a drag (not a click)
        if abs(dx) > 3 or abs(dy) > 3:
            self._is_dragging = True

            # Get current window position
            x = self.window.winfo_x() + dx
            y = self.window.winfo_y() + dy

            # Move the window
            self.window.geometry(f"+{x}+{y}")

    def _on_drag_release(self, _event):
        """Handle end of drag operation"""
        # Reset drag flag after a short delay to prevent click from firing
        self.window.after(100, self._reset_drag_flag)

    def _reset_drag_flag(self):
        """Reset the dragging flag"""
        self._is_dragging = False

    def _on_hover_enter(self, event):
        """Handle mouse hover enter"""
        self.button.config(bg='skyblue')
        self.window.config(bg='skyblue')

    def _on_hover_leave(self, event):
        """Handle mouse hover leave"""
        self.button.config(bg='lightblue')
        self.window.config(bg='lightblue')

    def destroy(self):
        """Destroy the floating button window"""
        self.logger.info("Destroying floating refresh button")
        if self.window:
            self.window.destroy()
            self.window = None


class EInkControlGUI:
    # Version
    VERSION = "0.1.0 alpha"

    # Configuration
    SOCKET_PATH = '/tmp/tinta4plusu.sock'
    KEEPALIVE_INTERVAL = 5.0  # seconds (send keepalive every 5s, watchdog is 60s)
    SOCKET_TIMEOUT = 10.0  # seconds
    CONFIG_DIR = os.path.expanduser("~/.config/Tinta4PlusU")
    SETTINGS_FILE = os.path.join(os.path.expanduser("~/.config/Tinta4PlusU"), "settings")

    # Display names (ThinkBook Plus Gen 4 has eDP-1=OLED, eDP-2=E-Ink)
    DISPLAY_OLED = "eDP-1"
    DISPLAY_EINK = "eDP-2"

    # E-Ink privacy images (one picked at random when disabling E-Ink)
    # NOTE: must install feh and imv for this to work!
    EINK_DISABLED_IMAGES = [
        "eink-disable.jpg",
    ]

    # XFCE theme names
    THEME_HIGH_CONTRAST = "HighContrast"
    THEME_ADWAITA_DARK = "Adwaita-dark"

    """Main GUI application using tkinter"""

    def __init__(self, root, HELPER_SCRIPT, logger, autostart=False):
        self.HELPER_SCRIPT = HELPER_SCRIPT
        self.logger = logger
        self.root = root
        self.root.title("ThinkBook E-Ink Control")
        # Fit the window to available screen height so the title bar and
        # close button are always reachable, even on GNOME with its top
        # bar eating vertical space on scaled displays.
        screen_h = self.root.winfo_screenheight()
        # Reserve generous space for GNOME top bar + window decorations
        # so the title bar (close/minimize/maximize) is never clipped.
        win_h = min(650, screen_h - 120)
        self.root.geometry(f"600x{win_h}+50+50")
        self.root.minsize(400, 400)

        # Helper client
        self.helper = HelperClient(logger)
        self.keepalive_after_id = None
        self._keepalive_thread = None
        self._keepalive_stop = threading.Event()
        self.helper_process = None

        # Managers
        self.display_mgr = DisplayManager(logger)
        self.theme_mgr = ThemeManager(logger)

        # Log detected session info
        self.logger.info(f"Session: {self.display_mgr.session_type}, Desktop: {self.display_mgr.desktop_env}")

        # Brightness timer for debouncing
        self.brightness_timer = None

        # Periodic refresh timer
        self.refresh_timer = None

        # Image viewer process for E-Ink privacy screen
        self.eink_image_process = None

        # Floating refresh button
        self.floating_refresh_button = None

        # Saved OLED scale to restore when switching back from eInk
        self.saved_oled_scale = None

        # Sleep inhibitor file descriptor (systemd-inhibit)
        self._sleep_inhibit_fd = None

        # Saved keyboard layout (restored after eInk toggle and resume)
        self.saved_keyboard_layout = None

        # Resume monitor thread
        self._resume_monitor_thread = None
        self._resume_monitor_stop = threading.Event()

        # Load settings from file (or use defaults)
        settings = self.load_settings()

        # Display scaling (from settings)
        self.display_scale = settings['display_scale']

        # Build UI
        self.build_ui()

        # Apply loaded settings to UI controls after they're created
        self.scale_var.set(self.display_scale)
        self.scale_label.config(text=f"{self.display_scale:.2f}")
        self.refresh_period_var.set(settings['refresh_period'])
        self.refresh_period_label.config(text=str(settings['refresh_period']))
        self.autoswitch_theme_var.set(settings['autoswitch_theme'])
        self.flip_countdown = settings['flip_countdown']
        self._countdown_active = False

        # Set up window close handler
        self.root.protocol("WM_DELETE_WINDOW", self.on_closing)

        # Save the initial keyboard layout so we can restore it after resume
        self.saved_keyboard_layout = self.display_mgr.get_keyboard_layout()
        if self.saved_keyboard_layout:
            self.logger.info(f"Saved initial keyboard layout: {self.saved_keyboard_layout}")

        # Start monitoring for system resume (lid open / wake from suspend)
        self._start_resume_monitor()

        # Run startup display/input validation after a short delay
        # (gives the display subsystem time to settle after login)
        self.root.after(3000, self._run_startup_check)

        if autostart:
            # Autostart mode: don't launch helper immediately (avoids password prompt at login)
            self.update_status("Click 'Connect to Helper' to start")
            self.log_message("Autostart mode — helper not launched automatically")
            self._check_secure_boot_local()
        else:
            # Normal launch: connect to helper after short delay
            self.root.after(500, self.initialize_helper)

    def load_settings(self):
        """Load settings from configuration file"""
        # Default settings
        defaults = {
            'display_scale': 1.0,
            'refresh_period': 0,
            'autoswitch_theme': False,
            'flip_countdown': 5
        }

        if not os.path.exists(self.SETTINGS_FILE):
            self.logger.info(f"Settings file not found, using defaults")
            return defaults

        try:
            with open(self.SETTINGS_FILE, 'r') as f:
                settings = json.load(f)
            self.logger.info(f"Loaded settings from {self.SETTINGS_FILE}")

            # Merge with defaults to handle missing keys
            for key in defaults:
                if key not in settings:
                    settings[key] = defaults[key]

            return settings

        except Exception as e:
            self.logger.error(f"Failed to load settings: {e}")
            return defaults

    def save_settings(self):
        """Save current settings to configuration file"""
        try:
            # Ensure config directory exists
            os.makedirs(self.CONFIG_DIR, exist_ok=True)

            # Gather current settings
            settings = {
                'display_scale': self.display_scale,
                'refresh_period': self.refresh_period_var.get(),
                'autoswitch_theme': self.autoswitch_theme_var.get(),
                'flip_countdown': self.flip_countdown
            }

            # Write to file
            with open(self.SETTINGS_FILE, 'w') as f:
                json.dump(settings, f, indent=2)

            self.logger.info(f"Saved settings to {self.SETTINGS_FILE}")

        except Exception as e:
            self.logger.error(f"Failed to save settings: {e}")

    def _inhibit_sleep(self):
        """Acquire a sleep/suspend inhibitor via systemd-logind D-Bus.

        This prevents the system from suspending while display switching is
        in progress.  The inhibitor is released by calling _uninhibit_sleep().
        """
        if self._sleep_inhibit_fd is not None:
            return  # already held

        try:
            import dbus
            bus = dbus.SystemBus()
            proxy = bus.get_object('org.freedesktop.login1',
                                   '/org/freedesktop/login1')
            mgr = dbus.Interface(proxy, 'org.freedesktop.login1.Manager')
            fd = mgr.Inhibit(
                'sleep',                       # what
                'Tinta4PlusU',                 # who
                'Switching displays',          # why
                'block',                       # mode
            )
            # fd is a dbus.UnixFd; take ownership of the underlying file descriptor
            self._sleep_inhibit_fd = fd.take()
            self.logger.info("Acquired sleep inhibitor")
        except Exception as e:
            self.logger.warning(f"Could not acquire sleep inhibitor: {e}")

    def _uninhibit_sleep(self):
        """Release the sleep/suspend inhibitor."""
        if self._sleep_inhibit_fd is not None:
            try:
                os.close(self._sleep_inhibit_fd)
                self.logger.info("Released sleep inhibitor")
            except OSError as e:
                self.logger.warning(f"Error releasing sleep inhibitor: {e}")
            self._sleep_inhibit_fd = None

    def build_ui(self):
        """Build the tkinter user interface"""

        # Configure style
        if HAS_SV_TTK:
            sv_ttk.set_theme("dark")
        else:
            style = ttk.Style()
            style.theme_use('clam')

        # Main frame with padding
        main_frame = ttk.Frame(self.root, padding="10")
        main_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
        
        # Configure grid weights
        self.root.columnconfigure(0, weight=1)
        self.root.rowconfigure(0, weight=1)
        main_frame.columnconfigure(0, weight=1)
        
        row = 0

        # Status bar
        self.status_var = tk.StringVar(value="Status: Initializing...")
        status_label = ttk.Label(main_frame, textvariable=self.status_var, relief=tk.SUNKEN, anchor=tk.W)
        status_label.grid(row=row, column=0, sticky=(tk.W, tk.E), pady=(0, 5))
        row += 1

        # Status row: Secure Boot indicator + Connect button
        status_row_frame = ttk.Frame(main_frame)
        status_row_frame.grid(row=row, column=0, sticky=(tk.W, tk.E), pady=(0, 10))

        self.secureboot_frame = tk.Frame(status_row_frame, bg='gray', relief=tk.RIDGE, bd=2)
        self.secureboot_frame.pack(side=tk.LEFT)

        self.secureboot_label = tk.Label(self.secureboot_frame, text="Secure Boot: Unknown",
                                         bg='gray', fg='white', font=('TkDefaultFont', 9, 'bold'),
                                         padx=10, pady=3)
        self.secureboot_label.pack()

        self.connect_btn = ttk.Button(status_row_frame, text="Connect to Helper",
                                       command=self.initialize_helper)
        self.connect_btn.pack(side=tk.RIGHT, padx=(10, 0))
        row += 1
        
        # === Display Control Section ===
        display_frame = ttk.LabelFrame(main_frame, text="Display Control", padding="10")
        display_frame.grid(row=row, column=0, sticky=(tk.W, tk.E), pady=5)
        display_frame.columnconfigure(0, weight=1)
        display_frame.columnconfigure(1, weight=1)
        row += 1
        
        # E-Ink toggle control
        eink_toggle_frame = ttk.Frame(display_frame)
        eink_toggle_frame.grid(row=0, column=0, columnspan=2, padx=5, pady=5, sticky=(tk.W, tk.E))

        self.eink_enabled_var = tk.BooleanVar(value=False)
        self.eink_toggle_btn = tk.Button(eink_toggle_frame, text="eInk Disabled",
                                         bg="#FF8C00", fg="white",
                                         font=('TkDefaultFont', 10, 'bold'),
                                         relief=tk.RAISED, bd=3,
                                         command=self.on_eink_toggled,
                                         activebackground="#CC7000",  # Darker orange
                                         activeforeground="black",
                                         padx=20, pady=10)
        self.eink_toggle_btn.pack(expand=True, fill=tk.X)

        # Bind hover effects for eInk toggle button
        self.eink_toggle_btn.bind("<Enter>", lambda e: self._on_eink_btn_hover(e, True))
        self.eink_toggle_btn.bind("<Leave>", lambda e: self._on_eink_btn_hover(e, False))

        # Refresh button
        self.btn_refresh = ttk.Button(display_frame, text="Refresh eInk (Clear Ghosts)",
                                      command=self.on_refresh_full,
                                      state='disabled')
        self.btn_refresh.grid(row=1, column=0, columnspan=2, padx=5, pady=5, sticky=(tk.W, tk.E))

        # Mode buttons (Dynamic and Reading)
        mode_frame = ttk.Frame(display_frame)
        mode_frame.grid(row=2, column=0, columnspan=2, padx=5, pady=5, sticky=(tk.W, tk.E))
        mode_frame.columnconfigure(0, weight=1)
        mode_frame.columnconfigure(1, weight=1)

        self.btn_set_dynamic = ttk.Button(mode_frame, text="Set Dynamic",
                                          command=self.on_set_dynamic,
                                          state='disabled')
        self.btn_set_dynamic.grid(row=0, column=0, padx=(0, 2), sticky=(tk.W, tk.E))

        self.btn_set_reading = ttk.Button(mode_frame, text="Set Reading",
                                          command=self.on_set_reading,
                                          state='disabled')
        self.btn_set_reading.grid(row=0, column=1, padx=(2, 0), sticky=(tk.W, tk.E))

        # Refresh period slider
        refresh_period_label = ttk.Label(display_frame, text="Refresh period (s):")
        refresh_period_label.grid(row=3, column=0, sticky=tk.W, padx=5, pady=5)

        refresh_period_container = ttk.Frame(display_frame)
        refresh_period_container.grid(row=3, column=1, sticky=(tk.W, tk.E), padx=5, pady=5)
        refresh_period_container.columnconfigure(0, weight=1)

        self.refresh_period_var = tk.IntVar(value=0)
        self.refresh_period_slider = ttk.Scale(refresh_period_container, from_=0, to=60,
                                              orient=tk.HORIZONTAL,
                                              variable=self.refresh_period_var,
                                              command=self.on_refresh_period_changed)
        self.refresh_period_slider.grid(row=0, column=0, sticky=(tk.W, tk.E))

        self.refresh_period_label = ttk.Label(refresh_period_container, text="0")
        self.refresh_period_label.grid(row=0, column=1, padx=(5, 0))

        # Display scale slider
        scale_label = ttk.Label(display_frame, text="Display Scale:")
        scale_label.grid(row=4, column=0, sticky=tk.W, padx=5, pady=5)

        scale_container = ttk.Frame(display_frame)
        scale_container.grid(row=4, column=1, sticky=(tk.W, tk.E), padx=5, pady=5)

        # Autoswitch theme checkbox
        self.autoswitch_theme_var = tk.BooleanVar(value=False)
        self.autoswitch_theme_checkbox = ttk.Checkbutton(
            display_frame,
            text="Autoswitch theme (HighContrast ↔ Adwaita-dark)",
            variable=self.autoswitch_theme_var,
            command=self.on_autoswitch_theme_changed
        )
        self.autoswitch_theme_checkbox.grid(row=5, column=0, columnspan=2, sticky=tk.W, padx=5, pady=5)
        scale_container.columnconfigure(0, weight=1)

        self.scale_var = tk.DoubleVar(value=1.75)
        self.scale_slider = ttk.Scale(scale_container, from_=1.0, to=2.0,
                                     orient=tk.HORIZONTAL,
                                     variable=self.scale_var,
                                     command=self.on_scale_changed)
        self.scale_slider.grid(row=0, column=0, sticky=(tk.W, tk.E))

        self.scale_label = ttk.Label(scale_container, text="1.75")
        self.scale_label.grid(row=0, column=1, padx=(5, 0))

        # === Frontlight Control Section ===
        frontlight_frame = ttk.LabelFrame(main_frame, text="Frontlight Control", padding="10")
        frontlight_frame.grid(row=row, column=0, sticky=(tk.W, tk.E), pady=5)
        frontlight_frame.columnconfigure(1, weight=1)
        row += 1

        # Brightness slider (frontlight auto-enables with eInk)
        ttk.Label(frontlight_frame, text="Brightness (0-8):").grid(row=0, column=0,
                                                                    sticky=tk.W, padx=5, pady=5)

        brightness_container = ttk.Frame(frontlight_frame)
        brightness_container.grid(row=0, column=1, sticky=(tk.W, tk.E), padx=5, pady=5)
        brightness_container.columnconfigure(0, weight=1)

        self.brightness_var = tk.IntVar(value=5)
        self.brightness_scale = ttk.Scale(brightness_container, from_=0, to=8,
                                         orient=tk.HORIZONTAL,
                                         variable=self.brightness_var,
                                         command=self.on_brightness_changed)
        self.brightness_scale.grid(row=0, column=0, sticky=(tk.W, tk.E))

        self.brightness_label = ttk.Label(brightness_container, text="5")
        self.brightness_label.grid(row=0, column=1, padx=(5, 0))

        # Warning label for Secure Boot (initially hidden)
        self.secure_boot_warning = ttk.Label(frontlight_frame,
                                             text="⚠ Secure Boot is enabled. Frontlight controls disabled.\nPlease disable Secure Boot in BIOS (Press ENTER during boot).",
                                             foreground='red', font=('TkDefaultFont', 9, 'bold'))
        # Don't grid it yet - will be shown if needed

        # === Activity Log Section ===
        log_frame = ttk.LabelFrame(main_frame, text="Activity Log", padding="10")
        log_frame.grid(row=row, column=0, sticky=(tk.W, tk.E, tk.N, tk.S), pady=5)
        log_frame.columnconfigure(0, weight=1)
        log_frame.rowconfigure(0, weight=1)
        main_frame.rowconfigure(row, weight=1)
        row += 1
        
        # Scrolled text widget
        log_kwargs = {'height': 12, 'wrap': tk.WORD, 'state': tk.DISABLED, 'font': ('Courier', 9)}
        if HAS_SV_TTK:
            log_kwargs.update({'bg': '#1c1c1c', 'fg': '#e0e0e0', 'insertbackground': '#e0e0e0'})
        self.log_text = scrolledtext.ScrolledText(log_frame, **log_kwargs)
        self.log_text.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))

        # Configure text tags for colored output
        if HAS_SV_TTK:
            self.log_text.tag_config('success', foreground='#57c785')
            self.log_text.tag_config('error', foreground='#ff6b6b')
            self.log_text.tag_config('info', foreground='#6bb3ff')
        else:
            self.log_text.tag_config('success', foreground='green')
            self.log_text.tag_config('error', foreground='red')
            self.log_text.tag_config('info', foreground='blue')

        # Version and Buy Me A Coffee button row
        version_coffee_frame = ttk.Frame(main_frame)
        version_coffee_frame.grid(row=row, column=0, sticky=(tk.W, tk.E), padx=10, pady=5)
        version_coffee_frame.columnconfigure(0, weight=1)  # Allow space to expand between elements

        # Version label (left side)
        version_label = ttk.Label(version_coffee_frame, text=f"Version {self.VERSION}",
                                 font=('TkDefaultFont', 8))
        version_label.grid(row=0, column=0, sticky=tk.W)

        # Buy Me A Coffee button (right side)
        self.coffee_btn = tk.Button(version_coffee_frame, text="Buy Me A Coffee",
                                   bg="#FF8C00", fg="white",
                                   font=('TkDefaultFont', 8),
                                   relief=tk.RAISED, bd=2,
                                   command=self.on_buy_coffee,
                                   activebackground="#CC7000",  # Darker orange
                                   activeforeground="white",
                                   padx=8, pady=4)
        self.coffee_btn.grid(row=0, column=1, sticky=tk.E)

        # Bind hover effects for coffee button
        self.coffee_btn.bind("<Enter>", lambda e: self.coffee_btn.config(bg="#CC7000"))
        self.coffee_btn.bind("<Leave>", lambda e: self.coffee_btn.config(bg="#FF8C00"))

        # Keyboard shortcuts
        self.root.bind_all('<Help>', lambda e: self.on_refresh_full() if self.eink_enabled_var.get() else None)

        # Map brightness keys to frontlight control when in eInk mode
        self.root.bind_all('<XF86MonBrightnessUp>', self._on_brightness_key_up)
        self.root.bind_all('<XF86MonBrightnessDown>', self._on_brightness_key_down)

        # Initial log message
        self.log_message("Application started")
    
    def log_message(self, message, level='info'):
        """Add a message to the log view and logger"""
        timestamp = datetime.now().strftime("%H:%M:%S")

        # Determine tag based on message content or level
        if '✓' in message or 'success' in message.lower():
            tag = 'success'
            logger_level = 'info'
        elif '✗' in message or 'error' in message.lower() or 'failed' in message.lower():
            tag = 'error'
            logger_level = 'error'
        else:
            tag = level
            logger_level = level

        log_line = f"[{timestamp}] {message}\n"

        # Insert into text widget
        self.log_text.config(state=tk.NORMAL)
        self.log_text.insert(tk.END, log_line, tag)
        self.log_text.see(tk.END)  # Auto-scroll
        self.log_text.config(state=tk.DISABLED)

        # Also log via logger
        if logger_level == 'error':
            self.logger.error(message)
        elif logger_level == 'warning':
            self.logger.warning(message)
        else:
            self.logger.info(message)
    
    def update_status(self, message, error=False):
        """Update status bar"""
        self.status_var.set(f"Status: {message}")
    
    def show_error_dialog(self, message):
        """Log error to activity log (non-blocking)"""
        self.log_message(f"ERROR: {message}", level='error')

    def show_info_dialog(self, message):
        """Log info to activity log (non-blocking)"""
        self.log_message(message)
    
    def initialize_helper(self):
        """Initialize connection to helper daemon"""
        self.connect_btn.config(state='disabled')

        # First try to connect to existing helper
        if os.path.exists(self.SOCKET_PATH):
            try:
                if self.helper.connect(self.SOCKET_PATH, timeout=self.SOCKET_TIMEOUT):
                    self.update_status("Connected to helper daemon")
                    self.log_message("Connected to existing helper daemon")
                    self.start_keepalive()
                    self.root.after(500, self.check_ec_status)
                    return
            except Exception as e:
                self.log_message(f"Failed to connect to existing socket: {e}")
                # Remove stale socket
                try:
                    os.remove(self.SOCKET_PATH)
                except:
                    pass

        # No existing helper, launch it
        self.log_message("Helper daemon not found, launching...")
        self.update_status("Launching helper daemon (password required)...")

        # Launch helper via pkexec in background
        threading.Thread(target=self._launch_helper_thread, daemon=True).start()
    
    def _launch_helper_thread(self):
        """Launch helper daemon in background thread"""
        try:
            helper_path = self.HELPER_SCRIPT

            if not os.path.exists(helper_path):
                self.root.after(0, self._helper_launch_failed, "Helper not found: " + helper_path)
                return

            # If helper is a compiled binary, run it directly via pkexec
            # If it's a .py script, invoke via python3
            if helper_path.endswith('.py'):
                cmd = ['pkexec', 'python3', helper_path]
            else:
                cmd = ['pkexec', helper_path]

            self.helper_process = subprocess.Popen(
                cmd,
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE
            )
            
            # Wait for helper to start (longer at login when polkit agent may not be ready)
            time.sleep(2.0)

            # Try to connect — up to 20 attempts (≈12s total after initial wait)
            max_attempts = 20
            for attempt in range(max_attempts):
                # Check if pkexec process died (user cancelled password, etc.)
                if self.helper_process.poll() is not None:
                    rc = self.helper_process.returncode
                    self.root.after(0, self._helper_launch_failed,
                                  f"Helper process exited (code {rc}) — password cancelled or pkexec failed")
                    return
                if os.path.exists(self.SOCKET_PATH):
                    if self.helper.connect(self.SOCKET_PATH, timeout=self.SOCKET_TIMEOUT):
                        self.root.after(0, self._helper_launch_success)
                        return
                time.sleep(0.5)

            self.root.after(0, self._helper_launch_failed,
                          "Helper started but socket not available after 12s")
            
        except Exception as e:
            self.root.after(0, self._helper_launch_failed, str(e))
    
    def _helper_launch_success(self):
        """Called when helper successfully launched"""
        self.update_status("Connected to helper daemon")
        self.log_message("Helper daemon launched successfully")
        self.connect_btn.config(state='disabled')
        self.start_keepalive()

        # Check EC status
        self.root.after(500, self.check_ec_status)
    
    def _helper_launch_failed(self, error):
        """Called when helper launch failed"""
        self.update_status(f"Failed to launch helper: {error}", error=True)
        self.log_message(f"ERROR: Failed to launch helper - {error}", level='error')
        self.connect_btn.config(state='normal')
        self.show_error_dialog(
            f"Failed to launch helper daemon:\n\n{error}\n\n"
            "Make sure you entered the correct password."
        )
        # Update Secure Boot indicator locally (since we can't ask the helper)
        self._check_secure_boot_local()

    def _check_secure_boot_local(self):
        """Check Secure Boot status locally via mokutil (no helper needed)"""
        try:
            result = subprocess.run(['mokutil', '--sb-state'],
                                    capture_output=True, text=True, timeout=2)
            output = result.stdout.strip()
            if 'SecureBoot enabled' in output:
                self.secureboot_label.config(text="Secure Boot: ON", bg='red')
                self.secureboot_frame.config(bg='red')
            else:
                self.secureboot_label.config(text="Secure Boot: OFF", bg='green')
                self.secureboot_frame.config(bg='green')
        except Exception as e:
            self.logger.warning(f"Could not check Secure Boot locally: {e}")

    def start_keepalive(self):
        """Start periodic keepalive messages in a background thread.

        Using a dedicated thread instead of root.after() ensures keepalives
        continue even when the tkinter event loop is blocked by long-running
        operations (display switching, etc.) or when the system resumes from
        suspend.
        """
        self.stop_keepalive()

        self._keepalive_stop.clear()
        self._keepalive_thread = threading.Thread(
            target=self._keepalive_loop, daemon=True
        )
        self._keepalive_thread.start()
        self.logger.info(f"Started keepalive thread ({self.KEEPALIVE_INTERVAL}s interval)")

    def stop_keepalive(self):
        """Stop the keepalive thread."""
        self._keepalive_stop.set()
        if self._keepalive_thread and self._keepalive_thread.is_alive():
            self._keepalive_thread.join(timeout=3)
        self._keepalive_thread = None

    def _keepalive_loop(self):
        """Background thread that sends keepalives at regular intervals."""
        while not self._keepalive_stop.wait(self.KEEPALIVE_INTERVAL):
            if not self.helper.is_connected():
                self.root.after(0, self._on_keepalive_lost,
                               "Helper disconnected")
                return

            try:
                response = self.helper.send_command('keepalive')
                if not response or not response.get('success'):
                    self.root.after(0, self._on_keepalive_lost,
                                   "Keepalive failed")
                    return

                # Process any hotkey notifications on the main thread
                notifs = response.get('notifications', [])
                if notifs:
                    self.root.after(0, self._process_notifications, notifs)

            except Exception as e:
                self.logger.error(f"Keepalive error: {e}")
                self.root.after(0, self._on_keepalive_lost,
                               f"Lost connection to helper - {e}")
                return

    def _on_keepalive_lost(self, reason):
        """Called on the main thread when keepalive detects a disconnect."""
        self.update_status("Helper disconnected - attempting restart...", error=True)
        self.log_message(f"ERROR: {reason}", level='error')
        self.attempt_helper_restart()

    def _process_notifications(self, notifs):
        """Process hotkey notifications on the main thread."""
        for notif in notifs:
            self._handle_hotkey_notification(notif)
    
    def _handle_hotkey_notification(self, notif):
        """Process a hotkey notification received from the helper daemon."""
        ntype = notif.get('type')
        if ntype == 'brightness':
            level = notif.get('level')
            if level is not None:
                self.brightness_var.set(level)
                self.brightness_label.config(text=str(level))
                self.log_message(f"Hotkey: brightness set to {level}")
        elif ntype == 'refresh':
            self.log_message("Hotkey: eInk refresh performed")

    def attempt_helper_restart(self):
        """Attempt to restart the helper daemon"""
        # Stop keepalive thread
        self.stop_keepalive()
        
        self.log_message("Attempting to restart helper daemon...")
        
        # Try to connect to existing socket first
        if os.path.exists(self.SOCKET_PATH):
            try:
                if self.helper.connect(self.SOCKET_PATH, timeout=self.SOCKET_TIMEOUT):
                    self.log_message("✓ Reconnected to existing helper")
                    self.update_status("Reconnected to helper daemon")
                    self.start_keepalive()
                    # Re-check EC status and sync frontlight state after reconnect
                    self.root.after(500, self.check_ec_status)
                    return
            except:
                pass
        
        # Need to launch new helper
        self.log_message("Launching new helper daemon (password may be required)...")
        self.update_status("Launching helper daemon...")
        threading.Thread(target=self._launch_helper_thread, daemon=True).start()
    
    def check_ec_status(self):
        """Check EC access status and disable frontlight controls if Secure Boot enabled"""
        try:
            response = self.helper.send_command('get-ec-status')

            if response and response.get('success'):
                ec_status = response.get('ec_status', {})

                # Update Secure Boot status indicator
                if ec_status.get('secure_boot_enabled'):
                    self.secureboot_label.config(text="Secure Boot: ON", bg='red')
                    self.secureboot_frame.config(bg='red')
                else:
                    self.secureboot_label.config(text="Secure Boot: OFF", bg='green')
                    self.secureboot_frame.config(bg='green')

                if ec_status.get('secure_boot_enabled') or not ec_status.get('available'):
                    # Secure Boot enabled or EC not available - disable frontlight controls
                    error_msg = ec_status.get('error_message', 'EC access not available')
                    self.log_message(f"⚠ {error_msg}", level='error')

                    # Show warning label
                    self.secure_boot_warning.grid(row=1, column=0, columnspan=2,
                                                 sticky=(tk.W, tk.E), padx=5, pady=10)

                    # Disable brightness slider (frontlight checkbox is already always disabled)
                    self.brightness_scale.config(state='disabled')

                    # Show dialog
                    if ec_status.get('secure_boot_enabled'):
                        messagebox.showwarning(
                            "Secure Boot Enabled",
                            "Secure Boot is currently enabled in your BIOS.\n\n"
                            "Frontlight controls require direct hardware access which is blocked by Secure Boot.\n\n"
                            "To enable frontlight controls:\n"
                            "1. Reboot your computer\n"
                            "2. Press ENTER (or F2) during boot to enter BIOS\n"
                            "3. Navigate to Security → Secure Boot\n"
                            "4. Set Secure Boot to 'Disabled'\n"
                            "5. Save and exit (F10)\n\n"
                            "Note: E-Ink display controls will continue to work normally."
                        )
                    else:
                        self.log_message(f"EC access not available: {error_msg}", level='error')
                else:
                    self.log_message("EC access verified - frontlight controls enabled")
                    # Sync GUI with actual EC state
                    self.sync_frontlight_state()

        except Exception as e:
            self.logger.error(f"Failed to check EC status: {e}")
            self.log_message(f"Warning: Could not verify EC status: {e}", level='error')

    def sync_frontlight_state(self):
        """Query EC and update GUI to match actual frontlight state"""
        try:
            response = self.helper.send_command('get-frontlight-state')

            if response and response.get('success'):
                brightness = response.get('brightness_level')

                if brightness is not None:
                    self.brightness_var.set(brightness)
                    self.brightness_label.config(text=str(brightness))
                    self.log_message(f"Synced brightness level: {brightness}")

        except Exception as e:
            self.logger.warning(f"Failed to sync frontlight state: {e}")
            self.log_message(f"Warning: Could not sync frontlight state from EC", level='error')


    def execute_helper_command(self, command, **params):
        """Execute a command via helper and handle response"""
        if not self.helper.is_connected():
            messagebox.showerror("Error", "Not connected to helper daemon.\n\nPlease click 'Connect to Helper' first.")
            return None

        try:
            response = self.helper.send_command(command, **params)

            if response and response.get('success'):
                message = response.get('message', 'Command completed')
                self.log_message(f"✓ {message}")

                # Log readback value if present
                if 'readback' in response:
                    self.log_message(f"  Readback value: {response['readback']}")

                return response
            else:
                error = response.get('error', 'Unknown error') if response else 'No response'
                self.log_message(f"✗ Command failed: {error}", level='error')
                self.show_error_dialog(f"Command failed:\n\n{error}")
                return None

        except Exception as e:
            self.log_message(f"✗ Command error: {e}", level='error')
            self.show_error_dialog(f"Command error:\n\n{e}")
            return None
    
    # === Event Handlers ===
    
    def on_eink_toggled(self, skip_countdown=False):
        """Handle E-Ink display toggle with flip countdown."""
        if self._countdown_active:
            self.log_message("Switch already in progress...", level='warning')
            return

        countdown = self.flip_countdown if not skip_countdown else 0
        if countdown > 0:
            direction = "eInk" if not self.eink_enabled_var.get() else "OLED"
            self.log_message(f"Flip your screen to {direction} now!")
            self._countdown_active = True
            self.eink_toggle_btn.config(state='disabled')
            self._run_countdown(countdown)
        else:
            self._do_eink_toggle()

    def _run_countdown(self, remaining):
        """Tick the flip countdown, then perform the switch."""
        if remaining > 0:
            self.log_message(f"Switching in {remaining}...")
            self.eink_toggle_btn.config(text=f"Flip now... {remaining}")
            self.root.after(1000, self._run_countdown, remaining - 1)
        else:
            self._countdown_active = False
            self.eink_toggle_btn.config(state='normal')
            self._do_eink_toggle()

    def _do_eink_toggle(self):
        """Perform the actual E-Ink display toggle."""
        enabled = self.eink_enabled_var.get()
        # Toggle the state
        enabled = not enabled

        if enabled:
            # Enabling E-Ink
            self.log_message("Enabling E-Ink display...")

            # Prevent the system from sleeping while we switch displays
            self._inhibit_sleep()

            # Save the current OLED scale so we can restore it later
            try:
                oled_scale = self.display_mgr.get_display_scale(self.DISPLAY_OLED)
                if oled_scale is not None:
                    self.saved_oled_scale = oled_scale
                    self.log_message(f"Saved OLED scale: {oled_scale}")
                else:
                    self.log_message("Could not read OLED scale, will use default on restore", level='warning')
            except Exception as e:
                self.logger.warning(f"Failed to save OLED scale: {e}")

            # Save keyboard layout before display switch
            try:
                kb = self.display_mgr.get_keyboard_layout()
                if kb:
                    self.saved_keyboard_layout = kb
                    self.log_message(f"Saved keyboard layout: {kb}")
            except Exception as e:
                self.logger.warning(f"Failed to save keyboard layout: {e}")

            # Step 0: Switch to High Contrast theme if enabled
            if self.autoswitch_theme_var.get():
                self.theme_mgr.set_theme(self.THEME_HIGH_CONTRAST)

            # Step 1: Enable E-Ink on eDP-2 first
            self.log_message(f"Enabling E-Ink display on {self.DISPLAY_EINK} with {self.display_scale}x scale...")
            if self.display_mgr.enable_display(self.DISPLAY_EINK, scale=self.display_scale):
                self.log_message(f"✓ E-Ink display ({self.DISPLAY_EINK}) enabled with {self.display_scale}x scale")
            else:
                self.log_message(f"⚠ Failed to enable E-Ink display on {self.DISPLAY_EINK}", level='error')

            # Let the event loop process display-change events before
            # continuing, so the compositor/X server state stays in sync.
            self.root.update_idletasks()
            time.sleep(1.0)

            # Step 2: Enable E-Ink via USB TCON controller
            response = self.execute_helper_command('enable-eink')

            if response:
                self.eink_enabled_var.set(True)
                self.eink_toggle_btn.config(text="eInk Enabled", bg="green", fg="white")
                self.update_status("E-Ink display enabled")

                # Enable refresh button and mode buttons
                self.btn_refresh.config(state='normal')
                self.btn_set_dynamic.config(state='normal')
                self.btn_set_reading.config(state='normal')

                # Step 3: Enable frontlight automatically with current brightness
                self.log_message("Enabling frontlight for E-Ink display...")
                brightness_level = self.brightness_var.get()
                frontlight_response = self.execute_helper_command('enable-frontlight',
                                                                  brightness_level=brightness_level)
                if frontlight_response:
                    self.log_message(f"✓ Frontlight enabled with brightness {brightness_level}")
                else:
                    self.log_message("⚠ Failed to enable frontlight (may not be available)", level='error')

                # Step 4: Set dynamic mode as default for eInk
                self.log_message("Setting E-Ink to dynamic mode...")
                dynamic_response = self.execute_helper_command('set-dynamic')
                if dynamic_response:
                    self.log_message("✓ E-Ink set to dynamic mode")
                else:
                    self.log_message("⚠ Failed to set dynamic mode", level='error')

                # Small delay before disabling OLED
                time.sleep(0.5)

                # Step 5: Disable OLED display on eDP-1 as the last step
                self.log_message(f"Disabling OLED display on {self.DISPLAY_OLED}...")
                if self.display_mgr.disable_display(self.DISPLAY_OLED):
                    self.log_message(f"✓ OLED display ({self.DISPLAY_OLED}) disabled")
                else:
                    self.log_message(f"⚠ Failed to disable OLED display on {self.DISPLAY_OLED}", level='error')

                # Let the event loop process display-change events from the
                # compositor / X server before continuing.  Without this,
                # tkinter can't respond to surface-reconfigure events and
                # the window may end up in a stale input state on Wayland.
                self.root.update_idletasks()

                # Step 5b: Re-apply eInk display config now that it is the
                # sole active output.  On X11, overlapping two outputs at
                # (0,0) with --panning can leave the panning viewport in a
                # broken state after the other output is disabled — the
                # pointer moves but clicks land in a dead zone.  Re-applying
                # forces xrandr to recalculate panning for the single output.
                time.sleep(0.3)
                self.display_mgr.enable_display(self.DISPLAY_EINK, scale=self.display_scale)
                self.root.update_idletasks()

                # Step 6: Map touchscreen input to E-Ink display
                self.log_message("Mapping touchscreen input to E-Ink display...")
                if self.display_mgr.map_touch_to_display(self.DISPLAY_EINK):
                    self.log_message(f"✓ Touchscreen mapped to {self.DISPLAY_EINK}")
                else:
                    self.log_message("⚠ Could not map touchscreen (may auto-map)", level='info')

                # Start periodic refresh timer if configured
                self._start_refresh_timer()

                # Create floating refresh button (may fail on Wayland due to
                # lack of overrideredirect / always-on-top support)
                try:
                    self.log_message("Creating floating refresh button...")
                    self.floating_refresh_button = FloatingRefreshButton(
                        self.root,
                        self.on_refresh_full,
                        self.logger
                    )
                except Exception as e:
                    self.logger.warning(f"Floating refresh button not available: {e}")
                    self.log_message("Floating refresh button unavailable (Wayland limitation)", level='warning')

                # Display switch complete — allow sleep again
                self._uninhibit_sleep()

        else:
            # Disabling E-Ink
            self.log_message("Preparing to disable E-Ink display...")

            # Prevent the system from sleeping while we switch displays
            self._inhibit_sleep()

            # Step 1: Stop periodic refresh timer first
            self._stop_refresh_timer()

            # Step 2: Destroy floating refresh button
            if self.floating_refresh_button:
                self.log_message("Destroying floating refresh button...")
                self.floating_refresh_button.destroy()
                self.floating_refresh_button = None

            # Step 3: Disable refresh button and mode buttons
            self.btn_refresh.config(state='disabled')
            self.btn_set_dynamic.config(state='disabled')
            self.btn_set_reading.config(state='disabled')

            # Step 4: Switch to dynamic mode for color rendering before showing privacy image
            self.log_message("Switching to dynamic mode for color privacy image...")
            self.execute_helper_command('set-dynamic')
            time.sleep(0.5)  # Give T-CON time to switch mode

            # Step 5: Display random privacy image on E-Ink screen
            chosen = random.choice(self.EINK_DISABLED_IMAGES)
            image_path = chosen
            if not os.path.exists(image_path):
                # Try in bundle/script directory
                if getattr(sys, 'frozen', False):
                    base_dir = sys._MEIPASS  # PyInstaller data dir
                else:
                    base_dir = os.path.dirname(os.path.abspath(__file__))
                image_path = os.path.join(base_dir, chosen)

            if os.path.exists(image_path):
                self.log_message(f"Displaying privacy image ({chosen}) on {self.DISPLAY_EINK}...")
                self.eink_image_process = self.display_mgr.display_fullscreen_image(
                    self.DISPLAY_EINK,
                    image_path
                )

                if self.eink_image_process:
                    # Wait for image to fully render on E-Ink.
                    # eInk panels need 2-3s for a full refresh in dynamic mode.
                    # feh must stay running through T-CON disable so the eInk
                    # retains the privacy image as its last frame.
                    self.log_message("Waiting for image to render on E-Ink...")
                    time.sleep(3.0)
                else:
                    self.log_message("Warning: Could not display privacy image", level='error')
            else:
                self.log_message(f"Warning: Privacy image not found: {chosen}", level='error')

            # Step 6: Disable frontlight before powering off T-CON
            self.log_message("Disabling frontlight...")
            frontlight_response = self.execute_helper_command('disable-frontlight')
            if frontlight_response:
                self.log_message("✓ Frontlight disabled")
            else:
                self.log_message("⚠ Failed to disable frontlight", level='error')

            # Step 7: Disable E-Ink via USB controller
            # IMPORTANT: disable T-CON while feh is still running so the
            # eInk panel retains the privacy image as its last frame.
            # Killing feh first would cause the desktop to flash on eDP-2,
            # and the eInk would start refreshing to that instead.
            self.log_message("Disabling E-Ink display via USB controller...")
            response = self.execute_helper_command('disable-eink')

            if response:
                self.eink_enabled_var.set(False)
                self.eink_toggle_btn.config(text="eInk Disabled", bg="#FF8C00", fg="white")
                self.update_status("E-Ink display disabled")

                # Step 8: Kill the image viewer (T-CON is off, eInk retains the image)
                if self.eink_image_process:
                    try:
                        self.eink_image_process.terminate()
                        self.eink_image_process.wait(timeout=2)
                        self.log_message("Closed image viewer (image persisted on E-Ink)")
                    except:
                        try:
                            self.eink_image_process.kill()
                        except:
                            pass
                    self.eink_image_process = None

                # Step 9: Enable OLED display on eDP-1, restoring previous scale
                restore_scale = self.saved_oled_scale if self.saved_oled_scale else 1.0
                self.log_message(f"Enabling OLED display on {self.DISPLAY_OLED} with scale {restore_scale}...")
                if self.display_mgr.enable_display(self.DISPLAY_OLED, scale=restore_scale):
                    self.log_message(f"✓ OLED display ({self.DISPLAY_OLED}) enabled with scale {restore_scale}")
                else:
                    self.log_message(f"⚠ Failed to enable OLED display on {self.DISPLAY_OLED}", level='error')

                # Small delay to ensure OLED is fully enabled
                time.sleep(1.0)

                # Step 5: Disable E-Ink on eDP-2 as the last step
                self.log_message(f"Disabling E-Ink display on {self.DISPLAY_EINK}...")
                if self.display_mgr.disable_display(self.DISPLAY_EINK):
                    self.log_message(f"✓ E-Ink display ({self.DISPLAY_EINK}) disabled")
                else:
                    self.log_message(f"⚠ Failed to disable E-Ink display on {self.DISPLAY_EINK}", level='error')

                self.root.update_idletasks()

                # Re-apply OLED config as sole output (same fix as eInk path)
                time.sleep(0.3)
                self.display_mgr.enable_display(self.DISPLAY_OLED, scale=restore_scale)
                self.root.update_idletasks()

                # Step 5b: Wake and unlock OLED panel — disabling eDP-2
                # can trigger GNOME to lock/blank the session.
                self.log_message("Waking OLED panel...")
                self.display_mgr.wake_display()
                # Retry after a short delay — the lock can trigger
                # asynchronously after the display change.
                time.sleep(1.0)
                self.display_mgr.wake_display()

                # Step 6: Map touchscreen input back to OLED display
                self.log_message("Mapping touchscreen input to OLED display...")
                if self.display_mgr.map_touch_to_display(self.DISPLAY_OLED):
                    self.log_message(f"✓ Touchscreen mapped to {self.DISPLAY_OLED}")
                else:
                    self.log_message("⚠ Could not map touchscreen (may auto-map)", level='info')

                # Step 7: Switch to Adwaita-dark theme if enabled
                if self.autoswitch_theme_var.get():
                    self.theme_mgr.set_theme(self.THEME_ADWAITA_DARK)

                # Step 8: Restore keyboard layout (display switching can reset it)
                if self.saved_keyboard_layout:
                    self.log_message("Restoring keyboard layout...")
                    self.display_mgr.restore_keyboard_layout(self.saved_keyboard_layout)
                    self.log_message("✓ Keyboard layout restored")

                # Display switch complete — allow sleep again
                self._uninhibit_sleep()
            else:
                self._uninhibit_sleep()
                # Failed to disable - kill image viewer
                if self.eink_image_process:
                    try:
                        self.eink_image_process.terminate()
                        self.eink_image_process.wait(timeout=2)
                    except:
                        try:
                            self.eink_image_process.kill()
                        except:
                            pass
                    self.eink_image_process = None
    
    def on_refresh_full(self):
        """Perform full E-Ink refresh"""
        self.log_message("Performing full E-Ink refresh (clearing ghosting)...")
        self.update_status("Refreshing E-Ink display...")
        response = self.execute_helper_command('refresh-eink')
        if response:
            self.update_status("E-Ink refresh complete")

    def on_set_dynamic(self):
        """Set E-Ink to Dynamic Mode (fast refresh)"""
        self.log_message("Setting E-Ink to Dynamic Mode (fast refresh)...")
        self.update_status("Setting Dynamic Mode...")
        response = self.execute_helper_command('set-dynamic')
        if response:
            self.update_status("E-Ink set to Dynamic Mode")

    def on_set_reading(self):
        """Set E-Ink to Reading Mode (high-quality refresh)"""
        self.log_message("Setting E-Ink to Reading Mode (high-quality refresh)...")
        self.update_status("Setting Reading Mode...")
        response = self.execute_helper_command('set-reading')
        if response:
            self.update_status("E-Ink set to Reading Mode")

    def on_brightness_changed(self, value):
        """Handle brightness slider change"""
        level = int(float(value))
        self.brightness_label.config(text=str(level))
        
        # Debounce: use timer to avoid too many commands while dragging
        if self.brightness_timer:
            self.root.after_cancel(self.brightness_timer)
        
        self.brightness_timer = self.root.after(300, self._set_brightness, level)
    
    def _set_brightness(self, level):
        """Actually set the brightness after debounce"""
        self.log_message(f"Setting brightness to level {level}...")
        response = self.execute_helper_command('set-brightness', level=level)

        if response:
            self.update_status(f"Brightness set to {level}")

        self.brightness_timer = None

    def _on_brightness_key_up(self, event):
        """Handle XF86MonBrightnessUp — step frontlight up when in eInk mode"""
        if not self.eink_enabled_var.get():
            return
        current = self.brightness_var.get()
        if current < 8:
            new_level = current + 1
            self.brightness_var.set(new_level)
            self.brightness_label.config(text=str(new_level))
            self._set_brightness(new_level)
        return "break"

    def _on_brightness_key_down(self, event):
        """Handle XF86MonBrightnessDown — step frontlight down when in eInk mode"""
        if not self.eink_enabled_var.get():
            return
        current = self.brightness_var.get()
        if current > 0:
            new_level = current - 1
            self.brightness_var.set(new_level)
            self.brightness_label.config(text=str(new_level))
            self._set_brightness(new_level)
        return "break"

    def on_scale_changed(self, value):
        """Handle display scale slider change"""
        # Round to nearest 0.05
        scale = round(float(value) / 0.05) * 0.05
        self.scale_var.set(scale)
        self.display_scale = scale
        self.scale_label.config(text=f"{scale:.2f}")
        self.log_message(f"Display scale set to {scale:.2f}x (will apply on next display switch)")

        # Save settings
        self.save_settings()

    def on_refresh_period_changed(self, value):
        """Handle refresh period slider change"""
        # Round to nearest 5 seconds
        period = int(round(float(value) / 5.0) * 5)
        self.refresh_period_var.set(period)
        self.refresh_period_label.config(text=str(period))

        # Restart the refresh timer if eInk is active
        if self.eink_enabled_var.get():
            self._start_refresh_timer()
            if period == 0:
                self.log_message("Periodic refresh disabled")
            else:
                self.log_message(f"Periodic refresh set to {period}s")

        # Save settings
        self.save_settings()

    def on_autoswitch_theme_changed(self):
        """Handle autoswitch theme checkbox change"""
        enabled = self.autoswitch_theme_var.get()
        if enabled:
            self.log_message("Theme auto-switching enabled")
        else:
            self.log_message("Theme auto-switching disabled")

        # Save settings
        self.save_settings()

    def _start_refresh_timer(self):
        """Start or restart the periodic refresh timer"""
        # Cancel existing timer if any
        if self.refresh_timer:
            self.root.after_cancel(self.refresh_timer)
            self.refresh_timer = None

        # Get current period
        period = self.refresh_period_var.get()

        # Only start timer if period > 0 and eInk is active
        if period > 0 and self.eink_enabled_var.get():
            self.refresh_timer = self.root.after(period * 1000, self._periodic_refresh)
            self.logger.info(f"Started periodic refresh timer ({period}s)")

    def _stop_refresh_timer(self):
        """Stop the periodic refresh timer"""
        if self.refresh_timer:
            self.root.after_cancel(self.refresh_timer)
            self.refresh_timer = None
            self.logger.info("Stopped periodic refresh timer")

    def _periodic_refresh(self):
        """Execute a periodic refresh and reschedule"""
        if self.eink_enabled_var.get():
            self.log_message("Performing periodic refresh...")
            self.execute_helper_command('refresh-eink')

            # Reschedule the next refresh
            period = self.refresh_period_var.get()
            if period > 0:
                self.refresh_timer = self.root.after(period * 1000, self._periodic_refresh)
        else:
            # eInk is no longer active, stop the timer
            self.refresh_timer = None

    def _on_eink_btn_hover(self, event, entering):
        """Handle hover effects for eInk toggle button"""
        if entering:
            # Mouse entering - darken the current color
            if self.eink_enabled_var.get():
                # Currently green (enabled) - use darker green
                self.eink_toggle_btn.config(bg="#006400")  # Dark green
            else:
                # Currently orange (disabled) - use darker orange
                self.eink_toggle_btn.config(bg="#CC7000")  # Darker orange
        else:
            # Mouse leaving - restore original color
            if self.eink_enabled_var.get():
                self.eink_toggle_btn.config(bg="green")
            else:
                self.eink_toggle_btn.config(bg="#FF8C00")

    def on_buy_coffee(self):
        """Handle Buy Me A Coffee button click"""
        try:
            webbrowser.open('https://buymeacoffee.com/joncox')
            self.log_message("Opening Buy Me A Coffee page...")
        except Exception as e:
            self.logger.error(f"Failed to open browser: {e}")
            self.log_message(f"Failed to open browser: {e}", level='error')

    def _run_startup_check(self):
        """Run post-login display/input validation on a background thread.

        Called once at startup (after a 3s delay) to catch display issues
        from login, reboot, or hibernate — before the user interacts.
        """
        def _check():
            try:
                # At startup we always expect OLED (eink_enabled_var defaults
                # to False). If the user had eInk active before a reboot,
                # the helper isn't connected yet so we can't know — default
                # to OLED per user preference.
                checker = ResumeCheck(self.display_mgr, self.logger)
                results = checker.run(
                    expect_eink=False,
                    saved_oled_scale=self.saved_oled_scale,
                    saved_keyboard_layout=self.saved_keyboard_layout)

                fixes = [r for r in results
                         if r.startswith("Fixed:") or r.startswith("Warning:")]
                if fixes:
                    summary = "; ".join(fixes)
                    self.root.after(0, lambda s=summary: self.log_message(
                        f"Startup check: {s}"))
                else:
                    self.logger.info("Startup check: all OK")
            except Exception as e:
                self.logger.error(f"Startup check failed: {e}")

        threading.Thread(target=_check, daemon=True,
                         name='startup-check').start()

    def _start_resume_monitor(self):
        """Start a background thread that listens for system resume events.

        Uses systemd-logind PrepareForSleep D-Bus signal to detect when the
        system wakes from suspend (e.g. lid open).  On resume, if eInk is
        not active, re-enforce OLED-only display state and restore the
        keyboard layout.
        """
        self._resume_monitor_stop.clear()
        self._resume_monitor_thread = threading.Thread(
            target=self._resume_monitor_loop, daemon=True,
            name='resume-monitor')
        self._resume_monitor_thread.start()
        # Also monitor for hotplug events (external monitor connect/disconnect)
        self._hotplug_monitor_thread = threading.Thread(
            target=self._hotplug_monitor_loop, daemon=True,
            name='hotplug-monitor')
        self._hotplug_monitor_thread.start()

    def _hotplug_monitor_loop(self):
        """Watch for xrandr hotplug events and re-enforce display state."""
        try:
            import subprocess
            proc = subprocess.Popen(
                ['xrandr', '--auto', '--dryrun'],
                stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        except Exception:
            pass
        try:
            proc = subprocess.Popen(
                ['sh', '-c',
                 'xrandr --verbose 2>&1 | grep -i "output\|connected\|disconnected"'],
                stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        except Exception:
            return
        # Poll xrandr for output changes every 3 seconds
        import time as _time
        prev = None
        while not self._resume_monitor_stop.is_set():
            self._resume_monitor_stop.wait(3.0)
            if self._resume_monitor_stop.is_set():
                break
            try:
                result = subprocess.run(
                    ['xrandr'],
                    capture_output=True, text=True, timeout=5)
                curr = result.stdout
                if prev is not None and curr != prev:
                    self.logger.info("Hotplug detected: display configuration changed")
                    _time.sleep(1.5)
                    # Only intervene if eInk is active — suppress OLED coming back
                    if self.eink_enabled_var.get():
                        self.logger.info("Hotplug: eInk active, re-enforcing eInk state")
                        self._on_system_resume()
                prev = curr
            except Exception:
                pass

    def _resume_monitor_loop(self):
        """Background loop: listen for PrepareForSleep(false) from logind."""
        try:
            import dbus
            from dbus.mainloop.glib import DBusGMainLoop
            from gi.repository import GLib
        except ImportError:
            self.logger.warning("Resume monitor: dbus/GLib not available, falling back to poll")
            self._resume_monitor_poll()
            return

        try:
            DBusGMainLoop(set_as_default=True)
            bus = dbus.SystemBus()

            bus.add_signal_receiver(
                self._on_prepare_for_sleep,
                signal_name='PrepareForSleep',
                dbus_interface='org.freedesktop.login1.Manager',
                bus_name='org.freedesktop.login1'
            )

            self._glib_loop = GLib.MainLoop()
            self.logger.info("Resume monitor started (D-Bus PrepareForSleep)")

            # Run until stop is requested
            context = self._glib_loop.get_context()
            while not self._resume_monitor_stop.is_set():
                context.iteration(True)

        except Exception as e:
            self.logger.warning(f"Resume monitor D-Bus setup failed: {e}, falling back to poll")
            self._resume_monitor_poll()

    def _resume_monitor_poll(self):
        """Fallback resume monitor using /sys/power/wakeup_count polling."""
        self.logger.info("Resume monitor started (poll fallback)")
        try:
            with open('/sys/power/wakeup_count', 'r') as f:
                last_count = f.read().strip()
        except Exception:
            self.logger.warning("Resume monitor: cannot read wakeup_count, monitor disabled")
            return

        while not self._resume_monitor_stop.is_set():
            self._resume_monitor_stop.wait(3.0)
            if self._resume_monitor_stop.is_set():
                break
            try:
                with open('/sys/power/wakeup_count', 'r') as f:
                    count = f.read().strip()
                if count != last_count:
                    last_count = count
                    self.logger.info("Resume detected (wakeup_count changed)")
                    self._on_system_resume()
            except Exception:
                pass

    def _on_prepare_for_sleep(self, going_to_sleep):
        """D-Bus signal handler for PrepareForSleep.

        Args:
            going_to_sleep: True when entering suspend, False when resuming.
        """
        if not going_to_sleep:
            self.logger.info("System resumed from suspend (PrepareForSleep=false)")
            # Small delay to let the display subsystem stabilise
            time.sleep(2.0)
            self._on_system_resume()

    def _on_system_resume(self):
        """Called after the system wakes from suspend / lid open.

        Runs comprehensive display and input validation via ResumeCheck.
        Fixes extended-desktop bugs, wrong-display states, resolution
        mismatches, keyboard layout drift, and touch mapping.
        """
        try:
            expect_eink = self.eink_enabled_var.get()
            self.logger.info(
                f"Resume: running post-resume checks "
                f"(expect_eink={expect_eink})")

            checker = ResumeCheck(self.display_mgr, self.logger)
            results = checker.run(
                expect_eink=expect_eink,
                saved_oled_scale=self.saved_oled_scale,
                saved_keyboard_layout=self.saved_keyboard_layout)

            if results:
                summary = "; ".join(r for r in results
                                    if not r.startswith("Touchscreen mapped")
                                    and not r.startswith("Keyboard layout restored"))
                if summary:
                    self.root.after(0, lambda s=summary: self.log_message(
                        f"↻ Post-resume: {s}"))

        except Exception as e:
            self.logger.error(f"Resume fix-up failed: {e}")

    def on_closing(self):
        """Handle window close"""
        self.logger.info("Application closing")

        # If eInk is currently active, automatically switch back to OLED
        # to display privacy image and prevent exposure of personal information
        if self.eink_enabled_var.get():
            self.log_message("eInk display is active - switching back to OLED before exit...")
            self.logger.info("eInk active at exit - automatically switching to OLED")

            # Trigger the toggle to switch back to OLED (this will display privacy image)
            self.on_eink_toggled(skip_countdown=True)

            self.log_message("✓ Automatic switch to OLED completed")

        # Stop resume monitor
        self._resume_monitor_stop.set()
        if hasattr(self, '_glib_loop') and self._glib_loop:
            try:
                self._glib_loop.quit()
            except Exception:
                pass

        # Release sleep inhibitor if still held
        self._uninhibit_sleep()

        # Stop refresh timer
        self._stop_refresh_timer()

        # Stop keepalive
        self.stop_keepalive()

        # Disconnect from helper (sends shutdown command)
        if self.helper.is_connected():
            self.helper.disconnect()

        # Terminate helper process if we launched it
        if self.helper_process:
            try:
                self.helper_process.terminate()
                self.helper_process.wait(timeout=2)
            except:
                pass

        self.root.destroy()


def show_disclaimer_dialog(parent=None):
    """Show disclaimer dialog on first launch. Returns True if user agrees, False otherwise."""
    # Load EULA text from external file
    if getattr(sys, 'frozen', False):
        script_dir = sys._MEIPASS  # PyInstaller data dir
    else:
        script_dir = os.path.dirname(os.path.abspath(__file__))
    eula_file = os.path.join(script_dir, "README_EULA_INSTRUCTIONS_WARNINGS.txt")

    try:
        with open(eula_file, 'r') as f:
            DISCLAIMER_TEXT = f.read()
    except FileNotFoundError:
        # Show error message and terminate
        if parent:
            messagebox.showerror("EULA Not Found",
                               "EULA file not found:\n" + eula_file +
                               "\n\nThe application will now exit.")
        else:
            root = tk.Tk()
            root.withdraw()
            messagebox.showerror("EULA Not Found",
                               "EULA file not found:\n" + eula_file +
                               "\n\nThe application will now exit.")
            root.destroy()
        sys.exit(1)
    except Exception as e:
        # Show error message for other read errors and terminate
        error_msg = f"Failed to read EULA file:\n{eula_file}\n\nError: {str(e)}\n\nThe application will now exit."
        if parent:
            messagebox.showerror("EULA Not Found", error_msg)
        else:
            root = tk.Tk()
            root.withdraw()
            messagebox.showerror("EULA Not Found", error_msg)
            root.destroy()
        sys.exit(1)

    # Check if agreement file exists
    config_dir = os.path.expanduser("~/.config/Tinta4PlusU")
    agree_file = os.path.join(config_dir, "agree")

    if os.path.exists(agree_file):
        return True  # User has already agreed

    # Create a custom EULA dialog
    dialog = tk.Toplevel(parent)
    dialog.title("End User License Agreement")
    dialog.geometry("900x750")
    dialog.resizable(False, False)

    # Disable the close button (X) - user must click Agree or Disagree
    dialog.protocol("WM_DELETE_WINDOW", lambda: None)

    # Make it modal
    dialog.grab_set()
    dialog.focus_set()

    # Center the dialog on screen
    dialog.update_idletasks()
    x = (dialog.winfo_screenwidth() // 2) - (650 // 2)
    y = (dialog.winfo_screenheight() // 2) - (600 // 2)
    dialog.geometry(f'900x750+{x}+{y}')

    # Result variable
    result = {'agreed': False}

    def on_agree():
        result['agreed'] = True
        dialog.destroy()

    def on_disagree():
        result['agreed'] = False
        dialog.destroy()

    # Top frame with warning icon and title
    _eula_bg = '#1c1c1c' if HAS_SV_TTK else 'white'
    _eula_fg = '#e0e0e0' if HAS_SV_TTK else 'black'
    top_frame = tk.Frame(dialog, bg=_eula_bg, pady=10)
    top_frame.pack(fill=tk.X)

    # Warning icon (using text emoji)
    icon_label = tk.Label(top_frame, text="⚠", font=('TkDefaultFont', 48),
                         bg=_eula_bg, fg='orange')
    icon_label.pack(side=tk.LEFT, padx=20)

    # Title
    title_label = tk.Label(top_frame, text="End User License Agreement\n\nPlease read carefully",
                          font=('TkDefaultFont', 12, 'bold'), bg=_eula_bg, fg=_eula_fg,
                          justify=tk.LEFT)
    title_label.pack(side=tk.LEFT, padx=10)

    # Separator
    separator = ttk.Separator(dialog, orient=tk.HORIZONTAL)
    separator.pack(fill=tk.X, padx=5, pady=5)

    # Button frame (pack this BEFORE the text so it stays at bottom)
    button_frame = tk.Frame(dialog)
    button_frame.pack(side=tk.BOTTOM, fill=tk.X, padx=10, pady=10)

    # Bottom separator (pack before text frame)
    separator2 = ttk.Separator(dialog, orient=tk.HORIZONTAL)
    separator2.pack(side=tk.BOTTOM, fill=tk.X, padx=5, pady=5)

    # Scrolled text widget for EULA (pack last so it fills remaining space)
    text_frame = tk.Frame(dialog)
    text_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)

    # Create ScrolledText with vertical scrollbar
    eula_kwargs = {'wrap': tk.WORD, 'font': ('TkDefaultFont', 11),
                   'relief': tk.SUNKEN, 'bd': 2, 'width': 1, 'height': 1}
    if HAS_SV_TTK:
        eula_kwargs.update({'bg': '#1c1c1c', 'fg': '#e0e0e0', 'insertbackground': '#e0e0e0'})
    eula_text = scrolledtext.ScrolledText(text_frame, **eula_kwargs)
    eula_text.pack(fill=tk.BOTH, expand=True)
    eula_text.insert('1.0', DISCLAIMER_TEXT)
    eula_text.config(state=tk.DISABLED)  # Make read-only

    # Agree button (left side, initially disabled)
    agree_btn = ttk.Button(button_frame, text="Agree",
                          command=on_agree,
                          state='disabled')
    agree_btn.pack(side=tk.LEFT, padx=5)

    # Disagree button (right side, default)
    disagree_btn = ttk.Button(button_frame, text="Disagree",
                             command=on_disagree)
    disagree_btn.pack(side=tk.RIGHT, padx=5)

    # Make Disagree the default button (focused)
    disagree_btn.focus_set()

    # Function to check if user has scrolled to the bottom
    def on_scroll(*args):
        # Get the current position of the scrollbar
        # yview() returns (top, bottom) as fractions of the total content
        pos = eula_text.yview()
        # If bottom is at or near 1.0 (end of document), enable Agree button
        if pos[1] >= 0.99:  # Allow small margin for rounding
            agree_btn.config(state='normal')

    # Bind scroll event to check position
    eula_text.bind('<Configure>', on_scroll)
    eula_text.bind('<MouseWheel>', on_scroll)
    eula_text.bind('<Button-4>', on_scroll)  # Linux scroll up
    eula_text.bind('<Button-5>', on_scroll)  # Linux scroll down
    eula_text.bind('<Key>', on_scroll)  # Arrow keys, Page Down, etc.

    # Also monitor the scrollbar directly - get the vbar widget
    vbar = eula_text.vbar  # ScrolledText has a vbar attribute for the scrollbar
    if vbar:
        original_set = vbar.set
        def scrollbar_set(*args):
            original_set(*args)
            on_scroll()
        vbar.set = scrollbar_set

    # Handle Enter key on buttons
    disagree_btn.bind('<Return>', lambda e: on_disagree())
    agree_btn.bind('<Return>', lambda e: on_agree())

    # Wait for dialog to close
    dialog.wait_window()

    if result['agreed']:
        # User agreed - create agreement file
        try:
            os.makedirs(config_dir, exist_ok=True)
            with open(agree_file, 'w') as f:
                f.write('')  # Empty file
            return True
        except Exception as e:
            print(f"Error creating agreement file: {e}")
            return False
    else:
        # User declined
        return False


def _resolve_helper_path(logger):
    """Resolve the helper daemon path, checking binary then script locations."""
    # When running as PyInstaller binary, use the bundle dir for relative paths
    if getattr(sys, 'frozen', False):
        base_dir = os.path.dirname(sys.executable)
    else:
        base_dir = os.path.dirname(os.path.abspath(__file__))

    candidates = [
        '/usr/local/bin/tinta4plusu-helper',                          # Installed binary (symlink)
        os.path.join(base_dir, 'tinta4plusu-helper'),                 # Portable binary (same dir)
        '/usr/local/bin/HelperDaemon.py',                            # Legacy installed script
        os.path.join(base_dir, 'HelperDaemon.py'),                   # Dev script (same dir)
    ]

    for path in candidates:
        if os.path.exists(path):
            logger.info(f"Using helper at: {path}")
            return path

    # Return first candidate as default even if not found yet (will be checked at launch)
    logger.warning("No helper found at any known location")
    return candidates[0]


def main():
    """Entry point"""
    autostart = '--autostart' in sys.argv

    # Setup logging
    log_handlers = [
        logging.StreamHandler(),  # Console output
        logging.FileHandler('/tmp/tinta4plusu.log', mode='w')  # File output (overwrite mode)
    ]

    logging.basicConfig(
        level=logging.INFO,
        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
        handlers=log_handlers
    )
    logger = logging.getLogger('tinta4plusu-gui')

    # Setup exception hook to log uncaught exceptions
    def handle_exception(exc_type, exc_value, exc_traceback):
        """Log uncaught exceptions"""
        if issubclass(exc_type, KeyboardInterrupt):
            # Allow keyboard interrupt to exit normally
            sys.__excepthook__(exc_type, exc_value, exc_traceback)
            return

        logger.critical("Uncaught exception", exc_info=(exc_type, exc_value, exc_traceback))

    sys.excepthook = handle_exception

    HELPER_SCRIPT = _resolve_helper_path(logger)

    root = tk.Tk()
    root.withdraw()  # Hide the main window initially

    # Check disclaimer agreement BEFORE showing the main window
    if not show_disclaimer_dialog(root):
        print("User declined disclaimer. Exiting.")
        root.destroy()
        sys.exit(0)

    # User agreed, show the main window
    root.deiconify()
    app = EInkControlGUI(root, HELPER_SCRIPT, logger, autostart=autostart)

    try:
        root.mainloop()
    except KeyboardInterrupt:
        logger.info("Interrupted by user")
        app.on_closing()


if __name__ == '__main__':
    main()