gui.py

"""
GitFollow GUI - Desktop interface for GitFollow.
Run: python gui.py   or double-click GitFollow.exe
"""

import colorsys
import queue
import time
import tkinter as tk
from tkinter import scrolledtext, messagebox
import importlib
import json
import logging
import os
import sys
import threading
import webbrowser
from pathlib import Path
from datetime import datetime, timezone

# ── Paths ─────────────────────────────────────────────────────────────────────

if getattr(sys, "frozen", False):
    BASE_DIR = Path(sys.executable).parent
else:
    BASE_DIR = Path(__file__).parent

ENV_FILE   = BASE_DIR / ".env"
STATE_FILE = BASE_DIR / "data" / "state.json"

# ── CA bundle sanity check ────────────────────────────────────────────────────
# Some installers (e.g. PostgreSQL) set CURL_CA_BUNDLE / REQUESTS_CA_BUNDLE /
# SSL_CERT_FILE machine-wide, pointing at their own cert bundle. If that path
# later goes missing, `requests` refuses every call with
# "Could not find a suitable TLS CA certificate bundle". Drop any such
# dangling env var so requests falls back to certifi's bundled certs.
for _ca_var in ("REQUESTS_CA_BUNDLE", "CURL_CA_BUNDLE", "SSL_CERT_FILE"):
    _ca_path = os.environ.get(_ca_var)
    if _ca_path and not Path(_ca_path).is_file():
        os.environ.pop(_ca_var, None)

VERSION = "2.3.6"

# ── GitHub Dark Dimmed color tokens ───────────────────────────────────────────

C_BG        = "#22272e"   # canvas-default
C_SURFACE   = "#2d333b"   # canvas-subtle
C_SIDEBAR   = "#1c2128"   # canvas-inset (sidebar)
C_SIDEBAR_H = "#2d333b"   # sidebar hover
C_SIDEBAR_S = "#2d333b"   # sidebar selected
C_ACCENT    = "#539bf5"   # accent-fg
C_SUCCESS   = "#57ab5a"   # success-fg
C_DANGER    = "#e5534b"   # danger-fg
C_WARNING   = "#c69026"   # attention-fg
C_TEXT      = "#adbac7"   # fg-default
C_TEXT2     = "#768390"   # fg-muted
C_MUTED     = "#636e7b"   # fg-subtle
C_SEP       = "#444c56"   # border-default
C_TERM_BG   = "#1c2128"   # canvas-inset (terminal)
C_TERM_FG   = "#adbac7"   # fg-default

F_APP   = ("Segoe UI", 12, "bold")
F_H1    = ("Segoe UI", 17, "bold")
F_H2    = ("Segoe UI", 12, "bold")
F_UI    = ("Segoe UI", 10)
F_BOLD  = ("Segoe UI", 10, "bold")
F_SM    = ("Segoe UI", 9)
F_XS    = ("Segoe UI", 8)
F_NUM   = ("Segoe UI", 26, "bold")
F_MONO  = ("Consolas", 9)
F_NAV   = ("Segoe UI", 10)

# ── Helpers ───────────────────────────────────────────────────────────────────

def load_env() -> dict:
    env = {}
    if ENV_FILE.exists():
        for line in ENV_FILE.read_text(encoding="utf-8").splitlines():
            line = line.strip()
            if line and not line.startswith("#") and "=" in line:
                k, _, v = line.partition("=")
                env[k.strip()] = v.strip()
    return env


def save_env(env: dict):
    ENV_FILE.write_text(
        "\n".join(f"{k}={v}" for k, v in env.items() if v.strip()) + "\n",
        encoding="utf-8",
    )


def load_state() -> dict:
    if STATE_FILE.exists():
        try:
            return json.loads(STATE_FILE.read_text(encoding="utf-8"))
        except Exception:
            pass
    return {
        "following": {},
        "quality_cache": {},
        "stats": {"followed": 0, "unfollowed": 0, "mutual": 0},
    }


def _darken(hex_color: str, amount: float) -> str:
    """Return a darkened version of a hex color."""
    hex_c = hex_color.lstrip("#")
    r, g, b = (int(hex_c[i:i+2], 16) / 255 for i in (0, 2, 4))
    h, s, v = colorsys.rgb_to_hsv(r, g, b)
    r2, g2, b2 = colorsys.hsv_to_rgb(h, s, max(0.0, v - amount))
    return "#{:02x}{:02x}{:02x}".format(int(r2 * 255), int(g2 * 255), int(b2 * 255))


# ── Rounded button (Canvas-based) ─────────────────────────────────────────────

class RoundedButton(tk.Canvas):
    """Pill-shaped button drawn on a Canvas for rounded corners."""

    def __init__(self, parent, text, command,
                 width=130, height=34, radius=8,
                 bg=C_ACCENT, fg="white", font=F_BOLD, **kwargs):
        super().__init__(
            parent, width=width, height=height,
            bg=parent.cget("bg"), highlightthickness=0, **kwargs
        )
        self._text      = text
        self._orig_cmd  = command
        self._command   = command
        self._orig_bg   = bg
        self._bg        = bg
        self._hover_bg  = _darken(bg, 0.12)
        self._fg        = fg
        self._radius    = radius
        self._font      = font
        self._btn_w     = width
        self._btn_h     = height
        self._disabled  = False
        self._hovering  = False
        self._draw()
        self.bind("<Enter>",    self._on_enter)
        self.bind("<Leave>",    self._on_leave)
        self.bind("<Button-1>", self._on_click)

    def _rounded_rect(self, color: str):
        self.delete("all")
        w, h, r = self._btn_w, self._btn_h, self._radius
        c = color
        self.create_arc(0,       0,       2*r, 2*r, start=90,  extent=90, fill=c, outline=c)
        self.create_arc(w-2*r,   0,       w,   2*r, start=0,   extent=90, fill=c, outline=c)
        self.create_arc(0,       h-2*r,   2*r, h,   start=180, extent=90, fill=c, outline=c)
        self.create_arc(w-2*r,   h-2*r,   w,   h,   start=270, extent=90, fill=c, outline=c)
        self.create_rectangle(r, 0,   w-r, h,   fill=c, outline=c)
        self.create_rectangle(0, r,   w,   h-r, fill=c, outline=c)
        self.create_text(w // 2, h // 2, text=self._text,
                         fill=self._fg, font=self._font)

    def _draw(self):
        if self._disabled:
            self._rounded_rect(C_MUTED)
        elif self._hovering:
            self._rounded_rect(self._hover_bg)
        else:
            self._rounded_rect(self._bg)

    def _on_enter(self, _e=None):
        if not self._disabled:
            self._hovering = True
            self.config(cursor="hand2")
            self._draw()

    def _on_leave(self, _e=None):
        self._hovering = False
        self.config(cursor="")
        self._draw()

    def _on_click(self, _e=None):
        if self._command and not self._disabled:
            self._command()

    def config_state(self, disabled: bool):
        self._disabled = disabled
        self._hovering = False
        self._command  = None if disabled else self._orig_cmd
        self._bg       = C_MUTED if disabled else self._orig_bg
        self._draw()


# ── Tooltip ────────────────────────────────────────────────────────────────────

