app.py

from __future__ import annotations

import argparse
import threading
import tkinter as tk
from tkinter import messagebox, ttk
from tkinter.scrolledtext import ScrolledText

from auto_logout.action_logger import get_logger
from auto_logout.config import Settings, load_settings, save_settings
from auto_logout.orchestrator import CleanupSummary, LogoutOrchestrator
from auto_logout.triggers import IdleMonitor, WindowsSessionHook


class AutoLogoutApp:
    def __init__(self, root: tk.Tk, start_silent: bool = False):
        self.root = root
        self.root.title("AutoLogout")
        self.root.geometry("640x470")
        self.root.minsize(540, 420)

        self.logger = get_logger()
        self.settings: Settings = load_settings()
        if start_silent:
            self.settings.silent_mode = True

        self._cleanup_lock = threading.Lock()
        self._cleanup_running = False

        self.status_var = tk.StringVar(value="Ready")
        self.auto_close_var = tk.BooleanVar(value=self.settings.auto_on_app_close)
        self.auto_windows_var = tk.BooleanVar(value=self.settings.auto_on_windows_logoff)
        self.idle_enabled_var = tk.BooleanVar(value=self.settings.idle_enabled)
        self.idle_minutes_var = tk.IntVar(value=self.settings.idle_minutes)
        self.silent_var = tk.BooleanVar(value=self.settings.silent_mode)
        self.preserve_dashlane_var = tk.BooleanVar(
            value=self.settings.preserve_dashlane_extension
        )
        self.target_apps_var = tk.StringVar(
            value=", ".join(self.settings.target_app_images)
        )

        self.orchestrator = LogoutOrchestrator(
            settings=self.settings,
            logger=self.logger,
            status_callback=self._set_status_threadsafe,
        )

        self.idle_monitor = IdleMonitor(
            enabled_getter=lambda: self.settings.idle_enabled,
            threshold_minutes_getter=lambda: self.settings.idle_minutes,
            callback=self._on_idle_trigger,
            logger=self.logger,
        )
        self.session_hook = WindowsSessionHook(
            hwnd_getter=lambda: self.root.winfo_id(),
            callback=self._on_windows_logoff_trigger,
            logger=self.logger,
        )

        self._build_ui()
        self._set_status("Ready")

        self.root.protocol("WM_DELETE_WINDOW", self._on_close)
        self.root.after(200, self._post_init)

    def _build_ui(self) -> None:
        container = ttk.Frame(self.root, padding=12)
        container.pack(fill=tk.BOTH, expand=True)

        title = ttk.Label(
            container,
            text="Shared Workstation Session Security",
            font=("Segoe UI", 13, "bold"),
        )
        title.pack(anchor=tk.W)

        subtitle = ttk.Label(
            container,
            text=(
                "Closes target applications and clears web sessions "
                "(Chrome, Edge, Firefox)."
            ),
            font=("Segoe UI", 9),
        )
        subtitle.pack(anchor=tk.W, pady=(0, 10))

        options_frame = ttk.LabelFrame(container, text="Options")
        options_frame.pack(fill=tk.X, pady=(0, 10))

        ttk.Checkbutton(
            options_frame,
            text="Auto cleanup on app close",
            variable=self.auto_close_var,
        ).grid(row=0, column=0, sticky="w", padx=8, pady=4)

        ttk.Checkbutton(
            options_frame,
            text="Auto cleanup on Windows sign-out",
            variable=self.auto_windows_var,
        ).grid(row=1, column=0, sticky="w", padx=8, pady=4)

        ttk.Checkbutton(
            options_frame,
            text="Idle timer",
            variable=self.idle_enabled_var,
        ).grid(row=2, column=0, sticky="w", padx=8, pady=4)

        minutes_frame = ttk.Frame(options_frame)
        minutes_frame.grid(row=2, column=1, sticky="w", padx=8, pady=4)
        ttk.Label(minutes_frame, text="Threshold (min):").pack(side=tk.LEFT)
        ttk.Spinbox(
            minutes_frame,
            from_=1,
            to=240,
            width=6,
            textvariable=self.idle_minutes_var,
        ).pack(side=tk.LEFT, padx=(6, 0))

        ttk.Checkbutton(
            options_frame,
            text="Silent mode (start minimized)",
            variable=self.silent_var,
        ).grid(row=3, column=0, sticky="w", padx=8, pady=4)

        ttk.Checkbutton(
            options_frame,
            text="Preserve Dashlane extension (avoid full re-login)",
            variable=self.preserve_dashlane_var,
        ).grid(row=4, column=0, sticky="w", padx=8, pady=4)

        apps_frame = ttk.LabelFrame(container, text="Applications to close")
        apps_frame.pack(fill=tk.X, pady=(0, 10))
        ttk.Label(
            apps_frame,
            text="Process names (.exe), comma-separated:",
        ).pack(anchor=tk.W, padx=8, pady=(6, 3))
        ttk.Entry(apps_frame, textvariable=self.target_apps_var).pack(
            fill=tk.X, padx=8, pady=(0, 8)
        )

        actions_frame = ttk.Frame(container)
        actions_frame.pack(fill=tk.X, pady=(0, 10))

        self.run_button = ttk.Button(
            actions_frame,
            text="Log out now",
            command=self._on_manual_cleanup,
        )
        self.run_button.pack(side=tk.LEFT)

        self.save_button = ttk.Button(
            actions_frame,
            text="Save settings",
            command=self._save_settings_from_ui,
        )
        self.save_button.pack(side=tk.LEFT, padx=8)

        ttk.Button(actions_frame, text="Quit", command=self._on_close).pack(side=tk.RIGHT)

        status_frame = ttk.Frame(container)
        status_frame.pack(fill=tk.X)
        ttk.Label(status_frame, text="Status:").pack(side=tk.LEFT)
        ttk.Label(status_frame, textvariable=self.status_var).pack(side=tk.LEFT, padx=6)

        self.log_widget = ScrolledText(container, height=12, state=tk.DISABLED)
        self.log_widget.pack(fill=tk.BOTH, expand=True, pady=(8, 0))

    def _post_init(self) -> None:
        self.idle_monitor.start()
        if self.settings.auto_on_windows_logoff:
            self.session_hook.install()
        if self.settings.silent_mode:
            self.root.iconify()
        self._append_log("Application ready")

    def _set_status(self, text: str) -> None:
        self.status_var.set(text)

    def _set_status_threadsafe(self, text: str) -> None:
        self.root.after(0, lambda: self._set_status(text))
        self.root.after(0, lambda: self._append_log(text))

    def _append_log(self, message: str) -> None:
        self.log_widget.configure(state=tk.NORMAL)
        self.log_widget.insert(tk.END, f"{message}\n")
        self.log_widget.see(tk.END)
        self.log_widget.configure(state=tk.DISABLED)

    def _apply_settings_from_ui(self) -> None:
        target_apps = [
            item.strip().lower()
            for item in self.target_apps_var.get().split(",")
            if item.strip()
        ]
        self.settings.auto_on_app_close = bool(self.auto_close_var.get())
        self.settings.auto_on_windows_logoff = bool(self.auto_windows_var.get())
        self.settings.idle_enabled = bool(self.idle_enabled_var.get())
        self.settings.idle_minutes = max(1, int(self.idle_minutes_var.get()))
        self.settings.silent_mode = bool(self.silent_var.get())
        self.settings.preserve_dashlane_extension = bool(
            self.preserve_dashlane_var.get()
        )
        self.settings.target_app_images = target_apps

    def _save_settings_from_ui(self) -> None:
        self._apply_settings_from_ui()
        save_settings(self.settings)
        if self.settings.auto_on_windows_logoff:
            self.session_hook.install()
        else:
            self.session_hook.uninstall()
        self._append_log("Settings saved")

    def _set_controls_enabled(self, enabled: bool) -> None:
        state = tk.NORMAL if enabled else tk.DISABLED
        self.run_button.configure(state=state)
        self.save_button.configure(state=state)

    def _on_manual_cleanup(self) -> None:
        self._run_cleanup_async("ManualButton")

    def _on_idle_trigger(self, trigger: str) -> None:
        self._run_cleanup_async(trigger)

    def _on_windows_logoff_trigger(self, trigger: str) -> None:
        if not self.settings.auto_on_windows_logoff:
            return
        self._run_cleanup_async(trigger)

    def _run_cleanup_async(self, trigger: str) -> None:
        with self._cleanup_lock:
            if self._cleanup_running:
                self._append_log("Cleanup already running")
                return
            self._cleanup_running = True

        self._set_controls_enabled(False)
        worker = threading.Thread(target=lambda: self._cleanup_worker(trigger), daemon=True)
        worker.start()

    def _cleanup_worker(self, trigger: str) -> None:
        summary: CleanupSummary = self.orchestrator.run_cleanup(trigger)
        self.logger.info(
            "Summary trigger=%s duration=%.2fs error=%s",
            summary.trigger,
            summary.duration_seconds,
            summary.error,
        )

        def finalize_ui() -> None:
            with self._cleanup_lock:
                self._cleanup_running = False
            self._set_controls_enabled(True)
            if summary.error:
                messagebox.showerror("AutoLogout", f"Error: {summary.error}")
            else:
                self._append_log(
                    (
                        f"Completed in {summary.duration_seconds:.1f}s | "
                        f"process={len(summary.process_actions)} "
                        f"browser={len(summary.browser_actions)} "
                        f"apps={len(summary.app_actions)}"
                    )
                )

        self.root.after(0, finalize_ui)

    def _on_close(self) -> None:
        self._apply_settings_from_ui()
        save_settings(self.settings)

        if self.settings.auto_on_app_close and not self._cleanup_running:
            self._append_log("Auto cleanup before close")
            summary = self.orchestrator.run_cleanup("AppClose")
            self.logger.info("Cleanup on close completed: error=%s", summary.error)

        self.idle_monitor.stop()
        self.session_hook.uninstall()
        self.root.destroy()



def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="AutoLogout")
    parser.add_argument(
        "--silent",
        action="store_true",
        help="Silent startup (window minimized)",
    )
    return parser.parse_args()



def main() -> None:
    args = parse_args()
    root = tk.Tk()
    app = AutoLogoutApp(root, start_silent=args.silent)
    app.logger.info("Application started")
    root.mainloop()


if __name__ == "__main__":
    main()