class Tooltip:
    """Dark floating tooltip on hover."""

    def __init__(self, widget: tk.Widget, text: str):
        self._win  = None
        self._text = text
        widget.bind("<Enter>",  self._show)
        widget.bind("<Leave>",  self._hide)
        widget.bind("<Button>", self._hide)

    def _show(self, event=None):
        if self._win:
            return
        w = event.widget
        x = w.winfo_rootx() + w.winfo_width() + 8
        y = w.winfo_rooty() + (w.winfo_height() // 2) - 14
        self._win = tw = tk.Toplevel(w)
        tw.wm_overrideredirect(True)
        tw.wm_attributes("-topmost", True)
        tw.wm_geometry(f"+{x}+{y}")
        tk.Label(
            tw, text=self._text, justify="left", wraplength=260,
            bg=C_SURFACE, fg=C_TEXT, font=F_SM, padx=12, pady=8,
        ).pack()

    def _hide(self, event=None):
        if self._win:
            self._win.destroy()
            self._win = None


def _tip(parent, text: str, bg=C_BG) -> tk.Label:
    """Small inline ? label with a hover tooltip."""
    lbl = tk.Label(parent, text="?", font=("Segoe UI", 8, "bold"),
                   fg=C_MUTED, bg=bg, cursor="question_arrow", width=2)
    Tooltip(lbl, text)
    return lbl


def _relative_time(iso_str: str) -> str:
    """Return a human-readable relative time string from an ISO timestamp."""
    if not iso_str:
        return "unknown"
    try:
        dt = datetime.fromisoformat(iso_str.replace("Z", "+00:00"))
        diff = datetime.now(timezone.utc) - dt
        total_seconds = int(diff.total_seconds())
        if total_seconds < 60:
            return "just now"
        if total_seconds < 3600:
            return f"{total_seconds // 60}m ago"
        if total_seconds < 86400:
            return f"{total_seconds // 3600}h ago"
        days = diff.days
        if days < 30:
            return f"{days}d ago"
        if days < 365:
            return f"{days // 30}mo ago"
        return f"{days // 365}y ago"
    except Exception:
        return "unknown"


# ── Log handler ────────────────────────────────────────────────────────────────

class _GUILogHandler(logging.Handler):
    def __init__(self, callback):
        super().__init__()
        self.callback = callback

    def emit(self, record):
        try:
            self.callback(self.format(record) + "\n")
        except Exception:
            pass


# ── App ────────────────────────────────────────────────────────────────────────

MAX_LOG_LINES = 2000   # keep the last N lines in the output terminal

class App(tk.Tk):
    def __init__(self):
        super().__init__()
        self.title("GitFollow")
        self.geometry("960x640")
        self.resizable(True, True)
        self.minsize(960, 640)
        self.configure(bg=C_SIDEBAR)
        _icon = BASE_DIR / "assets" / "icon.ico"
        if _icon.exists():
            try:
                self.iconbitmap(str(_icon))
            except Exception:
                pass
        self._running            = False
        self._stop_requested_early = False   # stop clicked before _gf_module was set
        self._pages              = {}
        self._nav_frames         = {}
        self._current_page       = None
        self._log_queue          = queue.Queue()
        self._log_line_count     = 0
        self.protocol("WM_DELETE_WINDOW", self._on_close)
        self._build_ui()
        self.after(50,  self._poll_log_queue)
        self.after(100, self._on_open)

    # ── Shell ──────────────────────────────────────────────────────────────────

    def _build_ui(self):
        # Left sidebar
        self._sidebar = tk.Frame(self, bg=C_SIDEBAR, width=190)
        self._sidebar.pack(side="left", fill="y")
        self._sidebar.pack_propagate(False)

        # Right content pane
        self._pane = tk.Frame(self, bg=C_BG)
        self._pane.pack(side="left", fill="both", expand=True)

        self._build_sidebar()
        self._build_setup_page()
        self._build_dashboard_page()
        self._build_run_page()
        self._build_people_page()
        self._build_settings_page()

        # Status bar (pinned to bottom of pane)
        tk.Frame(self._pane, bg=C_SEP, height=1).pack(side="bottom", fill="x")
        bar = tk.Frame(self._pane, bg=C_SURFACE, height=30)
        bar.pack(side="bottom", fill="x")
        bar.pack_propagate(False)
        self._status_var = tk.StringVar(value="Ready")
        tk.Label(bar, textvariable=self._status_var,
                 bg=C_SURFACE, fg=C_MUTED, font=F_SM).pack(side="left", padx=16, pady=6)

        self._show_page("setup")

    # ── Sidebar ────────────────────────────────────────────────────────────────

    def _build_sidebar(self):
        # App branding
        brand = tk.Frame(self._sidebar, bg=C_SIDEBAR, height=60)
        brand.pack(fill="x")
        brand.pack_propagate(False)
        tk.Label(brand, text="GitFollow", bg=C_SIDEBAR, fg="white",
                 font=F_APP).pack(side="left", padx=18, pady=18)
        tk.Label(brand, text=f"v{VERSION}", bg=C_SIDEBAR, fg=C_MUTED,
                 font=F_XS).pack(side="left", pady=22)

        tk.Frame(self._sidebar, bg=C_SEP, height=1).pack(fill="x")

        tk.Label(self._sidebar, text="MENU", bg=C_SIDEBAR, fg=C_MUTED,
                 font=("Segoe UI", 8, "bold")).pack(anchor="w", padx=18, pady=(12, 2))

        for key, icon, label in [
            ("setup",     "checkmark.circle", "Setup"),
            ("dashboard", "chart.bar",        "Dashboard"),
            ("run",       "play.circle",      "Run"),
            ("people",    "person.2",         "People"),
            ("settings",  "gearshape",        "Settings"),
        ]:
            self._nav_item(key, label)

        # Spacer + license note
        tk.Frame(self._sidebar, bg=C_SIDEBAR).pack(fill="both", expand=True)
        tk.Label(self._sidebar, text="MIT License",
                 bg=C_SIDEBAR, fg=C_MUTED, font=F_XS).pack(side="bottom", pady=14)

    def _nav_item(self, key: str, label: str):
        frame = tk.Frame(self._sidebar, bg=C_SIDEBAR, cursor="hand2")
        frame.pack(fill="x", padx=8, pady=1)

        # Accent bar (shown when selected)
        bar   = tk.Frame(frame, bg=C_SIDEBAR, width=3)
        bar.pack(side="left", fill="y")

        inner = tk.Label(frame, text=f"  {label}", bg=C_SIDEBAR, fg=C_MUTED,
                         font=F_NAV, anchor="w", padx=10, pady=8)
        inner.pack(fill="x", side="left", expand=True)

        def click(_e=None, k=key):
            self._show_page(k)

        def enter(_e=None):
            if self._current_page != key:
                frame.config(bg=C_SIDEBAR_H)
                inner.config(bg=C_SIDEBAR_H)
                bar.config(bg=C_SIDEBAR_H)

        def leave(_e=None):
            if self._current_page != key:
                frame.config(bg=C_SIDEBAR)
                inner.config(bg=C_SIDEBAR)
                bar.config(bg=C_SIDEBAR)

        for w in (frame, inner, bar):
            w.bind("<Button-1>", click)
            w.bind("<Enter>",    enter)
            w.bind("<Leave>",    leave)

        self._nav_frames[key] = (frame, inner, bar)

    def _show_page(self, name: str):
        self._current_page = name
        for pg in self._pages.values():
            pg.pack_forget()
        self._pages[name].pack(fill="both", expand=True)

        for key, (frame, inner, bar) in self._nav_frames.items():
            if key == name:
                frame.config(bg=C_SIDEBAR_S)
                inner.config(bg=C_SIDEBAR_S, fg=C_TEXT,
                             font=("Segoe UI", 10, "bold"))
                bar.config(bg=C_ACCENT)
            else:
                frame.config(bg=C_SIDEBAR)
                inner.config(bg=C_SIDEBAR, fg=C_MUTED, font=F_NAV)
                bar.config(bg=C_SIDEBAR)

    # ── Page scaffold ──────────────────────────────────────────────────────────

    def _page_header(self, page: tk.Frame, title: str, subtitle: str = "") -> tk.Frame:
        """White header bar. Returns the right-side actions frame."""
        hdr = tk.Frame(page, bg=C_SURFACE)
        hdr.pack(fill="x")

        left = tk.Frame(hdr, bg=C_SURFACE)
        left.pack(side="left", fill="y")
        tk.Label(left, text=title, bg=C_SURFACE, fg=C_TEXT,
                 font=F_H1).pack(anchor="w", padx=24, pady=(18, 0))
        if subtitle:
            tk.Label(left, text=subtitle, bg=C_SURFACE, fg=C_MUTED,
                     font=F_SM).pack(anchor="w", padx=24, pady=(1, 16))
        else:
            tk.Frame(left, height=18, bg=C_SURFACE).pack()

        right = tk.Frame(hdr, bg=C_SURFACE)
        right.pack(side="right", fill="y", padx=22, pady=18)

        tk.Frame(page, bg=C_SEP, height=1).pack(fill="x")
        return right

    def _card(self, parent, **pack_kw) -> tk.Frame:
        """Surface card with a hairline border for definition against the page bg."""
        card = tk.Frame(parent, bg=C_SURFACE,
                        highlightthickness=1, highlightbackground=C_SEP)
        card.pack(**pack_kw)
        return card

    # ── Setup page ─────────────────────────────────────────────────────────────

    def _build_setup_page(self):
        page = tk.Frame(self._pane, bg=C_BG)
        self._pages["setup"] = page
        self._page_header(page, "Setup", "Verify your environment before running.")

        content = tk.Frame(page, bg=C_BG)
        content.pack(fill="both", expand=True, padx=20, pady=20)

        card = self._card(content, fill="x")

        checks = [
            ("python",   "Python 3.8+",
             "GitFollow requires Python 3.8 or newer."),
            ("requests", "requests library installed",
             "Handles all GitHub API calls. Run 'pip install requests' if missing."),
            ("token",    "GH_TOKEN configured",
             "Your GitHub Personal Access Token. Set it in the Settings tab."),
            ("username", "GH_USERNAME configured",
             "Your GitHub username. Set it in the Settings tab."),
            ("data_dir", "data/ directory exists",
             "Stores state.json which tracks follows and quality check results."),
        ]
        self._check_icons = {}
        for key, label, tooltip in checks:
            row = tk.Frame(card, bg=C_SURFACE)
            row.pack(fill="x", padx=20, pady=5)
            dot = tk.Label(row, text="●", font=("Segoe UI", 13),
                           bg=C_SURFACE, fg=C_MUTED, width=2)
            dot.pack(side="left")
            tk.Label(row, text=label, font=F_UI,
                     bg=C_SURFACE, fg=C_TEXT).pack(side="left", padx=(4, 0))
            _tip(row, tooltip, bg=C_SURFACE).pack(side="left", padx=(8, 0))
            self._check_icons[key] = dot

        tk.Frame(card, bg=C_SEP, height=1).pack(fill="x", padx=20, pady=(8, 0))

        btn_row = tk.Frame(card, bg=C_SURFACE)
        btn_row.pack(fill="x", padx=20, pady=14)
        RoundedButton(btn_row, "Re-check", self._run_checks,
                      width=100, height=32).pack(side="left", padx=(0, 8))
        self._test_conn_btn = RoundedButton(
            btn_row, "Test Connection", self._test_connection,
            width=130, height=32, bg=C_TEXT2,
        )
        self._test_conn_btn.pack(side="left", padx=(0, 8))
        Tooltip(self._test_conn_btn,
                "Makes a live call to the GitHub API to confirm GH_TOKEN is valid "
                "and GH_USERNAME matches the token's account.")
        RoundedButton(btn_row, "Auto-fix", self._autofix,
                      width=100, height=32, bg=C_SUCCESS).pack(side="left", padx=(0, 8))
        RoundedButton(btn_row, "Create Token",
                      lambda: webbrowser.open(
                          "https://github.com/settings/tokens/new"
                          "?scopes=user%3Afollow&description=GitFollow"
                      ),
                      width=120, height=32, bg=C_TEXT2).pack(side="left")

        self._setup_msg = tk.Label(card, text="", font=F_SM, bg=C_SURFACE,
                                    wraplength=850, justify="left")
        self._setup_msg.pack(anchor="w", padx=20, pady=(0, 14))

    def _run_checks(self):
        self._set_status("Running checks...")
        results = {}
        results["python"] = sys.version_info >= (3, 8)
        try:
            import requests  # noqa
            results["requests"] = True
        except ImportError:
            results["requests"] = False
        merged = {**load_env(), **os.environ}
        results["token"]    = bool(merged.get("GH_TOKEN", "").strip())
        results["username"] = bool(merged.get("GH_USERNAME", "").strip())
        results["data_dir"] = (BASE_DIR / "data").exists()

        for key, ok in results.items():
            self._check_icons[key].config(fg=C_SUCCESS if ok else C_DANGER)

        all_ok = all(results.values())
        self._setup_msg.config(
            text="All checks passed. You are ready to run." if all_ok
                 else "Fix the failing items above, then click Re-check.",
            fg=C_SUCCESS if all_ok else C_DANGER,
        )
        self._set_status("Checks complete." if all_ok else "Some checks failed.")

    def _test_connection(self):
        env   = {**load_env(), **os.environ}
        token = env.get("GH_TOKEN", "").strip()
        user  = env.get("GH_USERNAME", "").strip()
        if not token or not user:
            messagebox.showerror(
                "Missing credentials",
                "Set GH_TOKEN and GH_USERNAME in the Settings tab first.",
            )
            return
        self._test_conn_btn.config_state(disabled=True)
        self._setup_msg.config(text="Testing connection to GitHub...", fg=C_MUTED)
        self._set_status("Testing GitHub connection...")

        def _fetch():
            try:
                import requests
                resp = requests.get(
                    "https://api.github.com/user",
                    headers={"Authorization": f"token {token}",
                             "Accept": "application/vnd.github.v3+json"},
                    timeout=10,
                )
                if resp.status_code == 200:
                    login = resp.json().get("login", "")
                    if login.lower() == user.lower():
                        msg, ok = f"Connected as {login} — token is valid and ready to use.", True
                    else:
                        msg, ok = (
                            f"Token is valid but belongs to '{login}', not '{user}'. "
                            "Update GH_USERNAME in Settings.", False,
                        )
                elif resp.status_code == 401:
                    msg, ok = "401 Unauthorized — GH_TOKEN is invalid, expired, or revoked.", False
                else:
                    msg, ok = f"GitHub API returned HTTP {resp.status_code}.", False
            except Exception as e:
                msg, ok = f"Connection failed: {e}", False
            self.after(0, lambda: self._test_connection_done(msg, ok))

        threading.Thread(target=_fetch, daemon=True).start()

    def _test_connection_done(self, msg: str, ok: bool):
        self._test_conn_btn.config_state(disabled=False)
        self._setup_msg.config(text=msg, fg=C_SUCCESS if ok else C_DANGER)
        self._set_status("Connection test complete.")

    def _autofix(self):
        import subprocess as sp
        fixed = []
        # In a frozen exe, requests is already bundled — pip cannot help here
        if not getattr(sys, "frozen", False):
            try:
                import requests  # noqa
            except ImportError:
                try:
                    no_win = getattr(sp, "CREATE_NO_WINDOW", 0)
                    sp.check_call(
                        [sys.executable, "-m", "pip", "install", "requests", "-q"],
                        creationflags=no_win,
                    )
                    fixed.append("Installed requests")
                except Exception as e:
                    messagebox.showerror("Auto-fix failed", str(e))
                    return
        data_dir = BASE_DIR / "data"
        if not data_dir.exists():
            data_dir.mkdir(parents=True)
            fixed.append("Created data/ directory")
        if not ENV_FILE.exists():
            ENV_FILE.write_text("GH_TOKEN=\nGH_USERNAME=\n", encoding="utf-8")
            fixed.append("Created .env - open Settings to fill in credentials")
        messagebox.showinfo(
            "Auto-fix",
            ("Fixed:\n  " + "\n  ".join(fixed)) if fixed else "Nothing needed fixing.",
        )
        self._run_checks()

    # ── Dashboard page ─────────────────────────────────────────────────────────

    def _build_dashboard_page(self):
        page = tk.Frame(self._pane, bg=C_BG)
        self._pages["dashboard"] = page
        hdr_right = self._page_header(page, "Dashboard", "Live statistics.")

        self._dash_ts = tk.Label(hdr_right, text="", font=F_SM,
                                 bg=C_SURFACE, fg=C_MUTED)
        self._dash_ts.pack(side="right", padx=(0, 12), anchor="center")
        RoundedButton(hdr_right, "Refresh", self._refresh_dashboard,
                      width=90, height=30, font=F_SM).pack(side="right", padx=(0, 10))
        RoundedButton(hdr_right, "Clear Cache", self._clear_cache,
                      width=100, height=30, font=F_SM, bg=C_WARNING).pack(side="right", padx=(0, 10))

        content = tk.Frame(page, bg=C_BG)
        content.pack(fill="both", expand=True, padx=20, pady=20)

        grid = tk.Frame(content, bg=C_BG)
        grid.pack(fill="x")

        card_defs = [
            ("following",  "FOLLOWING",       "Your current total following count on GitHub."),
            ("followers",  "FOLLOWERS",        "Your current total follower count on GitHub."),
            ("mutual",     "MUTUAL FOLLOWS",   "Accounts currently marked as mutual in state.json (they follow you back)."),
            ("followed",   "TOTAL FOLLOWED",   "Total accounts followed through GitFollow across all runs."),
            ("unfollowed", "TOTAL UNFOLLOWED", "Total accounts unfollowed through GitFollow across all runs."),
            ("cached",     "CACHED CHECKS",    "Quality check results stored locally to avoid re-checking."),
        ]
        tk.Label(grid, text="CURRENT", font=("Segoe UI", 8, "bold"),
                 bg=C_BG, fg=C_MUTED).grid(
            row=0, column=0, columnspan=3, sticky="w", pady=(0, 6))
        tk.Label(grid, text="ALL-TIME", font=("Segoe UI", 8, "bold"),
                 bg=C_BG, fg=C_MUTED).grid(
            row=2, column=0, columnspan=3, sticky="w", pady=(16, 6))

        self._stat_vars = {}
        for i, (key, label, tooltip) in enumerate(card_defs):
            col = i % 3
            row = 1 if i < 3 else 3
            card = tk.Frame(grid, bg=C_SURFACE,
                             highlightthickness=1, highlightbackground=C_SEP)
            card.grid(row=row, column=col,
                      padx=(0 if col == 0 else 10, 0),
                      sticky="nsew")

            # Mutual follows gets a status accent (reciprocated = good) —
            # the other five are plain counters, not a categorical set, so
            # they stay neutral rather than each getting an arbitrary hue.
            if key == "mutual":
                tk.Frame(card, bg=C_SUCCESS, width=3).pack(side="left", fill="y")

            inner = tk.Frame(card, bg=C_SURFACE, padx=20, pady=16)
            inner.pack(side="left", fill="both", expand=True)

            top_row = tk.Frame(inner, bg=C_SURFACE)
            top_row.pack(fill="x")
            tk.Label(top_row, text=label, font=("Segoe UI", 8),
                     bg=C_SURFACE, fg=C_MUTED).pack(side="left")
            _tip(top_row, tooltip, bg=C_SURFACE).pack(side="right")

            var = tk.StringVar(value="--")
            self._stat_vars[key] = var
            tk.Label(inner, textvariable=var, font=F_NUM,
                     bg=C_SURFACE, fg=C_TEXT).pack(anchor="w", pady=(8, 0))

        for col in range(3):
            grid.columnconfigure(col, weight=1)

        tk.Label(content,
            text="Following / Followers fetched live from the GitHub API. "
                 "Other stats read from local state.json.",
            font=F_XS, bg=C_BG, fg=C_MUTED,
            wraplength=700, justify="left",
        ).pack(anchor="w", pady=(14, 0))

    def _refresh_dashboard(self):
        state = load_state()
        stats = state.get("stats", {})
        cache = state.get("quality_cache", {})
        # Compute current mutual count directly from state (not the lifetime counter,
        # which never decrements when someone unfollows you).
        current_mutual = sum(
            1 for v in state.get("following", {}).values() if v.get("mutual")
        )
        self._stat_vars["mutual"].set(f"{current_mutual:,}")
        self._stat_vars["followed"].set(f"{stats.get('followed', 0):,}")
        self._stat_vars["unfollowed"].set(f"{stats.get('unfollowed', 0):,}")
        self._stat_vars["cached"].set(f"{len(cache):,}")
        self._stat_vars["following"].set("...")
        self._stat_vars["followers"].set("...")
        self._dash_ts.config(text="Fetching...")
        self._set_status("Fetching live counts from GitHub...")

        def _fetch():
            env   = {**load_env(), **os.environ}
            token = env.get("GH_TOKEN", "").strip()
            user  = env.get("GH_USERNAME", "").strip()
            if not token or not user:
                self.after(0, lambda: (
                    self._stat_vars["following"].set("--"),
                    self._stat_vars["followers"].set("--"),
                    self._dash_ts.config(text="Set credentials in Settings"),
                    self._set_status("Credentials not configured."),
                ))
                return
            try:
                import requests
                resp = requests.get(
                    f"https://api.github.com/users/{user}",
                    headers={"Authorization": f"token {token}",
                             "Accept": "application/vnd.github.v3+json"},
                    timeout=10,
                )
                if resp.status_code == 200:
                    data  = resp.json()
                    f_ing = data.get("following", 0)
                    f_ers = data.get("followers", 0)
                    ts    = datetime.now().strftime("%H:%M:%S")
                    self.after(0, lambda: (
                        self._stat_vars["following"].set(f"{f_ing:,}"),
                        self._stat_vars["followers"].set(f"{f_ers:,}"),
                        self._dash_ts.config(text=f"Updated {ts}"),
                        self._set_status("Dashboard refreshed."),
                    ))
                elif resp.status_code == 401:
                    self.after(0, lambda: (
                        self._stat_vars["following"].set("--"),
                        self._stat_vars["followers"].set("--"),
                        self._dash_ts.config(text="Auth error (401)"),
                        self._set_status("401 Unauthorized — token is invalid or expired. Update GH_TOKEN in Settings."),
                    ))
                else:
                    self.after(0, lambda: (
                        self._stat_vars["following"].set("Err"),
                        self._stat_vars["followers"].set("Err"),
                        self._dash_ts.config(text=f"API error {resp.status_code}"),
                        self._set_status(f"GitHub API returned {resp.status_code}."),
                    ))
            except Exception as e:
                self.after(0, lambda: (
                    self._dash_ts.config(text="Network error"),
                    self._set_status(f"Error: {e}"),
                ))

        threading.Thread(target=_fetch, daemon=True).start()

    def _clear_cache(self):
        state = load_state()
        count = len(state.get("quality_cache", {}))
        if count == 0:
            messagebox.showinfo("Clear Cache", "Cache is already empty.")
            return
        if not messagebox.askyesno(
            "Clear Cache",
            f"Remove {count:,} cached quality-check results?\n"
            "All accounts will be re-evaluated on the next run.",
        ):
            return
        state["quality_cache"] = {}
        STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
        STATE_FILE.write_text(json.dumps(state, indent=2), encoding="utf-8")
        self._stat_vars["cached"].set("0")
        self._set_status(f"Cleared {count:,} cached entries.")

    # ── Run page ───────────────────────────────────────────────────────────────

    def _build_run_page(self):
        page = tk.Frame(self._pane, bg=C_BG)
        self._pages["run"] = page
        self._page_header(page, "Run", "Execute follow or unfollow passes locally.")

        content = tk.Frame(page, bg=C_BG)
        content.pack(fill="both", expand=True, padx=20, pady=20)

        # Action buttons card
        card = self._card(content, fill="x", pady=(0, 12))
        btn_area = tk.Frame(card, bg=C_SURFACE, padx=20, pady=16)
        btn_area.pack(fill="x")

        self._btn_follow = RoundedButton(
            btn_area, "Run Follow", lambda: self._start_run("follow"),
            width=130, height=36,
        )
        self._btn_follow.pack(side="left", padx=(0, 10))
        Tooltip(self._btn_follow,
                "Searches GitHub for active developers meeting your quality criteria "
                "and follows up to FOLLOW_LIMIT of them.")

        self._btn_unfollow = RoundedButton(
            btn_area, "Run Unfollow", lambda: self._start_run("unfollow"),
            width=130, height=36, bg=C_TEXT2,
        )
        self._btn_unfollow.pack(side="left", padx=(0, 10))
        Tooltip(self._btn_unfollow,
                "Immediately unfollows every current non-reciprocator (except "
                "whitelisted accounts). If Quality Unfollow is enabled in Settings, "
                "also scans existing follows for quality and unfollows failures "
                "(first run is slow; subsequent runs use the cache).")

        self._btn_stop = RoundedButton(
            btn_area, "Stop", self._stop_run,
            width=80, height=36, bg=C_DANGER,
        )
        self._btn_stop.pack(side="left")
        self._btn_stop.config_state(disabled=True)

        clear_lbl = tk.Label(btn_area, text="Clear Log", font=F_SM,
                             fg=C_ACCENT, bg=C_SURFACE, cursor="hand2")
        clear_lbl.pack(side="right")
        clear_lbl.bind("<Button-1>", lambda _e: self._clear_log())

        # Terminal card
        term = tk.Frame(content, bg=C_TERM_BG,
                        highlightthickness=1, highlightbackground=C_SEP)
        term.pack(fill="both", expand=True)

        # Minimal header bar — no dots
        chrome = tk.Frame(term, bg=C_SURFACE)
        chrome.pack(fill="x")
        tk.Label(chrome, text="Output", font=F_MONO,
                 bg=C_SURFACE, fg=C_MUTED).pack(side="left", padx=14, pady=6)
        tk.Frame(term, bg=C_SEP, height=1).pack(fill="x")

        self._log = scrolledtext.ScrolledText(
            term, font=F_MONO, state="disabled",
            bg=C_TERM_BG, fg=C_TERM_FG, insertbackground=C_TERM_FG,
            relief="flat", borderwidth=0, selectbackground="#264f78",
        )
        self._log.pack(fill="both", expand=True, padx=4, pady=(0, 4))

    def _start_run(self, mode: str):
        if self._running:
            messagebox.showinfo("Already running", "A run is already in progress.")
            return
        env = load_env()
        merged = {**env, **os.environ}
        if not merged.get("GH_TOKEN") or not merged.get("GH_USERNAME"):
            messagebox.showerror(
                "Missing credentials",
                "GH_TOKEN and GH_USERNAME must be set.\nGo to the Settings tab.",
            )
            return
        if mode == "unfollow":
            env["FOLLOW_LIMIT"] = "0"
            env.pop("FOLLOW_ONLY", None)
            os.environ.pop("FOLLOW_ONLY", None)
            # QUALITY_UNFOLLOW is whatever was saved in Settings (env, from .env);
            # clear any stale process-level override left by a previous run.
            os.environ.pop("QUALITY_UNFOLLOW", None)
            # A manual button click is a deliberate, immediate action — the
            # UNFOLLOW_HOURS grace period exists for the unattended/scheduled
            # run so freshly-followed accounts get a chance to follow back
            # before then. Clicking Run Unfollow by hand should act now.
            env["UNFOLLOW_HOURS"] = "0"
        else:
            env["FOLLOW_ONLY"] = "true"
            env.pop("QUALITY_UNFOLLOW", None)
            os.environ.pop("QUALITY_UNFOLLOW", None)
            os.environ.pop("FOLLOW_LIMIT", None)
        env["STATE_FILE"] = str(STATE_FILE)
        os.environ.update(env)
        self._running = True
        self._btn_follow.config_state(disabled=True)
        self._btn_unfollow.config_state(disabled=True)
        self._btn_stop.config_state(disabled=False)
        self._set_status(f"Running {mode}...")
        self._log_write(
            f"\n{'=' * 60}\n"
            f"  GitFollow  -  {mode.title()} Run  -  "
            f"{datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S')} UTC\n"
            f"{'=' * 60}\n\n"
        )
        handler = _GUILogHandler(self._log_write)
        handler.setFormatter(logging.Formatter("%(asctime)s  %(levelname)-8s  %(message)s"))

        def _worker():
            root_log = logging.getLogger()
            root_log.setLevel(logging.INFO)
            # Remove any StreamHandlers that write to stderr/stdout — these are
            # None in a windowed exe and will suppress our handler via handleError.
            for h in root_log.handlers[:]:
                if isinstance(h, logging.StreamHandler) and not isinstance(h, _GUILogHandler):
                    root_log.removeHandler(h)
            root_log.addHandler(handler)
            try:
                import gitfollow as _gf
                importlib.reload(_gf)
                _gf.stop_event.clear()
                self._gf_module = _gf
                # Honour a stop that was requested during the module reload
                if self._stop_requested_early:
                    self._stop_requested_early = False
                    _gf.stop_event.set()
                _gf.main()
            except Exception as e:
                self._log_write(f"\nERROR: {e}\n")
            finally:
                root_log.removeHandler(handler)
                self._gf_module = None
                self.after(0, self._run_done)

        threading.Thread(target=_worker, daemon=True).start()

    def _stop_run(self):
        gf = getattr(self, "_gf_module", None)
        if gf:
            gf.stop_event.set()
        else:
            # Module not yet assigned (clicked Stop during reload) — flag it so
            # the worker honours the request once the module is ready.
            self._stop_requested_early = True
        self._btn_stop.config_state(disabled=True)
        self._set_status("Stop requested — finishing current operation...")
        self._log_write("\n  Stop requested — will halt after current operation.\n")

    def _run_done(self):
        self._running = False
        self._btn_follow.config_state(disabled=False)
        self._btn_unfollow.config_state(disabled=False)
        self._btn_stop.config_state(disabled=True)
        self._log_write(
            f"\n{'=' * 60}\n"
            f"  Run complete  -  {datetime.now(timezone.utc).strftime('%H:%M:%S')} UTC\n"
            f"{'=' * 60}\n"
        )
        self._set_status("Run complete.")
        self._refresh_dashboard()

    def _log_write(self, text: str):
        self._log_queue.put(text)

    def _poll_log_queue(self):
        messages = []
        try:
            while True:
                messages.append(self._log_queue.get_nowait())
        except queue.Empty:
            pass
        if messages:
            combined = "".join(messages)
            new_lines = combined.count("\n")
            self._log.config(state="normal")
            self._log.insert(tk.END, combined)
            self._log_line_count += new_lines
            # Prune oldest lines to keep the widget bounded
            if self._log_line_count > MAX_LOG_LINES:
                excess = self._log_line_count - MAX_LOG_LINES
                self._log.delete("1.0", f"{excess + 1}.0")
                self._log_line_count = MAX_LOG_LINES
            self._log.see(tk.END)
            self._log.config(state="disabled")
        self.after(50, self._poll_log_queue)

    def _clear_log(self):
        self._log.config(state="normal")
        self._log.delete("1.0", tk.END)
        self._log.config(state="disabled")
        self._log_line_count = 0

    # ── People page ────────────────────────────────────────────────────────────

    def _build_people_page(self):
        page = tk.Frame(self._pane, bg=C_BG)
        self._pages["people"] = page

        hdr_right = self._page_header(page, "People", "Browse following and followers.")
        self._people_refresh_btn = RoundedButton(
            hdr_right, "Refresh", self._load_people,
            width=90, height=30, font=F_SM,
        )
        self._people_refresh_btn.pack(side="right")

        # Sub-tab bar
        self._people_tab_var = "following"
        self._people_tab_btns = {}
        tab_bar = tk.Frame(page, bg=C_SURFACE)
        tab_bar.pack(fill="x")
        for key, label in [("following", "Following"), ("followers", "Followers")]:
            btn = tk.Label(tab_bar, text=label, font=F_BOLD,
                           cursor="hand2", bg=C_SURFACE, padx=20, pady=10)
            btn.pack(side="left")
            btn.bind("<Button-1>", lambda _e, k=key: self._switch_people_tab(k))
            self._people_tab_btns[key] = btn
        tk.Frame(page, bg=C_SEP, height=1).pack(fill="x")

        # Action bar pinned to bottom
        tk.Frame(page, bg=C_SEP, height=1).pack(side="bottom", fill="x")
        action_bar = tk.Frame(page, bg=C_SURFACE)
        action_bar.pack(side="bottom", fill="x")

        self._people_sel_var = tk.StringVar(value="")
        tk.Label(action_bar, textvariable=self._people_sel_var,
                 font=F_SM, bg=C_SURFACE, fg=C_MUTED).pack(side="left", padx=16, pady=10)

        sel_all = tk.Label(action_bar, text="Select Page", font=F_SM,
                           fg=C_ACCENT, bg=C_SURFACE, cursor="hand2")
        sel_all.pack(side="left", padx=(0, 12))
        sel_all.bind("<Button-1>", lambda _e: self._people_select_all(True))
        Tooltip(sel_all, "Selects all accounts on the current page (50 at a time).")

        desel_all = tk.Label(action_bar, text="Deselect All", font=F_SM,
                             fg=C_ACCENT, bg=C_SURFACE, cursor="hand2")
        desel_all.pack(side="left")
        desel_all.bind("<Button-1>", lambda _e: self._people_select_all(False))

        tk.Label(action_bar, text="|", font=F_SM,
                 bg=C_SURFACE, fg=C_SEP).pack(side="left", padx=10)

        self._people_prev_lbl = tk.Label(action_bar, text="< Prev", font=F_SM,
                                          fg=C_MUTED, bg=C_SURFACE)
        self._people_prev_lbl.pack(side="left")
        self._people_prev_lbl.bind("<Button-1>", lambda _e: self._people_prev_page())

        self._people_page_var = tk.StringVar(value="")
        tk.Label(action_bar, textvariable=self._people_page_var, font=F_SM,
                 bg=C_SURFACE, fg=C_MUTED).pack(side="left", padx=6)

        self._people_next_lbl = tk.Label(action_bar, text="Next >", font=F_SM,
                                          fg=C_MUTED, bg=C_SURFACE)
        self._people_next_lbl.pack(side="left")
        self._people_next_lbl.bind("<Button-1>", lambda _e: self._people_next_page())

        self._people_unfollow_btn = RoundedButton(
            action_bar, "Unfollow Selected", self._unfollow_selected,
            width=155, height=32, bg=C_DANGER, font=F_SM,
        )
        self._people_unfollow_btn.pack(side="right", padx=16, pady=8)

        # Scrollable list area fills remaining space
        list_outer = tk.Frame(page, bg=C_BG)
        list_outer.pack(fill="both", expand=True)

        self._people_canvas = tk.Canvas(list_outer, bg=C_BG, highlightthickness=0)
        people_sb = tk.Scrollbar(list_outer, orient="vertical",
                                  command=self._people_canvas.yview)
        self._people_canvas.configure(yscrollcommand=people_sb.set)
        people_sb.pack(side="right", fill="y")
        self._people_canvas.pack(side="left", fill="both", expand=True)

        self._people_list_frame = tk.Frame(self._people_canvas, bg=C_BG)
        self._people_list_win = self._people_canvas.create_window(
            (0, 0), window=self._people_list_frame, anchor="nw",
        )

        self._people_list_frame.bind(
            "<Configure>",
            lambda e: self._people_canvas.configure(
                scrollregion=self._people_canvas.bbox("all")
            ),
        )
        self._people_canvas.bind(
            "<Configure>",
            lambda e: self._people_canvas.itemconfig(self._people_list_win, width=e.width),
        )
        self._people_canvas.bind(
            "<Enter>",
            lambda _e: self._people_canvas.bind_all(
                "<MouseWheel>",
                lambda e: self._people_canvas.yview_scroll(int(-1 * e.delta / 120), "units"),
            ),
        )
        self._people_canvas.bind(
            "<Leave>",
            lambda _e: self._people_canvas.unbind_all("<MouseWheel>"),
        )

        # Internal state
        self._people_data = {"following": [], "followers": []}
        self._people_check_vars = {}
        self._people_loading = False
        self._people_page = 0
        self._people_page_size = 50

        # Initial empty state message
        self._switch_people_tab("following")

    def _switch_people_tab(self, tab: str):
        self._people_tab_var = tab
        self._people_page = 0
        for key, btn in self._people_tab_btns.items():
            if key == tab:
                btn.config(fg=C_ACCENT, font=("Segoe UI", 10, "bold"))
            else:
                btn.config(fg=C_MUTED, font=F_BOLD)
        # Unfollow action only applies to following tab
        if tab == "following":
            self._people_unfollow_btn.pack(side="right", padx=16, pady=8)
        else:
            self._people_unfollow_btn.pack_forget()
        self._render_people_list()

    def _render_people_list(self):
        for w in self._people_list_frame.winfo_children():
            w.destroy()
        self._people_check_vars.clear()

        tab = self._people_tab_var

        if self._people_loading and not self._people_data[tab]:
            tk.Label(self._people_list_frame, text="Loading...",
                     font=F_UI, bg=C_BG, fg=C_MUTED).pack(pady=40)
            self._people_sel_var.set("")
            self._people_page_var.set("")
            return

        data = self._people_data[tab]
        if not data:
            msg = ("Click  Refresh  to load data."
                   if not any(self._people_data.values())
                   else f"No {tab} found.")
            tk.Label(self._people_list_frame, text=msg,
                     font=F_UI, bg=C_BG, fg=C_MUTED).pack(pady=40)
            self._people_sel_var.set("")
            self._people_page_var.set("")
            return

        # Pagination
        total       = len(data)
        page_size   = self._people_page_size
        total_pages = max(1, (total + page_size - 1) // page_size)
        self._people_page = max(0, min(self._people_page, total_pages - 1))
        start     = self._people_page * page_size
        page_data = data[start:start + page_size]

        self._people_page_var.set(f"  {self._people_page + 1} / {total_pages}  ")
        no_prev = self._people_page == 0
        no_next = self._people_page >= total_pages - 1
        self._people_prev_lbl.config(fg=C_MUTED if no_prev else C_ACCENT,
                                      cursor="" if no_prev else "hand2")
        self._people_next_lbl.config(fg=C_MUTED if no_next else C_ACCENT,
                                      cursor="" if no_next else "hand2")

        # Column header
        hdr = tk.Frame(self._people_list_frame, bg=C_SURFACE)
        hdr.pack(fill="x")
        tk.Label(hdr, text="", bg=C_SURFACE, width=3).pack(side="left")
        tk.Label(hdr, text="Username", font=("Segoe UI", 8, "bold"),
                 bg=C_SURFACE, fg=C_MUTED, anchor="w").pack(side="left", padx=(4, 0), expand=True, fill="x")
        tk.Label(hdr, text="Status", font=("Segoe UI", 8, "bold"),
                 bg=C_SURFACE, fg=C_MUTED, width=7, anchor="center").pack(side="left", padx=8)
        tk.Label(hdr, text="Time", font=("Segoe UI", 8, "bold"),
                 bg=C_SURFACE, fg=C_MUTED, width=12, anchor="e").pack(side="right", padx=(0, 16))
        tk.Frame(self._people_list_frame, bg=C_SEP, height=1).pack(fill="x")

        for i, entry in enumerate(page_data):
            login    = entry["login"]
            mutual   = entry.get("mutual", False)
            time_str = entry.get("time_str", "")
            row_bg   = C_BG if i % 2 == 0 else "#262c34"

            row = tk.Frame(self._people_list_frame, bg=row_bg)
            row.pack(fill="x")

            var = tk.BooleanVar(value=False)
            self._people_check_vars[login] = var

            tk.Checkbutton(
                row, variable=var, bg=row_bg,
                activebackground=row_bg, selectcolor=C_SUCCESS,
                relief="flat", command=self._update_people_selection,
            ).pack(side="left", padx=(8, 0), pady=4)

            name_lbl = tk.Label(row, text=login, font=F_UI,
                                bg=row_bg, fg=C_ACCENT, cursor="hand2", anchor="w")
            name_lbl.pack(side="left", padx=(2, 0), expand=True, fill="x")
            name_lbl.bind("<Button-1>",
                          lambda _e, l=login: webbrowser.open(f"https://github.com/{l}"))

            if mutual:
                tk.Label(row, text="mutual", font=F_XS,
                         bg=C_SUCCESS, fg="white", padx=5, pady=2).pack(side="left", padx=8)
            else:
                tk.Label(row, text="", width=7, bg=row_bg).pack(side="left", padx=8)

            tk.Label(row, text=time_str, font=F_SM,
                     bg=row_bg, fg=C_TEXT2, anchor="e", width=12).pack(side="right", padx=(0, 16))

            tk.Frame(self._people_list_frame, bg=C_SEP, height=1).pack(fill="x")

        self._update_people_selection()

    def _update_people_selection(self):
        count      = sum(1 for v in self._people_check_vars.values() if v.get())
        page_count = len(self._people_check_vars)
        total      = len(self._people_data.get(self._people_tab_var, []))
        if count == 0:
            self._people_sel_var.set(f"{total:,} total")
        else:
            self._people_sel_var.set(f"{count} of {page_count} selected")

    def _people_select_all(self, select: bool):
        for v in self._people_check_vars.values():
            v.set(select)
        self._update_people_selection()

    def _load_people(self):
        if self._people_loading:
            return
        self._people_loading = True
        self._people_page = 0
        self._people_refresh_btn.config_state(disabled=True)
        self._render_people_list()

        def _fetch():
            env   = {**load_env(), **os.environ}
            token = env.get("GH_TOKEN", "").strip()
            user  = env.get("GH_USERNAME", "").strip()
            if not token or not user:
                self.after(0, lambda: self._people_load_done(None, None, "Credentials not configured."))
                return
            try:
                import requests as _req
                hdrs = {
                    "Authorization": f"token {token}",
                    "Accept": "application/vnd.github.v3+json",
                }

                def _paginate(url, label, max_pages=50):
                    results, page = [], 1
                    while page <= max_pages:
                        self.after(0, lambda n=len(results), lbl=label:
                                   self._set_status(f"Fetching {lbl}... ({n} loaded)"))
                        r = _req.get(url, headers=hdrs,
                                     params={"per_page": 100, "page": page}, timeout=20)
                        if r.status_code == 401:
                            raise PermissionError(
                                "401 Unauthorized — token is invalid or expired. Update GH_TOKEN in Settings."
                            )
                        if r.status_code != 200:
                            break
                        batch = r.json()
                        if not batch:
                            break
                        results.extend(u["login"].lower() for u in batch)
                        if len(batch) < 100:
                            break
                        page += 1
                    return results

                following_logins = _paginate(
                    f"https://api.github.com/users/{user}/following", "following"
                )
                # Show following list immediately while fetching followers
                self.after(0, lambda f=list(following_logins): self._people_show_partial(f))

                followers_logins = _paginate(
                    f"https://api.github.com/users/{user}/followers", "followers"
                )
                self.after(0, lambda: self._people_load_done(following_logins, followers_logins, None))
            except Exception as exc:
                self.after(0, lambda: self._people_load_done(None, None, str(exc)))

        threading.Thread(target=_fetch, daemon=True).start()

    def _people_show_partial(self, following_logins: list):
        """Show the following list immediately before followers finish loading."""
        state           = load_state()
        following_state = state.get("following", {})
        following_data  = []
        for login in following_logins:
            info        = following_state.get(login, {})
            followed_at = info.get("followed_at", "")
            following_data.append({
                "login":       login,
                "mutual":      False,
                "time_str":    _relative_time(followed_at),
                "followed_at": followed_at,
            })
        following_data.sort(key=lambda x: x.get("followed_at") or "", reverse=True)
        self._people_data["following"] = following_data
        if self._people_tab_var == "following":
            self._render_people_list()
        self._set_status(
            f"Loaded {len(following_logins):,} following — fetching followers..."
        )

    def _people_prev_page(self):
        if self._people_page > 0:
            self._people_page -= 1
            self._render_people_list()
            self._people_canvas.yview_moveto(0)

    def _people_next_page(self):
        data        = self._people_data.get(self._people_tab_var, [])
        total_pages = max(1, (len(data) + self._people_page_size - 1) // self._people_page_size)
        if self._people_page < total_pages - 1:
            self._people_page += 1
            self._render_people_list()
            self._people_canvas.yview_moveto(0)

    def _people_load_done(self, following_logins, followers_logins, error):
        self._people_loading = False
        self._people_refresh_btn.config_state(disabled=False)

        if error:
            self._set_status(f"Error: {error}")
            self._render_people_list()
            return

        state          = load_state()
        following_state = state.get("following", {})
        following_set  = set(following_logins)
        followers_set  = set(followers_logins)

        following_data = []
        for login in following_logins:
            info        = following_state.get(login, {})
            followed_at = info.get("followed_at", "")
            following_data.append({
                "login":      login,
                "mutual":     login in followers_set,
                "time_str":   _relative_time(followed_at),
                "followed_at": followed_at,
            })
        # Most-recently followed first; mutuals floated to top
        following_data.sort(key=lambda x: x.get("followed_at") or "", reverse=True)
        following_data.sort(key=lambda x: not x["mutual"])

        followers_data = []
        for login in followers_logins:
            info        = following_state.get(login, {})
            followed_at = info.get("followed_at", "")
            mutual      = login in following_set
            followers_data.append({
                "login":    login,
                "mutual":   mutual,
                "time_str": f"you: {_relative_time(followed_at)}" if mutual and followed_at else "",
            })
        followers_data.sort(key=lambda x: not x["mutual"])

        self._people_data["following"] = following_data
        self._people_data["followers"] = followers_data

        self._render_people_list()
        self._set_status(
            f"Loaded {len(following_logins):,} following, {len(followers_logins):,} followers."
        )

    def _unfollow_selected(self):
        selected = [login for login, var in self._people_check_vars.items() if var.get()]
        if not selected:
            messagebox.showinfo("Nothing selected", "Select at least one account to unfollow.")
            return
        preview = "\n".join(f"  \u2022 {l}" for l in selected[:10])
        if len(selected) > 10:
            preview += f"\n  \u2026and {len(selected) - 10} more"
        if not messagebox.askyesno(
            "Confirm Unfollow",
            f"Unfollow {len(selected)} account(s)?\n\n{preview}",
        ):
            return

        env   = {**load_env(), **os.environ}
        token = env.get("GH_TOKEN", "").strip()
        if not token:
            messagebox.showerror("Missing credentials", "GH_TOKEN is not configured.")
            return

        self._people_unfollow_btn.config_state(disabled=True)
        self._people_refresh_btn.config_state(disabled=True)
        self._set_status(f"Unfollowing {len(selected)} accounts...")

        def _do():
            import requests as _req
            hdrs = {
                "Authorization": f"token {token}",
                "Accept": "application/vnd.github.v3+json",
            }
            success, failed = [], []
            for idx, login in enumerate(selected):
                while True:
                    try:
                        r = _req.delete(
                            f"https://api.github.com/user/following/{login}",
                            headers=hdrs, timeout=15,
                        )
                    except Exception:
                        failed.append(login)
                        break
                    if r.status_code == 401:
                        self.after(0, lambda: self._set_status(
                            "401 Unauthorized — token is invalid or expired. Update GH_TOKEN in Settings."
                        ))
                        failed.extend(selected[idx:])
                        self.after(0, lambda: self._unfollow_done(success, failed))
                        return
                    if r.status_code == 429 or (
                        r.status_code == 403 and "rate limit" in r.text.lower()
                    ):
                        wait = int(r.headers.get("Retry-After", 60))
                        self.after(0, lambda w=wait: self._set_status(
                            f"Rate limited — waiting {w}s before continuing..."
                        ))
                        time.sleep(wait)
                        continue
                    (success if r.status_code in (204, 404) else failed).append(login)
                    break
                time.sleep(0.5)
            self.after(0, lambda: self._unfollow_done(success, failed))

        threading.Thread(target=_do, daemon=True).start()

    def _unfollow_done(self, success: list, failed: list):
        if success:
            state = load_state()
            for login in success:
                state["following"].pop(login, None)
            state["stats"]["unfollowed"] = state["stats"].get("unfollowed", 0) + len(success)
            STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
            STATE_FILE.write_text(json.dumps(state, indent=2), encoding="utf-8")

            success_set = set(success)
            self._people_data["following"] = [
                e for e in self._people_data["following"]
                if e["login"] not in success_set
            ]

        self._render_people_list()
        self._people_unfollow_btn.config_state(disabled=False)
        self._people_refresh_btn.config_state(disabled=False)

        msg = f"Unfollowed {len(success)}"
        if failed:
            msg += f"  ({len(failed)} failed)"
        self._set_status(msg)
        self._refresh_dashboard()

    # ── Settings page ──────────────────────────────────────────────────────────

    def _build_settings_page(self):
        page = tk.Frame(self._pane, bg=C_BG)
        self._pages["settings"] = page
        self._page_header(page, "Settings",
                          "Saved to a local .env file - never committed to git.")

        # Scrollable container
        outer = tk.Frame(page, bg=C_BG)
        outer.pack(fill="both", expand=True)

        canvas = tk.Canvas(outer, bg=C_BG, highlightthickness=0)
        scrollbar = tk.Scrollbar(outer, orient="vertical", command=canvas.yview)
        canvas.configure(yscrollcommand=scrollbar.set)
        scrollbar.pack(side="right", fill="y")
        canvas.pack(side="left", fill="both", expand=True)

        content = tk.Frame(canvas, bg=C_BG)
        _win_id = canvas.create_window((0, 0), window=content, anchor="nw")

        def _on_content_resize(e):
            canvas.configure(scrollregion=canvas.bbox("all"))

        def _on_canvas_resize(e):
            canvas.itemconfig(_win_id, width=e.width)

        def _on_enter(_e):
            canvas.bind_all("<MouseWheel>",
                            lambda e: canvas.yview_scroll(int(-1 * e.delta / 120), "units"))

        def _on_leave(_e):
            canvas.unbind_all("<MouseWheel>")

        content.bind("<Configure>", _on_content_resize)
        canvas.bind("<Configure>", _on_canvas_resize)
        canvas.bind("<Enter>", _on_enter)
        canvas.bind("<Leave>", _on_leave)

        inner = tk.Frame(content, bg=C_BG)
        inner.pack(fill="x", padx=20, pady=20)

        card = self._card(inner, fill="x")
        form = tk.Frame(card, bg=C_SURFACE)
        form.pack(fill="x", padx=24, pady=16)

        # Fixed pixel width for every label+tooltip block, so the "?" always
        # sits a consistent, small distance from its word (sized to the text,
        # not padded to it) while every entry box still starts at the same
        # x position regardless of how long that row's label is.
        LABEL_W = 175

        # Fields: (env_key, label, secret, default, tip, mode)  or  (None, "SECTION", ...)
        # mode: "wide" (full-width entry), "narrow" (compact, paired 2-per-row),
        # or "multiline" (wrapping text box for values that can grow long).
        FIELDS = [
            (None, "AUTHENTICATION", None, None, None, None),
            ("GH_TOKEN",    "GitHub Token",    True,  "",
             "Personal Access Token with user:follow scope. "
             "Stored locally in .env, never shared.", "wide"),
            ("GH_USERNAME", "GitHub Username", False, "",
             "Your exact GitHub username (case-insensitive).", "wide"),

            (None, "FOLLOW BEHAVIOR", None, None, None, None),
            ("FOLLOW_LIMIT",   "Follow Limit",        False, "150",
             "Maximum new follows per run. Keep at or below 150/day.", "narrow"),
            ("UNFOLLOW_HOURS", "Unfollow After (hrs)", False, "24",
             "Hours before unfollowing a non-reciprocator.", "narrow"),
            ("WHITELIST",      "Whitelist",            False, "",
             "Comma-separated usernames to never unfollow.", "multiline"),

            (None, "QUALITY FILTERS", None, None, None, None),
            ("ACTIVITY_DAYS",        "Activity Days",    False, "30",
             "Skip users who haven't pushed a commit in this many days.", "narrow"),
            ("MIN_FOLLOWERS",        "Min Followers",    False, "1",
             "Only follow users with at least this many followers.", "narrow"),
            ("SEARCH_MIN_FOLLOWERS", "Search Min Followers", False, "10",
             "Pre-filter the user search query: only fetch candidates with at least this many followers. "
             "Reduces wasted API calls on ghost accounts. Sweet spot: 10–50.", "narrow"),
            ("SEARCH_MAX_FOLLOWERS", "Search Max Followers", False, "1000",
             "Pre-filter the user search query: skip candidates above this follower count. "
             "High-follower accounts rarely follow back. Sweet spot: 500–2000.", "narrow"),
            ("MAX_REPOS",            "Max Repos",        False, "500",
             "Skip accounts with more public repos than this. Catches mass-forking bots.", "narrow"),
            ("MAX_FF_RATIO",         "Max F/F Ratio",    False, "10.0",
             "Skip accounts whose following/followers ratio exceeds this. "
             "Filters follow-farmers.", "narrow"),
            ("MIN_ACCOUNT_AGE_DAYS", "Min Account Age",  False, "30",
             "Skip accounts newer than this many days. Filters throwaway accounts.", "narrow"),
            ("CACHE_DAYS",           "Cache Days",       False, "7",
             "Days to cache quality check results to save API quota.", "narrow"),
        ]

        self._settings_vars = {}
        self._settings_widgets = {}
        row_idx = [0]           # boxed so nested helpers can mutate it
        first_section = [True]
        pending_narrow = [None]

        def _make_entry(parent, key, secret, default, width):
            var = tk.StringVar(value=default)
            self._settings_vars[key] = var
            return tk.Entry(
                parent, textvariable=var, show="*" if secret else "",
                font=F_UI, width=width,
                bg=C_BG, fg=C_TEXT, relief="flat",
                highlightthickness=1,
                highlightbackground=C_SEP,
                highlightcolor=C_ACCENT,
                insertbackground=C_TEXT,
            )

        def _place_narrow(item, slot):
            key, label, secret, default, tooltip = item
            lbl_col, entry_col = (0, 1) if slot == 0 else (2, 3)
            lbl_padx = (0, 10) if slot == 0 else (28, 10)
            lbl_f = tk.Frame(form, bg=C_SURFACE, width=LABEL_W, height=24)
            lbl_f.pack_propagate(False)
            lbl_f.grid(row=row_idx[0], column=lbl_col, padx=lbl_padx, pady=6, sticky="w")
            tk.Label(lbl_f, text=label, font=F_UI, bg=C_SURFACE,
                     fg=C_TEXT, anchor="w").pack(side="left")
            _tip(lbl_f, tooltip, bg=C_SURFACE).pack(side="left", padx=(4, 0))
            _make_entry(form, key, secret, default, width=10).grid(
                row=row_idx[0], column=entry_col, pady=6, sticky="w")

        def _flush_pending():
            if pending_narrow[0] is not None:
                _place_narrow(pending_narrow[0], 0)
                pending_narrow[0] = None
                row_idx[0] += 1

        def _tab_to_next_widget(e):
            e.widget.tk_focusNext().focus()
            return "break"   # Text's default Tab behavior inserts a tab char

        for item in FIELDS:
            key, label, secret, default, tooltip, mode = item

            if key is None:
                _flush_pending()
                # Section separator + heading
                if not first_section[0]:
                    tk.Frame(form, bg=C_SEP, height=1).grid(
                        row=row_idx[0], column=0, columnspan=4,
                        sticky="ew", pady=(12, 6)
                    )
                    row_idx[0] += 1
                first_section[0] = False
                tk.Label(form, text=label, font=("Segoe UI", 8, "bold"),
                         bg=C_SURFACE, fg=C_MUTED).grid(
                    row=row_idx[0], column=0, columnspan=4,
                    sticky="w", pady=(0, 4)
                )
                row_idx[0] += 1
                continue

            if mode == "narrow":
                if pending_narrow[0] is None:
                    pending_narrow[0] = (key, label, secret, default, tooltip)
                else:
                    _place_narrow(pending_narrow[0], 0)
                    _place_narrow((key, label, secret, default, tooltip), 1)
                    pending_narrow[0] = None
                    row_idx[0] += 1
                continue

            _flush_pending()

            lbl_f = tk.Frame(form, bg=C_SURFACE, width=LABEL_W, height=24)
            lbl_f.pack_propagate(False)
            lbl_f.grid(row=row_idx[0], column=0, padx=(0, 16), pady=6,
                       sticky="nw" if mode == "multiline" else "w")
            tk.Label(lbl_f, text=label, font=F_UI, bg=C_SURFACE,
                     fg=C_TEXT, anchor="w").pack(side="left")
            _tip(lbl_f, tooltip, bg=C_SURFACE).pack(side="left", padx=(4, 0))

            if mode == "multiline":
                txt = tk.Text(
                    form, font=F_UI, height=3, wrap="word",
                    bg=C_BG, fg=C_TEXT, relief="flat",
                    highlightthickness=1, highlightbackground=C_SEP,
                    highlightcolor=C_ACCENT, insertbackground=C_TEXT,
                    padx=6, pady=4,
                )
                txt.insert("1.0", default)
                txt.bind("<Tab>", _tab_to_next_widget)
                self._settings_widgets[key] = txt
                txt.grid(row=row_idx[0], column=1, columnspan=3, pady=6, sticky="ew")
            else:
                _make_entry(form, key, secret, default, width=36).grid(
                    row=row_idx[0], column=1, columnspan=3, pady=6, sticky="ew")
            row_idx[0] += 1

        _flush_pending()

        # Quality unfollow toggle
        tk.Frame(form, bg=C_SEP, height=1).grid(
            row=row_idx[0], column=0, columnspan=4, sticky="ew", pady=(12, 6)
        )
        row_idx[0] += 1
        qu_f = tk.Frame(form, bg=C_SURFACE, width=LABEL_W, height=24)
        qu_f.pack_propagate(False)
        qu_f.grid(row=row_idx[0], column=0, padx=(0, 16), pady=6, sticky="w")
        tk.Label(qu_f, text="Quality Unfollow", font=F_UI, bg=C_SURFACE,
                 fg=C_TEXT, anchor="w").pack(side="left")
        _tip(qu_f,
             "When enabled, Run Unfollow also cleans up existing follows that fail "
             "quality criteria. First run is slow; subsequent runs use the cache.",
             bg=C_SURFACE).pack(side="left", padx=(4, 0))
        self._qu_var = tk.BooleanVar()
        tk.Checkbutton(form, variable=self._qu_var,
                       bg=C_SURFACE, activebackground=C_SURFACE,
                       fg=C_TEXT, activeforeground=C_TEXT,
                       selectcolor=C_BG,
                       relief="flat").grid(row=row_idx[0], column=1, pady=6, sticky="w")
        form.columnconfigure(1, weight=1)
        form.columnconfigure(3, weight=1)

        # Save / load
        tk.Frame(card, bg=C_SEP, height=1).pack(fill="x", padx=24)
        btn_row = tk.Frame(card, bg=C_SURFACE)
        btn_row.pack(fill="x", padx=24, pady=16)
        RoundedButton(btn_row, "Save Settings", self._save_settings,
                      width=130, height=34).pack(side="left", padx=(0, 12))
        load_lbl = tk.Label(btn_row, text="Load from .env", font=F_SM,
                            fg=C_ACCENT, bg=C_SURFACE, cursor="hand2")
        load_lbl.pack(side="left")
        load_lbl.bind("<Button-1>", lambda _e: self._load_settings())

        self._settings_msg = tk.Label(card, text="", font=F_SM, bg=C_SURFACE)
        self._settings_msg.pack(anchor="w", padx=24, pady=(0, 12))

    def _save_settings(self):
        _INT_FIELDS   = {"FOLLOW_LIMIT", "UNFOLLOW_HOURS", "ACTIVITY_DAYS",
                         "MIN_FOLLOWERS", "MAX_REPOS", "MIN_ACCOUNT_AGE_DAYS", "CACHE_DAYS",
                         "SEARCH_MIN_FOLLOWERS", "SEARCH_MAX_FOLLOWERS"}
        _FLOAT_FIELDS = {"MAX_FF_RATIO"}
        env = {k: v.get() for k, v in self._settings_vars.items()}
        for k, w in self._settings_widgets.items():
            # Collapse any stray newline (e.g. accidental Enter) - it's a
            # comma-separated list, not meant to be multi-line data.
            env[k] = w.get("1.0", "end-1c").replace("\n", " ").strip()
        for k in _INT_FIELDS:
            val = env.get(k, "").strip()
            if val:
                try:
                    int(val)
                except ValueError:
                    self._settings_msg.config(
                        text=f"{k} must be a whole number (got '{val}')", fg=C_DANGER)
                    return
        for k in _FLOAT_FIELDS:
            val = env.get(k, "").strip()
            if val:
                try:
                    float(val)
                except ValueError:
                    self._settings_msg.config(
                        text=f"{k} must be a number (got '{val}')", fg=C_DANGER)
                    return
        env["QUALITY_UNFOLLOW"] = "true" if self._qu_var.get() else "false"
        save_env(env)
        self._settings_msg.config(text=f"Saved to {ENV_FILE}", fg=C_SUCCESS)
        self._set_status("Settings saved.")
        self._run_checks()

    def _load_settings(self):
        env = load_env()
        for k, var in self._settings_vars.items():
            var.set(env.get(k, var.get()))
        for k, w in self._settings_widgets.items():
            current = w.get("1.0", "end-1c")
            w.delete("1.0", "end")
            w.insert("1.0", env.get(k, current))
        self._qu_var.set(env.get("QUALITY_UNFOLLOW", "false").lower() == "true")
        self._settings_msg.config(text=f"Loaded from {ENV_FILE}", fg=C_MUTED)

    # ── Shared ─────────────────────────────────────────────────────────────────

    def _set_status(self, msg: str):
        self._status_var.set(msg)

    def _on_open(self):
        self._run_checks()
        self._refresh_dashboard()
        self._load_settings()

    def _on_close(self):
        if self._running:
            if not messagebox.askyesno(
                "Run in progress",
                "A run is still in progress.\n\n"
                "Closing now will stop it immediately — any follows or unfollows "
                "already made this run will NOT be saved to state.json.\n\n"
                "Close anyway?",
            ):
                return
            # Request a graceful stop so the worker thread can exit cleanly
            self._stop_run()
        self.destroy()


if __name__ == "__main__":
    App().mainloop()