RCR

#!/usr/bin/env python3
"""
RCR v0.5  —  RuleFlow Chain Runner (Cross-Platform)
Graphical front-end for: rulest_v2.py -> concentrator.py -> ranker.py
Fully compatible with Windows 10+ and Linux (X11/Wayland).
"""

import tkinter as tk
from tkinter import ttk, filedialog, messagebox, scrolledtext
import subprocess
import threading
import os
import sys
import glob
import shlex
import re
import queue
import time
import gc
import hashlib
from dataclasses import dataclass
from typing import Optional, List, Tuple, Callable, Dict
from collections import defaultdict

# ── Platform bootstrap ─────────────────────────────────────────────────────

def _set_dpi_awareness() -> None:
    """Enable DPI awareness on Windows so the GUI renders correctly on
    high-DPI displays (4K monitors, laptops with scaling > 100%)."""
    if sys.platform == "win32":
        try:
            import ctypes
            ctypes.windll.shcore.SetProcessDpiAwareness(1)  # type: ignore[attr-defined]
        except Exception:
            try:
                ctypes.windll.user32.SetProcessDPIAware()  # type: ignore[attr-defined]
            except Exception:
                pass


_set_dpi_awareness()

# On Windows, force UTF-8 for stdin/stdout/stderr so that rule files,
# wordlists and log output containing non-ASCII characters are handled
# identically to Linux.
if sys.platform == "win32":
    import io
    if sys.stdout.encoding != "utf-8":
        try:
            sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8")
            sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding="utf-8")
        except Exception:
            pass

# SCRIPT_DIR must resolve correctly whether we are running from source or
# from a frozen PyInstaller/pex bundle.
if getattr(sys, "frozen", False):
    SCRIPT_DIR = os.path.dirname(sys.executable)
else:
    SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))

APP_TITLE = "RCR - RuleFlow Chain Runner"

# ── Cross-platform font resolution ─────────────────────────────────────────

if sys.platform == "win32":
    FONT_UI = "Segoe UI"
    FONT_MONO = "Consolas"
else:
    # Linux / macOS fallbacks.  Tkinter will degrade gracefully if the
    # first choice is missing, but DejaVu is present on almost all distros.
    FONT_UI = "DejaVu Sans"
    FONT_MONO = "DejaVu Sans Mono"


def ui_font(size: int = 10, weight: str = "normal") -> Tuple[str, int, str]:
    return (FONT_UI, size, weight)


def mono_font(size: int = 9) -> Tuple[str, int]:
    return (FONT_MONO, size)


# ── Theme ──────────────────────────────────────────────────────────────────

@dataclass(frozen=True)
class Theme:
    name: str = "dark"
    bg: str = "#0f1115"
    surface: str = "#181a20"
    card: str = "#1e2128"
    elevated: str = "#252830"
    border: str = "#2f333c"
    fg: str = "#e4e6eb"
    fg2: str = "#8b909e"
    accent: str = "#58a6ff"
    accent_hover: str = "#79b8ff"
    success: str = "#3fb950"
    warning: str = "#d29922"
    danger: str = "#f85149"
    info: str = "#a371f7"
    log_bg: str = "#0d0f14"


DARK_THEME = Theme(
    name="dark",
    bg="#0f1115", surface="#181a20", card="#1e2128", elevated="#252830",
    border="#2f333c", fg="#e4e6eb", fg2="#8b909e", accent="#58a6ff",
    accent_hover="#79b8ff", success="#3fb950", warning="#d29922",
    danger="#f85149", info="#a371f7", log_bg="#0d0f14",
)

LIGHT_THEME = Theme(
    name="light",
    bg="#f4f5f7", surface="#ffffff", card="#ffffff", elevated="#eef1f5",
    border="#d7dbe1", fg="#1b1e24", fg2="#5b6270", accent="#2563eb",
    accent_hover="#3b76ea", success="#1a7f37", warning="#9a6700",
    danger="#cf222e", info="#7c3aed", log_bg="#fbfbfc",
)


class _ThemeProxy:
    """Lets the rest of the codebase keep using `THEME.xxx` unmodified while
    the active palette can be swapped at runtime (dark/light mode)."""

    def __init__(self, initial: Theme):
        object.__setattr__(self, "_current", initial)

    @property
    def current(self) -> Theme:
        return self._current  # type: ignore[has-type]

    def set(self, theme: Theme):
        object.__setattr__(self, "_current", theme)

    def __getattr__(self, item):
        return getattr(self._current, item)  # type: ignore[has-type]


THEME = _ThemeProxy(DARK_THEME)

# ── ANSI → tkinter mapping ─────────────────────────────────────────────────

# Palette used when the log panel has a dark background (default).
ANSI_COLOURS_DARK = {
    "30": "#2f333c", "31": "#f85149", "32": "#3fb950", "33": "#d29922",
    "34": "#58a6ff", "35": "#bc8cff", "36": "#39c5cf", "37": "#e4e6eb",
    "90": "#6e7681", "91": "#ff7b72", "92": "#7ee787", "93": "#ffa657",
    "94": "#79b8ff", "95": "#d2a8ff", "96": "#56d4dd", "97": "#ffffff",
}
# Palette used when the log panel has a light background — the dark palette's
# near-white/pastel tones (e.g. codes 37/97/90/94/95/96) are almost invisible
# on a light background, so these are darkened/saturated for contrast.
ANSI_COLOURS_LIGHT = {
    "30": "#1b1e24", "31": "#cf222e", "32": "#1a7f37", "33": "#9a6700",
    "34": "#2563eb", "35": "#8250df", "36": "#0969a2", "37": "#57606a",
    "90": "#6e7681", "91": "#c4262e", "92": "#116329", "93": "#7d4e00",
    "94": "#1d4ed8", "95": "#6639ba", "96": "#0c6b8e", "97": "#1b1e24",
}
ANSI_RE = re.compile(r'\x1b\[([0-9;]*)m')


def active_ansi_colours() -> dict:
    """Returns the ANSI colour palette matching the currently active theme."""
    return ANSI_COLOURS_LIGHT if THEME.current.name == "light" else ANSI_COLOURS_DARK


def strip_ansi(text: str) -> str:
    return ANSI_RE.sub("", text)


def parse_ansi_segments(text: str) -> List[Tuple[str, Optional[str]]]:
    """Split text into (chunk, colour_hex) segments."""
    colours = active_ansi_colours()
    segments = []
    pos = 0
    current_fg = None
    for m in ANSI_RE.finditer(text):
        if m.start() > pos:
            segments.append((text[pos:m.start()], current_fg))
        codes = m.group(1).split(";") if m.group(1) else ["0"]
        for code in codes:
            if code in ("0", ""):
                current_fg = None
            elif code in colours:
                current_fg = colours[code]
        pos = m.end()
    if pos < len(text):
        segments.append((text[pos:], current_fg))
    return segments


# tqdm (and similar) progress bars are rendered by the *external* tool with
# whatever width it decides on, which varies with description length, digit
# counts in the counters, etc. — making the log look ragged/uneven. Since we
# can't change how those tools draw their bars, we detect the "NN%|<bar>|"
# segment and re-render just that portion at a fixed width, so every bar in
# the log (regardless of which stage or tool produced it) lines up evenly.
_TQDM_BAR_RE = re.compile(r'(\d{1,3})%\|([^|]*)\|')
PROGRESS_BAR_WIDTH = 30


def normalize_progress_bars(text: str) -> str:
    def _replace(m: "re.Match") -> str:
        try:
            pct = max(0, min(100, int(m.group(1))))
        except ValueError:
            return m.group(0)
        filled = round(PROGRESS_BAR_WIDTH * pct / 100)
        bar = "█" * filled + " " * (PROGRESS_BAR_WIDTH - filled)
        return f"{pct}%|{bar}|"

    return _TQDM_BAR_RE.sub(_replace, text)


# ── Theme switching (light / dark) ─────────────────────────────────────────

_TK_COLOR_OPTIONS = (
    "bg", "background", "fg", "foreground",
    "activebackground", "activeforeground", "disabledforeground",
    "highlightbackground", "highlightcolor",
    "insertbackground", "selectbackground", "selectforeground",
    "troughcolor", "selectcolor",
)


def _theme_color_map(old: Theme, new: Theme) -> dict:
    fields = ("bg", "surface", "card", "elevated", "border", "fg", "fg2",
              "accent", "accent_hover", "success", "warning", "danger", "info")
    return {getattr(old, f): getattr(new, f) for f in fields}


def _retheme_widget(widget, color_map: dict):
    for opt in _TK_COLOR_OPTIONS:
        try:
            cur = widget.cget(opt)
        except Exception:
            continue
        if cur in color_map:
            try:
                widget.configure(**{opt: color_map[cur]})
            except Exception:
                pass
    # ModernButton caches its own hover/base colours outside of tk's option
    # database, so those need to be remapped too or hovering will revert them.
    base_bg = getattr(widget, "_base_bg", None)
    if base_bg in color_map:
        widget._base_bg = color_map[base_bg]
    hover_bg = getattr(widget, "_hover_bg", None)
    if hover_bg in color_map:
        widget._hover_bg = color_map[hover_bg]


def _retheme_tree(widget, color_map: dict):
    _retheme_widget(widget, color_map)
    try:
        children = widget.winfo_children()
    except Exception:
        children = []
    for child in children:
        _retheme_tree(child, color_map)


OOM_PATTERNS = re.compile(
    r"memoryerror|out of memory|bad_alloc|allocation failed|"
    r"failed to allocate|cl_mem|clerror|memory allocation failed|"
    r"gpu memory allocation failed|killed\b",
    re.IGNORECASE,
)


# ==============================================================================
#  CONCENTRATOR-COMPATIBLE RULE HELPERS  (copied from concentrator.py)
# ==============================================================================

_NEVER_PRODUCE_OPS = frozenset({'M', '4', '6', 'X', '<', '>', '!', '/', '(', ')', '=', '%', 'Q'})

_OPERATOR_ARGS: Dict[str, List[str]] = {
    ':': [], 'l': [], 'u': [], 'c': [], 'C': [], 't': [], 'r': [], 'd': [], 'f': [],
    '{': [], '}': [], '[': [], ']': [], 'q': [], 'k': [], 'K': [], 'E': [],
    'T': ['num'], 'p': ['num'], 'D': ['num'], 'z': ['num'], 'Z': ['num'], "'": ['num'],
    '+': ['num'], '-': ['num'], '.': ['num'], ',': ['num'], 'L': ['num'], 'R': ['num'],
    'y': ['num'], 'Y': ['num'], '<': ['num'], '>': ['num'], '_': ['num'],
    'x': ['num', 'num'], 'O': ['num', 'num'], '*': ['num', 'num'],
    '$': ['char'], '^': ['char'], '@': ['char'], 'e': ['char'],
    's': ['char', 'char'],
    'i': ['num', 'char'], 'o': ['num', 'char'], '3': ['num', 'char'],
}


def _build_token_regex() -> re.Pattern:
    patterns = []
    for op, args in _OPERATOR_ARGS.items():
        escaped = re.escape(op)
        arg_pat = ''.join('[0-9A-Z]' if a == 'num' else '[ -~]' for a in args)
        patterns.append(escaped + arg_pat)
    patterns.sort(key=len, reverse=True)
    return re.compile('|'.join(patterns))


_TOKEN_REGEX = _build_token_regex()


def _has_banned_op(rule: str) -> bool:
    tokens = _TOKEN_REGEX.findall(rule)
    return any(t[0] in _NEVER_PRODUCE_OPS for t in tokens)


def _i36(s: str) -> int:
    return int(s, 36)


def is_valid_hashcat_rule(rule: str) -> bool:
    if _has_banned_op(rule):
        return False
    if not rule.strip():
        return False
    pos = 0
    cnt = 0
    n = len(rule)

    def is_digit(c: str) -> bool:
        return ('0' <= c <= '9') or ('A' <= c <= 'Z')

    while pos < n:
        c = rule[pos]
        if c == ' ':
            pos += 1
            continue
        if c in ('p', 'z', 'Z'):
            cnt += 1
            pos += 1
            if pos < n and is_digit(rule[pos]):
                pos += 1
            continue
        if c in (':', 'l', 'u', 'c', 'C', 't', 'r', 'd', 'f', 'q', 'k', 'K',
                 'E', '{', '}', '[', ']'):
            pos += 1
            cnt += 1
            continue
        if c in ('T', 'D', 'L', 'R', '+', '-', '.', ',', "'", 'y', 'Y', '_'):
            pos += 1
            if pos >= n or not is_digit(rule[pos]):
                return False
            pos += 1
            cnt += 1
            continue
        if c in ('i', 'o', '3'):
            pos += 1
            if pos >= n or not is_digit(rule[pos]):
                return False
            pos += 1
            if pos >= n:
                return False
            pos += 1
            cnt += 1
            continue
        if c in ('x', '*', 'O'):
            pos += 1
            if pos >= n or not is_digit(rule[pos]):
                return False
            pos += 1
            if pos >= n or not is_digit(rule[pos]):
                return False
            pos += 1
            cnt += 1
            continue
        if c == 's':
            pos += 1
            if pos + 1 >= n:
                return False
            pos += 2
            cnt += 1
            continue
        if c in ('@', 'e', '$', '^'):
            pos += 1
            if pos >= n:
                return False
            pos += 1
            cnt += 1
            continue
        return False
    return 1 <= cnt <= 255


# ── Simplified RuleEngine (from concentrator) ────────────────────────────────

class _RuleEngine:
    def __init__(self, rules: List[str]) -> None:
        self._token_lists = [_TOKEN_REGEX.findall(r) for r in rules]
        self.memorized = ''

    def apply(self, string: str) -> str:
        word = string
        self.memorized = ''
        for tokens in self._token_lists:
            for token in tokens:
                try:
                    word = self._dispatch(token, word)
                except Exception:
                    pass
        return word

    def _dispatch(self, token: str, word: str) -> str:
        op = token[0]
        args = token[1:]
        if op == ':':
            return word
        elif op == 'l':
            return word.lower()
        elif op == 'u':
            return word.upper()
        elif op == 'c':
            return word.capitalize()
        elif op == 'C':
            return word.capitalize().swapcase()
        elif op == 't':
            return word.swapcase()
        elif op == 'T':
            n = _i36(args[0])
            if n >= len(word):
                return word
            return word[:n] + word[n].swapcase() + word[n + 1:]
        elif op == 'r':
            return word[::-1]
        elif op == 'd':
            return word + word
        elif op == 'p':
            if not args:
                return word
            return word * (_i36(args[0]) + 1)
        elif op == 'f':
            return word + word[::-1]
        elif op == '{':
            return (word[1:] + word[0]) if word else word
        elif op == '}':
            return (word[-1] + word[:-1]) if word else word
        elif op == '$':
            return word + args[0]
        elif op == '^':
            return args[0] + word
        elif op == '[':
            return word[1:]
        elif op == ']':
            return word[:-1]
        elif op == 'D':
            n = _i36(args[0])
            return word[:n] + word[n + 1:] if n < len(word) else word
        elif op == 'x':
            n, m = _i36(args[0]), _i36(args[1])
            if n < 0 or m < 0:
                return word
            return word[n:n + m]
        elif op == 'O':
            n, m = _i36(args[0]), _i36(args[1])
            if n < 0 or m < 0 or n >= len(word):
                return word
            return word[:n] + word[n + m:]
        elif op == 'i':
            pos = min(_i36(args[0]), len(word))
            return word[:pos] + args[1] + word[pos:]
        elif op == 'o':
            pos = _i36(args[0])
            return word[:pos] + args[1] + word[pos + 1:] if pos < len(word) else word
        elif op == "'":
            return word[:_i36(args[0])]
        elif op == 's':
            return word.replace(args[0], args[1])
        elif op == '@':
            return word.replace(args[0], '')
        elif op == 'z':
            n = _i36(args[0])
            return word[0] * n + word if word else ''
        elif op == 'Z':
            n = _i36(args[0])
            return word + word[-1] * n if word else ''
        elif op == 'q':
            return ''.join(c * 2 for c in word)
        elif op == 'E':
            out = []
            cap = True
            for ch in word:
                if cap and ch.islower():
                    out.append(ch.upper())
                elif not cap and ch.isupper():
                    out.append(ch.lower())
                else:
                    out.append(ch)
                cap = (ch == ' ')
            return ''.join(out)
        elif op == 'e':
            sep = args[0]
            out = []
            cap = True
            for ch in word:
                if cap and ch.islower():
                    out.append(ch.upper())
                elif not cap and ch.isupper():
                    out.append(ch.lower())
                else:
                    out.append(ch)
                cap = (ch == sep)
            return ''.join(out)
        else:
            return word


# ── Memory Monitor ─────────────────────────────────────────────────────────

class MemoryMonitor:
    def __init__(self, threshold_mb: float = 6144.0):
        self.threshold_mb = threshold_mb
        self._have_psutil = False
        try:
            import psutil
            self._have_psutil = True
            self._psutil = psutil
            self._self_proc = psutil.Process()
        except ImportError:
            self._psutil = None
            self._self_proc = None
        self._child_pid: Optional[int] = None

    def set_child_pid(self, pid: Optional[int]):
        self._child_pid = pid

    def current_mb(self) -> float:
        if not self._have_psutil:
            return 0.0
        total = 0.0
        try:
            total += self._self_proc.memory_info().rss
        except Exception:
            pass
        if self._child_pid:
            try:
                p = self._psutil.Process(self._child_pid)
                total += p.memory_info().rss
                for c in p.children(recursive=True):
                    try:
                        total += c.memory_info().rss
                    except Exception:
                        pass
            except Exception:
                pass
        return total / (1024 * 1024)

    def is_under_pressure(self) -> bool:
        return self.current_mb() > self.threshold_mb

    def format(self) -> str:
        mb = self.current_mb()
        if not self._have_psutil:
            return "n/a (psutil not installed)"
        if mb > 1024:
            return f"{mb/1024:.2f} GB"
        return f"{mb:.0f} MB"


# ── Bounded Log Queue ──────────────────────────────────────────────────────

class BoundedLogQueue:
    def __init__(self, maxsize: int = 4000):
        self._queue: queue.Queue = queue.Queue(maxsize=maxsize)
        self._dropped = 0
        self._lock = threading.Lock()

    def put(self, item, block: bool = False, timeout: float = 0.1) -> bool:
        try:
            self._queue.put(item, block=block, timeout=timeout)
            return True
        except queue.Full:
            with self._lock:
                self._dropped += 1
            return False

    def get_nowait(self):
        return self._queue.get_nowait()

    def clear_dropped(self) -> int:
        with self._lock:
            d = self._dropped
            self._dropped = 0
            return d


# ── Process Wrapper ────────────────────────────────────────────────────────

class ManagedProcess:
    def __init__(self):
        self._proc: Optional[subprocess.Popen] = None
        self._terminated = False
        self._lock = threading.Lock()
        self._queue: queue.Queue = queue.Queue()
        self._reader_thread: Optional[threading.Thread] = None

    @property
    def pid(self) -> Optional[int]:
        return self._proc.pid if self._proc else None

    def start(self, cmd: List[str], cwd: str, env: dict) -> bool:
        with self._lock:
            if self._proc is not None:
                return False
            try:
                popen_kwargs = {
                    "stdin": subprocess.DEVNULL,
                    "stdout": subprocess.PIPE,
                    "stderr": subprocess.STDOUT,
                    "bufsize": 0,
                    "cwd": cwd,
                    "env": env,
                }
                # On Windows, running from a tkinter GUI without a console
                # attached will cause every subprocess to spawn a visible CMD
                # window.  CREATE_NO_WINDOW suppresses that.
                if sys.platform == "win32":
                    popen_kwargs["creationflags"] = subprocess.CREATE_NO_WINDOW  # type: ignore[attr-defined]

                self._proc = subprocess.Popen(cmd, **popen_kwargs)
                self._terminated = False
                self._queue = queue.Queue()
                self._reader_thread = threading.Thread(target=self._reader_loop, daemon=True)
                self._reader_thread.start()
                return True
            except Exception as e:
                print(f"Failed to start process: {e}", file=sys.stderr)
                return False

    def _reader_loop(self, chunk_size: int = 4096):
        if self._proc is None or self._proc.stdout is None:
            self._queue.put(None)
            return
        buf = ""
        decoder_leftover = b""
        while True:
            if self._terminated:
                break
            try:
                raw = self._proc.stdout.read(chunk_size)
            except (OSError, ValueError):
                break
            if not raw:
                break

            raw = decoder_leftover + raw
            try:
                text = raw.decode("utf-8")
                decoder_leftover = b""
            except UnicodeDecodeError as e:
                text = raw[:e.start].decode("utf-8", errors="replace")
                decoder_leftover = raw[e.start:]

            buf += text
            while True:
                idx_n = buf.find("\n")
                idx_r = buf.find("\r")
                if idx_n == -1 and idx_r == -1:
                    break
                if idx_n != -1 and idx_r != -1:
                    idx = min(idx_n, idx_r)
                elif idx_n != -1:
                    idx = idx_n
                else:
                    idx = idx_r
                piece = buf[:idx]
                buf = buf[idx + 1:]
                if idx == idx_r and buf.startswith("\n"):
                    buf = buf[1:]
                self._queue.put(("line", piece))

        if buf:
            self._queue.put(("line", buf))
        self._queue.put(None)

    def iter_events(self, timeout: float = 0.3, chunk_size: int = 4096):
        while True:
            if self._terminated:
                break
            try:
                item = self._queue.get(timeout=timeout)
            except queue.Empty:
                if self._proc is not None and self._proc.poll() is not None:
                    while True:
                        try:
                            item = self._queue.get_nowait()
                        except queue.Empty:
                            return
                        if item is None:
                            return
                continue
            if item is None:
                break
            yield item

    def terminate(self, wait: float = 3.0) -> None:
        with self._lock:
            self._terminated = True
            if self._proc is None:
                return
            try:
                self._proc.terminate()
                try:
                    self._proc.wait(timeout=0.5)
                except subprocess.TimeoutExpired:
                    # On Windows, killing the parent often leaves orphaned
                    # child processes (e.g. Python multiprocessing workers).
                    # If psutil is available, walk the tree and kill them.
                    if sys.platform == "win32":
                        try:
                            import psutil
                            parent = psutil.Process(self._proc.pid)
                            for child in parent.children(recursive=True):
                                try:
                                    child.kill()
                                except psutil.NoSuchProcess:
                                    pass
                        except Exception:
                            pass
                    self._proc.kill()
                    self._proc.wait(timeout=wait)
            except Exception:
                pass
            finally:
                if self._proc and self._proc.stdout:
                    try:
                        self._proc.stdout.close()
                    except Exception:
                        pass
                self._proc = None

    @property
    def returncode(self) -> Optional[int]:
        with self._lock:
            if self._proc is None:
                return None
            return self._proc.poll()


# ── UI Helpers ───────────────────────────────────────────────────────────────

class ModernButton(tk.Button):
    def __init__(self, master, text="", command=None, variant="primary",
                 font=None, padx=None, pady=None, **kw):
        self.variant = variant
        colors = {
            "primary": (THEME.accent, "#0a0a0a", THEME.accent_hover),
            "danger": (THEME.danger, "#0a0a0a", "#ff7b72"),
            "secondary": (THEME.surface, THEME.fg, THEME.elevated),
            "ghost": (THEME.bg, THEME.fg2, THEME.surface),
        }
        bg, fg, hover_bg = colors.get(variant, colors["primary"])
        btn_font = font or ui_font(10, "bold" if variant == "primary" else "normal")
        btn_padx = padx if padx is not None else 14
        btn_pady = pady if pady is not None else 7
        super().__init__(
            master, text=text, command=command,
            bg=bg, fg=fg, activebackground=hover_bg, activeforeground=fg,
            disabledforeground="#5c6270",
            relief="flat", bd=0, cursor="hand2",
            font=btn_font, padx=btn_padx, pady=btn_pady,
            **kw
        )
        if variant != "primary":
            self.config(highlightbackground=THEME.border, highlightthickness=1)
        self._hover_bg = hover_bg
        self._base_bg = bg
        self.bind("<Enter>", self._on_enter)
        self.bind("<Leave>", self._on_leave)

    def _on_enter(self, _event=None):
        if self.cget("state") != "disabled":
            self.config(bg=self._hover_bg)

    def _on_leave(self, _event=None):
        if self.cget("state") != "disabled":
            self.config(bg=self._base_bg)


class Section(tk.Frame):
    def __init__(self, master, title: str, **kw):
        super().__init__(
            master, bg=THEME.card,
            highlightbackground=THEME.border, highlightthickness=1,
            padx=14, pady=10, **kw
        )
        tk.Label(
            self, text=title, bg=THEME.card, fg=THEME.accent,
            font=ui_font(10, "bold")
        ).pack(anchor="w", pady=(0, 8))
        self.body = tk.Frame(self, bg=THEME.card)
        self.body.pack(fill="both", expand=True)


class Expander(tk.Frame):
    def __init__(self, master, title: str, subtitle: str = "", start_open: bool = False, **kw):
        super().__init__(
            master, bg=THEME.card,
            highlightbackground=THEME.border, highlightthickness=1, **kw
        )
        self._open = tk.BooleanVar(value=start_open)

        head = tk.Frame(self, bg=THEME.card, cursor="hand2")
        head.pack(fill="x", padx=12, pady=8)

        self._arrow = tk.Label(head, text="▸", bg=THEME.card, fg=THEME.accent,
                                font=ui_font(10, "bold"), width=2)
        self._arrow.pack(side="left")

        titles = tk.Frame(head, bg=THEME.card)
        titles.pack(side="left", fill="x", expand=True)
        tk.Label(titles, text=title, bg=THEME.card, fg=THEME.fg,
                 font=ui_font(10, "bold"), anchor="w").pack(fill="x")
        if subtitle:
            tk.Label(titles, text=subtitle, bg=THEME.card, fg=THEME.fg2,
                      font=ui_font(8), anchor="w").pack(fill="x")

        self.body = tk.Frame(self, bg=THEME.card, padx=12, pady=10)

        for w in (head, self._arrow, titles):
            w.bind("<Button-1>", self._toggle)
        for child in titles.winfo_children():
            child.bind("<Button-1>", self._toggle)

        if start_open:
            self.body.pack(fill="x")
            self._arrow.config(text="▾")

    def _toggle(self, _=None):
        if self._open.get():
            self.body.pack_forget()
            self._arrow.config(text="▸")
        else:
            self.body.pack(fill="x")
            self._arrow.config(text="▾")
        self._open.set(not self._open.get())


class FilePicker(tk.Frame):
    def __init__(self, master, label: str, **kw):
        super().__init__(master, bg=THEME.card, **kw)
        tk.Label(self, text=label, bg=THEME.card, fg=THEME.fg2,
                 font=ui_font(9), width=18, anchor="w").pack(side="left")
        self.var = tk.StringVar()
        self.entry = tk.Entry(
            self, textvariable=self.var, bg=THEME.surface, fg=THEME.fg,
            insertbackground=THEME.accent, relief="flat", bd=0,
            highlightbackground=THEME.border, highlightthickness=1,
            font=mono_font()
        )
        self.entry.pack(side="left", fill="x", expand=True, padx=(0, 8), ipady=4)
        ModernButton(self, text="Browse", command=self._browse, variant="secondary").pack(side="left")

    def _browse(self):
        p = filedialog.askopenfilename()
        if p:
            self.var.set(p)

    def get(self) -> str:
        return self.var.get().strip()

    def set(self, value: str):
        self.var.set(value)


class ModernSlider(tk.Frame):
    def __init__(self, master, label: str, from_: float, to: float,
                 resolution: float, default: float, is_float: bool = False,
                 unit: str = "", **kw):
        super().__init__(master, bg=THEME.card, **kw)
        self.is_float = is_float
        tk.Label(self, text=label, bg=THEME.card, fg=THEME.fg2,
                 font=ui_font(9), width=24, anchor="w").pack(side="left")
        self.var = tk.DoubleVar(value=default)
        self.scale = tk.Scale(
            self, variable=self.var, from_=from_, to=to, resolution=resolution,
            orient="horizontal", bg=THEME.card, fg=THEME.fg, troughcolor=THEME.surface,
            highlightthickness=0, showvalue=False, bd=0,
            activebackground=THEME.accent, length=150, command=self._on_scale
        )
        self.scale.pack(side="left", padx=(0, 8))
        self.entry_var = tk.StringVar(value=self._fmt(default))
        self.entry = tk.Entry(
            self, textvariable=self.entry_var, bg=THEME.surface, fg=THEME.accent,
            insertbackground=THEME.accent, relief="flat", bd=0,
            highlightbackground=THEME.border, highlightthickness=1,
            font=mono_font(), width=9, justify="right"
        )
        self.entry.pack(side="left")
        self.entry.bind("<FocusOut>", self._on_entry)
        self.entry.bind("<Return>", self._on_entry)
        if unit:
            tk.Label(self, text=unit, bg=THEME.card, fg=THEME.fg2,
                     font=ui_font(8)).pack(side="left", padx=(4, 0))

    def _fmt(self, v) -> str:
        v = float(v)
        return f"{v:.1f}" if self.is_float else str(int(v))

    def _on_scale(self, v):
        self.entry_var.set(self._fmt(v))

    def _on_entry(self, _=None):
        try:
            v = float(self.entry_var.get())
            sc_from = float(self.scale.cget("from"))
            sc_to = float(self.scale.cget("to"))
            v = max(sc_from, min(v, sc_to))
            self.var.set(v)
            self.entry_var.set(self._fmt(v))
        except ValueError:
            self.entry_var.set(self._fmt(self.var.get()))

    def get(self) -> float:
        try:
            return float(self.entry_var.get())
        except ValueError:
            return float(self.var.get())

    def set(self, v: float):
        sc_from = float(self.scale.cget("from"))
        sc_to = float(self.scale.cget("to"))
        v = max(sc_from, min(v, sc_to))
        self.var.set(v)
        self.scale.set(v)
        self.entry_var.set(self._fmt(v))


class ModeCard(tk.Frame):
    def __init__(self, master, title: str, subtitle: str, value: str,
                 selected: bool = False, command: Optional[Callable] = None, **kw):
        super().__init__(
            master, bg=THEME.elevated if selected else THEME.card,
            highlightbackground=THEME.accent if selected else THEME.border,
            highlightthickness=2 if selected else 1,
            padx=12, pady=8, cursor="hand2", **kw
        )
        self.value = value
        self.command = command
        tk.Label(self, text=title, bg=self.cget("bg"),
                 fg=THEME.accent if selected else THEME.fg,
                 font=ui_font(10, "bold")).pack(anchor="w")
        tk.Label(self, text=subtitle, bg=self.cget("bg"), fg=THEME.fg2,
                 font=ui_font(8), justify="left").pack(anchor="w", pady=(3, 0))
        for w in [self] + list(self.winfo_children()):
            w.bind("<Button-1>", lambda _e: self.command and self.command(self.value))

    def set_selected(self, selected: bool):
        bg = THEME.elevated if selected else THEME.card
        fg = THEME.accent if selected else THEME.fg
        self.config(bg=bg, highlightbackground=THEME.accent if selected else THEME.border,
                    highlightthickness=2 if selected else 1)
        for child in self.winfo_children():
            child.config(bg=bg)
            if isinstance(child, tk.Label) and "bold" in str(child.cget("font")):
                child.config(fg=fg)


class StageCheck(tk.Frame):
    """A checkbox widget for toggling pipeline stages with a description."""
    def __init__(self, master, label: str, description: str, variable: tk.BooleanVar,
                 command: Optional[Callable] = None, **kw):
        super().__init__(master, bg=THEME.card, **kw)
        self.variable = variable
        self.command = command
        self.cb = tk.Checkbutton(
            self, text=label, variable=variable, bg=THEME.card, fg=THEME.fg,
            selectcolor=THEME.surface, activebackground=THEME.card,
            activeforeground=THEME.fg, font=ui_font(10, "bold"),
            command=self._on_toggle
        )
        self.cb.pack(anchor="w")
        tk.Label(self, text=description, bg=THEME.card, fg=THEME.fg2,
                 font=ui_font(8), justify="left", anchor="w").pack(anchor="w", padx=(24, 0))

    def _on_toggle(self):
        if self.command:
            self.command()


# ── Main Application ─────────────────────────────────────────────────────────

# Log display is kept unbounded per user preference — the queue that feeds
# it is unbounded too (see BoundedLogQueue(maxsize=0) below), so no output is
# ever dropped or trimmed, either on screen or in the mirrored log file.


class RCRApp(tk.Tk):
    def __init__(self):
        super().__init__()
        self.title(APP_TITLE)
        # ── Window / taskbar icon ─────────────────────────────────────────
        try:
            icon_path = os.path.join(SCRIPT_DIR, "rcr_icon_128.png")
            if os.path.exists(icon_path):
                self._icon_img = tk.PhotoImage(file=icon_path)
                self.iconphoto(True, self._icon_img)
        except Exception:
            pass
        self.configure(bg=THEME.bg)
        self.geometry("1280x1000")
        self.minsize(980, 680)

        self._running = False
        self._stage = 0
        self._process: Optional[ManagedProcess] = None
        self._log_queue = BoundedLogQueue(maxsize=0)
        self._mem_monitor = MemoryMonitor(threshold_mb=6144.0)
        self._cancel_event = threading.Event()
        self._log_file = None
        self._log_file_path = None
        self._log_file_lock = threading.Lock()
        self._log_line_count = 0
        self._recent_tail: List[str] = []
        self._autoscroll = True

        self._devices: List[Tuple[str, str]] = [("auto", "Auto-detect (recommended)")]
        self._dev_var = tk.StringVar(value="auto")

        # Stage selection variables
        self._run_rulest = tk.BooleanVar(value=True)
        self._run_conc = tk.BooleanVar(value=True)
        self._run_ranker = tk.BooleanVar(value=True)

        # ── Step 3b — Advanced concentrator filtering variables ─────────────
        self._conc_min_occ_var = tk.BooleanVar(value=False)
        self._conc_min_occ_val = tk.StringVar(value="10")
        self._conc_max_rules_var = tk.BooleanVar(value=False)
        self._conc_max_rules_val = tk.StringVar(value="10000")
        self._conc_func_red_var = tk.BooleanVar(value=False)
        self._conc_inv_var = tk.BooleanVar(value=False)
        self._conc_inv_val = tk.StringVar(value="1000")
        self._conc_hashcat_var = tk.BooleanVar(value=False)
        self._conc_hashcat_mode = tk.StringVar(value="cpu")

        self._build_ui()
        self._set_mode("balanced")
        self._start_polling()
        self.protocol("WM_DELETE_WINDOW", self._on_close)

    # ── UI Construction ─────────────────────────────────────────────

    def _build_ui(self):
        main = tk.Frame(self, bg=THEME.bg)
        main.pack(fill="both", expand=True, padx=16, pady=12)

        self._build_header(main)

        paned = tk.PanedWindow(main, orient="vertical", bg=THEME.bg, bd=0,
                                sashwidth=6, sashrelief="flat")
        paned.pack(fill="both", expand=True, pady=(10, 0))

        top = tk.Frame(paned, bg=THEME.bg)
        self._build_tabs(top)
        paned.add(top, stretch="always", minsize=200)

        bottom = tk.Frame(paned, bg=THEME.bg)
        self._build_log_panel(bottom)
        paned.add(bottom, height=300, minsize=150)

        self._build_footer(main)

    def _build_header(self, master):
        hdr = tk.Frame(master, bg=THEME.bg)
        hdr.pack(fill="x")

        title_grp = tk.Frame(hdr, bg=THEME.bg)
        title_grp.pack(side="left")
        tk.Label(title_grp, text=f"◈ {APP_TITLE}", bg=THEME.bg, fg=THEME.fg,
                 font=ui_font(17, "bold")).pack(anchor="w")
        tk.Label(title_grp, text="rulest  →  concentrator  →  ranker", bg=THEME.bg,
                 fg=THEME.fg2, font=ui_font(10)).pack(anchor="w", pady=(1, 0))

        self._stage_frame = tk.Frame(hdr, bg=THEME.bg)
        self._stage_frame.pack(side="right")
        self._stage_dots = []
        for i, name in enumerate(["rulest", "concentrator", "ranker"], 1):
            dot = tk.Label(self._stage_frame, text=f"  {i}  ", bg=THEME.surface, fg=THEME.fg2,
                            font=ui_font(9, "bold"), padx=8, pady=4)
            dot.pack(side="left", padx=(0, 6))
            self._stage_dots.append(dot)

        self._mem_label = tk.Label(hdr, text="RAM: —", bg=THEME.bg, fg=THEME.fg2, font=ui_font(9))
        self._mem_label.pack(side="right", padx=(0, 16))

        self._theme_btn = ModernButton(
            hdr, text="☀  Light mode", variant="secondary",
            command=self._toggle_theme, font=ui_font(9)
        )
        self._theme_btn.pack(side="right", padx=(0, 16))

    def _configure_ttk_styles(self):
        style = ttk.Style()
        try:
            style.theme_use("clam")
        except Exception:
            pass
        style.configure("RCR.TNotebook", background=THEME.bg, borderwidth=0)
        style.configure("RCR.TNotebook.Tab", background=THEME.surface, foreground=THEME.fg2,
                        padding=(16, 8), font=ui_font(10, "bold"))
        style.map("RCR.TNotebook.Tab",
                  background=[("selected", THEME.card)],
                  foreground=[("selected", THEME.accent)])
        style.configure("Vertical.TScrollbar", background=THEME.surface,
                         troughcolor=THEME.bg, bordercolor=THEME.border,
                         arrowcolor=THEME.fg2, darkcolor=THEME.surface, lightcolor=THEME.surface)
        style.configure("Horizontal.TScrollbar", background=THEME.surface,
                         troughcolor=THEME.bg, bordercolor=THEME.border,
                         arrowcolor=THEME.fg2, darkcolor=THEME.surface, lightcolor=THEME.surface)
        style.configure("TCombobox", fieldbackground=THEME.surface, background=THEME.surface,
                        foreground=THEME.fg, arrowcolor=THEME.fg2, bordercolor=THEME.border)
        style.map("TCombobox",
                  fieldbackground=[("readonly", THEME.surface)],
                  foreground=[("readonly", THEME.fg)],
                  selectbackground=[("readonly", THEME.surface)],
                  selectforeground=[("readonly", THEME.fg)])

    def _build_tabs(self, master):
        self._configure_ttk_styles()

        self._nb = ttk.Notebook(master, style="RCR.TNotebook")
        self._nb.pack(fill="both", expand=True)

        tab_pipeline = tk.Frame(self._nb, bg=THEME.bg)
        tab_ranker = tk.Frame(self._nb, bg=THEME.bg)
        tab_advanced = tk.Frame(self._nb, bg=THEME.bg)

        self._nb.add(tab_pipeline, text="  Pipeline  ")
        self._nb.add(tab_ranker, text="  Output & Ranker  ")
        self._nb.add(tab_advanced, text="  Advanced  ")

        self._build_pipeline_tab(tab_pipeline)
        self._build_ranker_tab(tab_ranker)
        self._build_advanced_tab(tab_advanced)

    def _make_scrollable_container(self, parent):
        canvas = tk.Canvas(parent, bg=THEME.bg, highlightthickness=0)
        vsb = ttk.Scrollbar(parent, orient="vertical", command=canvas.yview)
        canvas.configure(yscrollcommand=vsb.set)
        vsb.pack(side="right", fill="y")
        canvas.pack(side="left", fill="both", expand=True)
        wrap = tk.Frame(canvas, bg=THEME.bg)
        win = canvas.create_window((0, 0), window=wrap, anchor="nw")
        wrap.bind("<Configure>", lambda e: canvas.configure(scrollregion=canvas.bbox("all")))
        canvas.bind("<Configure>", lambda e: canvas.itemconfig(win, width=e.width))

        def _on_mousewheel(e):
            canvas.yview_scroll(int(-1 * (e.delta / 120)), "units")
            return "break"

        for widget in (canvas, wrap):
            widget.bind("<MouseWheel>", _on_mousewheel)
            widget.bind("<Button-4>", lambda e: canvas.yview_scroll(-1, "units"))
            widget.bind("<Button-5>", lambda e: canvas.yview_scroll(1, "units"))

        return wrap

    # -- Tab: Pipeline -----------------------------------------------

    def _build_pipeline_tab(self, root):
        wrap = self._make_scrollable_container(root)

        # ── Stage Selection Checkboxes ──────────────────────────────
        stages = Section(wrap, "Step 0 — Select Stages to Run")
        stages.pack(fill="x", pady=(0, 10))
        self._stage_checks_frame = tk.Frame(stages.body, bg=THEME.card)
        self._stage_checks_frame.pack(fill="x")

        self._check_rulest = StageCheck(
            self._stage_checks_frame, "1. rulest", "Extract rules from base + target wordlists",
            self._run_rulest, command=self._on_stage_toggle
        )
        self._check_rulest.pack(side="left", fill="both", expand=True, padx=(0, 8))

        self._check_conc = StageCheck(
            self._stage_checks_frame, "2. concentrator", "Optimize and clean extracted rules",
            self._run_conc, command=self._on_stage_toggle
        )
        self._check_conc.pack(side="left", fill="both", expand=True, padx=(0, 8))

        self._check_ranker = StageCheck(
            self._stage_checks_frame, "3. ranker", "Score and rank rules against cracked passwords",
            self._run_ranker, command=self._on_stage_toggle
        )
        self._check_ranker.pack(side="left", fill="both", expand=True)

        # ── Conditional Rules File Picker ─────────────────────────────
        self._rules_file_section = Section(wrap, "External Rules Input")
        self._rules_file_picker = FilePicker(self._rules_file_section.body, "Rules file")
        self._rules_file_picker.pack(fill="x", pady=3)
        tk.Label(self._rules_file_section.body,
                 text="Required when rulest is skipped. The selected rules file will be fed directly into concentrator and/or ranker depending on which stages are enabled.",
                 bg=THEME.card, fg=THEME.fg2, font=ui_font(8), justify="left").pack(anchor="w", pady=(4, 0))
        self._rules_file_section.pack(fill="x", pady=(0, 10))
        self._rules_file_section.pack_forget()  # hidden by default

        files = Section(wrap, "Step 1 — Input Files")
        files.pack(fill="x", pady=(0, 10))
        self._base_wl = FilePicker(files.body, "Base wordlist"); self._base_wl.pack(fill="x", pady=3)
        self._tgt_wl = FilePicker(files.body, "Target wordlist"); self._tgt_wl.pack(fill="x", pady=3)
        self._cracked = FilePicker(files.body, "Cracked passwords"); self._cracked.pack(fill="x", pady=3)

        row = tk.Frame(files.body, bg=THEME.card)
        row.pack(fill="x", pady=(6, 0))
        tk.Label(row, text="Output directory", bg=THEME.card, fg=THEME.fg2,
                 font=ui_font(9), width=18, anchor="w").pack(side="left")
        self._outdir_var = tk.StringVar(value=os.getcwd())
        tk.Entry(row, textvariable=self._outdir_var, bg=THEME.surface, fg=THEME.fg,
                 insertbackground=THEME.accent, relief="flat", bd=0,
                 highlightbackground=THEME.border, highlightthickness=1,
                 font=mono_font()).pack(side="left", fill="x", expand=True, padx=(0, 8), ipady=4)
        ModernButton(row, text="Browse", variant="secondary",
                     command=lambda: self._outdir_var.set(filedialog.askdirectory() or self._outdir_var.get())
                     ).pack(side="left")

        mode = Section(wrap, "Step 2 — Pipeline Mode")
        mode.pack(fill="x", pady=(0, 10))
        self._mode_var = tk.StringVar(value="balanced")
        row2 = tk.Frame(mode.body, bg=THEME.card)
        row2.pack(fill="x")
        self._mode_cards = {}
        for value, title, subtitle in [
            ("maximum", "Maximum Quality", "Depth 10, full genetic run,\nextensive token-strip."),
            ("balanced", "Balanced", "Depth 6, genetic enabled,\nrecommended default."),
            ("fast", "Fast", "Depth 3, lighter genetic,\nquick results for testing."),
            ("custom", "Custom", "Full manual control over\nevery parameter."),
        ]:
            mc = ModeCard(row2, title, subtitle, value, selected=(value == "balanced"), command=self._set_mode)
            mc.pack(side="left", fill="both", expand=True, padx=(0, 8))
            self._mode_cards[value] = mc

        device = Section(wrap, "OpenCL Device")
        device.pack(fill="x")
        top = tk.Frame(device.body, bg=THEME.card)
        top.pack(fill="x")
        tk.Label(top, text="GPU / Accelerator", bg=THEME.card, fg=THEME.fg2,
                 font=ui_font(9), width=18, anchor="w").pack(side="left")
        self._dev_combo = ttk.Combobox(top, textvariable=self._dev_var,
                                        values=[d[1] for d in self._devices], state="readonly", width=38)
        self._dev_combo.set(self._devices[0][1])
        self._dev_combo.pack(side="left", padx=(0, 8))
        ModernButton(top, text="⟳ Scan", command=self._scan_devices, variant="secondary").pack(side="left")
        self._dev_status = tk.Label(device.body,
            text="Click 'Scan' to detect OpenCL hardware. Auto-detect works for most setups.",
            bg=THEME.card, fg=THEME.fg2, font=ui_font(9), anchor="w")
        self._dev_status.pack(fill="x", pady=(8, 0))

    def _on_stage_toggle(self):
        """Show or hide the external rules file picker depending on whether
        rulest is enabled."""
        if self._run_rulest.get():
            self._rules_file_section.pack_forget()
        else:
            self._rules_file_section.pack(fill="x", pady=(0, 10), before=self._base_wl.master.master)
            # Re-order: insert after stage selection, before input files
            # Since pack doesn't support before/after well, we just show it.
            # The widget was already created in the scrollable wrap.
            self._rules_file_section.pack(fill="x", pady=(0, 10))

    # -- Tab: Output & Ranker -----------------------------------------

    def _build_ranker_tab(self, root):
        wrap = self._make_scrollable_container(root)

        conc = Section(wrap, "Step 3 — Concentrator Output")
        conc.pack(fill="x", pady=(0, 10))
        self._concfmt_var = tk.BooleanVar(value=True)
        tk.Checkbutton(
            conc.body, text="Expanded format (space-separated operators)",
            variable=self._concfmt_var, bg=THEME.card, fg=THEME.fg, selectcolor=THEME.surface,
            activebackground=THEME.card, activeforeground=THEME.fg, font=ui_font(9)
        ).pack(anchor="w")
        tk.Label(
            conc.body,
            text="Expanded: each operator and argument is separated by spaces — easier to read and debug.\n"
                 "Compact: rules on single lines — slightly faster for hashcat to load.",
            bg=THEME.card, fg=THEME.fg2, font=ui_font(9), justify="left"
        ).pack(anchor="w", pady=(8, 0))

        # ── Step 3b — Advanced Filtering ──────────────────────────────
        adv = Section(wrap, "Step 3b — Advanced Filtering (Concentrator Post-Processing)")
        adv.pack(fill="x", pady=(10, 0))

        # (1) Min occurrence
        r1 = tk.Frame(adv.body, bg=THEME.card)
        r1.pack(fill="x", pady=3)
        tk.Checkbutton(
            r1, text="(1) Filter by MINIMUM OCCURRENCE", variable=self._conc_min_occ_var,
            bg=THEME.card, fg=THEME.fg, selectcolor=THEME.surface,
            activebackground=THEME.card, activeforeground=THEME.fg, font=ui_font(9)
        ).pack(side="left")
        tk.Entry(
            r1, textvariable=self._conc_min_occ_val, bg=THEME.surface, fg=THEME.accent,
            insertbackground=THEME.accent, relief="flat", bd=0,
            highlightbackground=THEME.border, highlightthickness=1,
            font=mono_font(), width=8, justify="right"
        ).pack(side="left", padx=(8, 0))
        tk.Label(r1, text="times", bg=THEME.card, fg=THEME.fg2, font=ui_font(8)).pack(side="left")

        # (2) Max rules
        r2 = tk.Frame(adv.body, bg=THEME.card)
        r2.pack(fill="x", pady=3)
        tk.Checkbutton(
            r2, text="(2) Filter by MAXIMUM NUMBER OF RULES (top N)", variable=self._conc_max_rules_var,
            bg=THEME.card, fg=THEME.fg, selectcolor=THEME.surface,
            activebackground=THEME.card, activeforeground=THEME.fg, font=ui_font(9)
        ).pack(side="left")
        tk.Entry(
            r2, textvariable=self._conc_max_rules_val, bg=THEME.surface, fg=THEME.accent,
            insertbackground=THEME.accent, relief="flat", bd=0,
            highlightbackground=THEME.border, highlightthickness=1,
            font=mono_font(), width=8, justify="right"
        ).pack(side="left", padx=(8, 0))

        # (3) Functional redundancy
        r3 = tk.Frame(adv.body, bg=THEME.card)
        r3.pack(fill="x", pady=3)
        tk.Checkbutton(
            r3, text="(3) Filter by FUNCTIONAL REDUNDANCY  [RAM intensive]", variable=self._conc_func_red_var,
            bg=THEME.card, fg=THEME.fg, selectcolor=THEME.surface,
            activebackground=THEME.card, activeforeground=THEME.fg, font=ui_font(9)
        ).pack(side="left")
        tk.Label(
            r3, text="— keeps one rule per functional signature", bg=THEME.card, fg=THEME.fg2, font=ui_font(8)
        ).pack(side="left", padx=(8, 0))

        # (4) Inverse mode
        r4 = tk.Frame(adv.body, bg=THEME.card)
        r4.pack(fill="x", pady=3)
        tk.Checkbutton(
            r4, text="(4) INVERSE MODE – keep rules below the cut-off rank", variable=self._conc_inv_var,
            bg=THEME.card, fg=THEME.fg, selectcolor=THEME.surface,
            activebackground=THEME.card, activeforeground=THEME.fg, font=ui_font(9)
        ).pack(side="left")
        tk.Entry(
            r4, textvariable=self._conc_inv_val, bg=THEME.surface, fg=THEME.accent,
            insertbackground=THEME.accent, relief="flat", bd=0,
            highlightbackground=THEME.border, highlightthickness=1,
            font=mono_font(), width=8, justify="right"
        ).pack(side="left", padx=(8, 0))

        # (5) Hashcat cleanup
        r5 = tk.Frame(adv.body, bg=THEME.card)
        r5.pack(fill="x", pady=3)
        tk.Checkbutton(
            r5, text="(5) HASHCAT CLEANUP – validate rules", variable=self._conc_hashcat_var,
            bg=THEME.card, fg=THEME.fg, selectcolor=THEME.surface,
            activebackground=THEME.card, activeforeground=THEME.fg, font=ui_font(9)
        ).pack(side="left")
        tk.Radiobutton(
            r5, text="CPU", variable=self._conc_hashcat_mode, value="cpu",
            bg=THEME.card, fg=THEME.fg, selectcolor=THEME.surface,
            activebackground=THEME.card, activeforeground=THEME.fg, font=ui_font(8)
        ).pack(side="left", padx=(8, 0))
        tk.Radiobutton(
            r5, text="GPU", variable=self._conc_hashcat_mode, value="gpu",
            bg=THEME.card, fg=THEME.fg, selectcolor=THEME.surface,
            activebackground=THEME.card, activeforeground=THEME.fg, font=ui_font(8)
        ).pack(side="left", padx=(4, 0))

        rk = Section(wrap, "Step 4 — Ranker Strategy")
        rk.pack(fill="x")
        self._legacy_var = tk.BooleanVar(value=True)

        leg_frame = tk.Frame(rk.body, bg=THEME.card, padx=12, pady=12,
                              highlightbackground=THEME.accent, highlightthickness=2)
        leg_frame.pack(fill="x", pady=(0, 8))
        tk.Radiobutton(
            leg_frame, text="Legacy (Exhaustive) — RECOMMENDED for most dictionaries",
            variable=self._legacy_var, value=True, bg=THEME.card, fg=THEME.accent,
            selectcolor=THEME.surface, activebackground=THEME.card, activeforeground=THEME.accent,
            font=ui_font(10, "bold")
        ).pack(anchor="w")
        tk.Label(
            leg_frame,
            text="Every rule is tested straight through against the wordlist — no bandit bookkeeping.\n"
                 "• Usually the FASTER option in practice: no per-batch statistics, elimination passes,\n"
                 "  or Thompson-sampling overhead to pay for on every iteration\n"
                 "• Best fit for balanced dictionaries — where rule effectiveness is fairly evenly spread\n"
                 "  and there's little to be gained by skipping candidates early\n"
                 "• Maximum statistical accuracy — no rule is ever skipped\n"
                 "• Lower, flatter RAM usage — no bandit state arrays to maintain",
            bg=THEME.card, fg=THEME.fg2, font=ui_font(9), justify="left"
        ).pack(anchor="w", pady=(8, 0))

        mab_frame = tk.Frame(rk.body, bg=THEME.card, padx=12, pady=12,
                              highlightbackground=THEME.border, highlightthickness=1)
        mab_frame.pack(fill="x")
        tk.Radiobutton(
            mab_frame, text="MAB (Multi-Armed Bandit) — for very large / imbalanced rule sets",
            variable=self._legacy_var, value=False, bg=THEME.card, fg=THEME.fg,
            selectcolor=THEME.surface, activebackground=THEME.card, activeforeground=THEME.fg,
            font=ui_font(10)
        ).pack(anchor="w")
        tk.Label(
            mab_frame,
            text="Adaptive sampling that tries to spend less time on rules that look unpromising early.\n"
                 "• Pays off mainly on very large (10k+) or heavily skewed / imbalanced rule sets, where\n"
                 "  a large share of rules are genuinely useless and early elimination avoids real work\n"
                 "• On smaller or already-balanced dictionaries the sampling/statistics overhead can\n"
                 "  make it SLOWER than Legacy, not faster — there's less waste for it to cut\n"
                 "• Slightly lower statistical confidence for very rare rules\n"
                 "• Keeps extra bandit state (per-rule counters) in RAM for the whole run",
            bg=THEME.card, fg=THEME.fg2, font=ui_font(9), justify="left"
        ).pack(anchor="w", pady=(8, 0))

    # -- Tab: Advanced -----------------------------------------------

    def _build_advanced_tab(self, root):
        canvas = tk.Canvas(root, bg=THEME.bg, highlightthickness=0)
        vsb = ttk.Scrollbar(root, orient="vertical", command=canvas.yview)
        canvas.configure(yscrollcommand=vsb.set)
        vsb.pack(side="right", fill="y")
        canvas.pack(side="left", fill="both", expand=True, padx=4, pady=8)

        wrap = tk.Frame(canvas, bg=THEME.bg)
        win = canvas.create_window((0, 0), window=wrap, anchor="nw")
        wrap.bind("<Configure>", lambda e: canvas.configure(scrollregion=canvas.bbox("all")))
        canvas.bind("<Configure>", lambda e: canvas.itemconfig(win, width=e.width))

        def _on_mousewheel(e):
            canvas.yview_scroll(int(-1 * (e.delta / 120)), "units")
            return "break"

        for widget in (canvas, wrap):
            widget.bind("<MouseWheel>", _on_mousewheel)
            widget.bind("<Button-4>", lambda e: canvas.yview_scroll(-1, "units"))
            widget.bind("<Button-5>", lambda e: canvas.yview_scroll(1, "units"))

        exp1 = Expander(wrap, "Rulest Core", "Depth, genetic algorithm, time budget", start_open=True)
        exp1.pack(fill="x", pady=(0, 8))
        self._adv_depth = ModernSlider(exp1.body, "Max depth", 1, 31, 1, 3); self._adv_depth.pack(fill="x", pady=2)
        self._adv_gg = ModernSlider(exp1.body, "Genetic generations", 20, 1000, 10, 300); self._adv_gg.pack(fill="x", pady=2)
        self._adv_gp = ModernSlider(exp1.body, "Genetic population", 50, 2000, 50, 600); self._adv_gp.pack(fill="x", pady=2)
        self._adv_th = ModernSlider(exp1.body, "Target hours", 0.5, 12, 0.5, 2.0, is_float=True, unit="h"); self._adv_th.pack(fill="x", pady=2)

        exp2 = Expander(wrap, "Bloom Filter & Token-Strip", "Stage-0 preprocessing")
        exp2.pack(fill="x", pady=(0, 8))
        self._adv_bm = ModernSlider(exp2.body, "Bloom filter size", 100, 4000, 100, 256, unit="MB"); self._adv_bm.pack(fill="x", pady=2)
        self._adv_s0 = ModernSlider(exp2.body, "Stage-0 workers (0=auto)", 0, 64, 1, 0); self._adv_s0.pack(fill="x", pady=2)
        self._adv_tp = ModernSlider(exp2.body, "Token-strip max prefix", 1, 12, 1, 4); self._adv_tp.pack(fill="x", pady=2)
        self._adv_ts = ModernSlider(exp2.body, "Token-strip max suffix", 1, 12, 1, 4); self._adv_ts.pack(fill="x", pady=2)

        exp3 = Expander(wrap, "Ranker MAB Tuning", "Only used when MAB strategy is selected")
        exp3.pack(fill="x", pady=(0, 8))
        self._adv_rk = ModernSlider(exp3.body, "Top rules to keep (K)", 1000, 100000, 1000, 75000); self._adv_rk.pack(fill="x", pady=2)
        self._adv_ms = ModernSlider(exp3.body, "MAB screening trials", 1, 30, 1, 4); self._adv_ms.pack(fill="x", pady=2)
        self._adv_mf = ModernSlider(exp3.body, "MAB final trials", 1, 50, 1, 8); self._adv_mf.pack(fill="x", pady=2)

        exp4 = Expander(wrap, "Memory Preset", "Applies to the ranker stage", start_open=True)
        exp4.pack(fill="x", pady=(0, 8))
        tk.Label(exp4.body,
                 text="If a stage crashes with an out-of-memory error, switch to Low and re-run —\n"
                      "the app will also suggest this automatically when it detects one.",
                 bg=THEME.card, fg=THEME.fg2, font=ui_font(8), justify="left").pack(anchor="w", pady=(0, 6))
        preset_frame = tk.Frame(exp4.body, bg=THEME.card)
        preset_frame.pack(anchor="w")
        self._preset_var = tk.StringVar(value="medium_memory")
        for val, lbl in [("low_memory", "Low (≤4GB VRAM)"), ("medium_memory", "Medium (4-8GB)"),
                          ("high_memory", "High (>8GB)")]:
            tk.Radiobutton(preset_frame, text=lbl, variable=self._preset_var, value=val,
                           bg=THEME.card, fg=THEME.fg, selectcolor=THEME.surface,
                           activebackground=THEME.card, activeforeground=THEME.fg,
                           font=ui_font(9)).pack(side="left", padx=(0, 16))

    # ── Log Panel ─────────────────────────────────────────────────────

    def _build_log_panel(self, root):
        card = tk.Frame(root, bg=THEME.card, highlightbackground=THEME.border,
                         highlightthickness=1, padx=10, pady=8)
        card.pack(fill="both", expand=True)

        toolbar = tk.Frame(card, bg=THEME.card)
        toolbar.pack(fill="x", pady=(0, 6))

        tk.Label(toolbar, text="Execution Log", bg=THEME.card, fg=THEME.accent,
                 font=ui_font(10, "bold")).pack(side="left")
        self._log_status = tk.Label(toolbar, text="Ready", bg=THEME.card, fg=THEME.fg2, font=ui_font(9))
        self._log_status.pack(side="left", padx=(12, 0))

        self._follow_btn = ModernButton(toolbar, text="⏷ Following", variant="secondary",
                                         command=self._toggle_follow)
        self._follow_btn.pack(side="right", padx=(6, 0))
        ModernButton(toolbar, text="Open log file", variant="ghost", command=self._open_log_file).pack(side="right", padx=(6, 0))
        ModernButton(toolbar, text="Clear", variant="ghost", command=self._clear_log).pack(side="right", padx=(6, 0))

        search_row = tk.Frame(card, bg=THEME.card)
        search_row.pack(fill="x", pady=(0, 6))
        tk.Label(search_row, text="Search:", bg=THEME.card, fg=THEME.fg2, font=ui_font(9)).pack(side="left")
        self._search_var = tk.StringVar()
        search_entry = tk.Entry(search_row, textvariable=self._search_var, bg=THEME.surface, fg=THEME.fg,
                                 insertbackground=THEME.accent, relief="flat", bd=0,
                                 highlightbackground=THEME.border, highlightthickness=1, font=mono_font())
        search_entry.pack(side="left", fill="x", expand=True, padx=(6, 6), ipady=3)
        search_entry.bind("<Return>", lambda _e: self._search_log(1))
        ModernButton(search_row, text="↑ Prev", variant="secondary", command=lambda: self._search_log(-1)).pack(side="left", padx=(0, 4))
        ModernButton(search_row, text="↓ Next", variant="secondary", command=lambda: self._search_log(1)).pack(side="left")

        log_frame = tk.Frame(card, bg=THEME.card)
        log_frame.pack(fill="both", expand=True)

        self._hbar = tk.Scrollbar(log_frame, orient="horizontal", bg=THEME.surface, troughcolor=THEME.bg)
        self._hbar.pack(side="bottom", fill="x")
        self._vbar = tk.Scrollbar(log_frame, orient="vertical", bg=THEME.surface, troughcolor=THEME.bg)
        self._vbar.pack(side="right", fill="y")

        self._log = tk.Text(
            log_frame,
            bg="#0d0f14", fg=THEME.fg, insertbackground=THEME.accent,
            font=mono_font(), relief="flat", bd=0,
            highlightbackground=THEME.border, highlightthickness=1,
            wrap="none",
            width=120,
            xscrollcommand=self._hbar.set,
            yscrollcommand=self._vbar.set,
            state="disabled"
        )
        self._log.pack(side="left", fill="both", expand=True)
        self._hbar.config(command=self._log.xview)
        self._vbar.config(command=self._log.yview)

        self._log.tag_config("search_hit", background=THEME.info, foreground="#0a0a0a")

        self._log.bind("<MouseWheel>", self._on_log_scroll)
        self._log.bind("<Button-4>", self._on_log_scroll)
        self._log.bind("<Button-5>", self._on_log_scroll)
        self._log.bind("<Prior>", lambda _e: self._set_follow(False))
        self._log.bind("<Up>", lambda _e: self._set_follow(False))

        for name, colour in [
            ("accent", THEME.accent), ("success", THEME.success),
            ("warning", THEME.warning), ("danger", THEME.danger),
            ("info", THEME.info), ("muted", THEME.fg2),
        ]:
            self._log.tag_config(name, foreground=colour)
        self._colour_tags = {"accent", "success", "warning", "danger", "info", "muted"}

    def _toggle_follow(self):
        self._set_follow(not self._autoscroll)

    def _set_follow(self, on: bool):
        self._autoscroll = on
        self._follow_btn.config(text="⏷ Following" if on else "⏸ Paused (scroll to end to resume)")
        if on:
            self._log.see("end")

    def _on_log_scroll(self, _event=None):
        self.after(50, self._check_scroll_position)

    def _check_scroll_position(self):
        try:
            top_frac, bottom_frac = self._log.yview()
        except Exception:
            return
        at_bottom = bottom_frac > 0.999
        if at_bottom and not self._autoscroll:
            self._set_follow(True)
        elif not at_bottom and self._autoscroll:
            self._set_follow(False)

    def _search_log(self, direction: int):
        term = self._search_var.get()
        if not term:
            return
        self._log.tag_remove("search_hit", "1.0", "end")
        start = self._log.index("insert")
        if direction > 0:
            idx = self._log.search(term, start, stopindex="end", nocase=True)
            if not idx:
                idx = self._log.search(term, "1.0", stopindex="end", nocase=True)
        else:
            idx = self._log.search(term, start, stopindex="1.0", backwards=True, nocase=True)
            if not idx:
                idx = self._log.search(term, "end", stopindex="1.0", backwards=True, nocase=True)
        if idx:
            end_idx = f"{idx}+{len(term)}c"
            self._log.tag_add("search_hit", idx, end_idx)
            self._log.mark_set("insert", end_idx)
            self._log.see(idx)
            self._set_follow(False)

    def _open_log_file(self):
        if not self._log_file_path or not os.path.isfile(self._log_file_path):
            messagebox.showinfo("Log file", "No log file yet — run the pipeline first.")
            return
        folder = os.path.dirname(self._log_file_path)
        try:
            if sys.platform == "win32":
                os.startfile(folder)
            elif sys.platform == "darwin":
                subprocess.Popen(["open", folder])
            else:
                subprocess.Popen(["xdg-open", folder])
        except Exception:
            messagebox.showinfo("Log file location", self._log_file_path)

    # ── Footer ────────────────────────────────────────────────────────

    def _build_footer(self, master):
        tk.Frame(master, bg=THEME.border, height=1).pack(side="bottom", fill="x")

        bar = tk.Frame(master, bg=THEME.surface, padx=24, pady=18)
        bar.pack(side="bottom", fill="x")

        status_box = tk.Frame(bar, bg=THEME.surface)
        status_box.pack(side="left")
        self._status_dot = tk.Label(
            status_box, text="●", bg=THEME.surface, fg=THEME.success,
            font=ui_font(10)
        )
        self._status_dot.pack(side="left", padx=(0, 8))
        self._status_label = tk.Label(
            status_box, text="Ready to start", bg=THEME.surface,
            fg=THEME.fg2, font=ui_font(10)
        )
        self._status_label.pack(side="left")

        btn_box = tk.Frame(bar, bg=THEME.surface)
        btn_box.pack(side="right")

        self._stop_btn = ModernButton(
            btn_box, text="⏹  Stop", command=self._stop, variant="danger",
            font=ui_font(11, "bold"), padx=28, pady=12
        )
        self._stop_btn.pack(side="right", padx=(12, 0))
        self._stop_btn.config(state="disabled")

        self._run_btn = ModernButton(
            btn_box, text="▶  Run Pipeline", command=self._run, variant="primary",
            font=ui_font(11, "bold"), padx=28, pady=12
        )
        self._run_btn.pack(side="right")

    def _set_status(self, text: str, color: str):
        self._status_label.config(text=text, fg=color)
        self._status_dot.config(fg=color)

    # ── Theme (Light / Dark) ─────────────────────────────────────────

    def _toggle_theme(self):
        old = THEME.current
        new = LIGHT_THEME if old.name == "dark" else DARK_THEME
        color_map = _theme_color_map(old, new)
        THEME.set(new)

        # Re-theme every existing widget in the tree.
        _retheme_tree(self, color_map)
        self._configure_ttk_styles()

        # The log panel's text background isn't part of the shared palette
        # (it is intentionally darker/lighter than the surrounding chrome).
        if self._log.cget("bg") == old.log_bg:
            self._log.config(bg=new.log_bg)

        # Text-widget tags aren't tk options, so they need an explicit refresh.
        for name in ("accent", "success", "warning", "danger", "info"):
            self._log.tag_config(name, foreground=getattr(new, name))
        self._log.tag_config("muted", foreground=new.fg2)
        self._log.tag_config("search_hit", background=new.info, foreground="#0a0a0a")

        # Raw ANSI-coloured tool output already rendered in the log uses
        # per-colour tags (col_<hex>) tied to the old palette — remap those
        # too, or previously-printed lines stay hard to read on the new bg.
        old_ansi = ANSI_COLOURS_LIGHT if old.name == "light" else ANSI_COLOURS_DARK
        new_ansi = ANSI_COLOURS_LIGHT if new.name == "light" else ANSI_COLOURS_DARK
        ansi_map = {old_ansi[k]: new_ansi[k] for k in old_ansi}
        for tag in list(getattr(self, "_colour_tags", ())):
            try:
                cur_fg = self._log.tag_cget(tag, "foreground")
            except Exception:
                continue
            if cur_fg in ansi_map:
                self._log.tag_config(tag, foreground=ansi_map[cur_fg])

        # Mode cards compute their colours fresh from THEME each call.
        if hasattr(self, "_mode_cards"):
            self._set_mode(self._mode_var.get())

        self._theme_btn.config(
            text="🌙  Dark mode" if new.name == "light" else "☀  Light mode"
        )

    # ── Mode Management ─────────────────────────────────────────────

    def _set_mode(self, mode: str):
        self._mode_var.set(mode)
        for value, card in self._mode_cards.items():
            card.set_selected(value == mode)
        # Updated presets per user request:
        # Maximum: gg=500, gp=1000
        # Balanced: unchanged (gg=300, gp=600)
        # Fast: gg=150, gp=300
        presets = {
            "maximum": dict(depth=10, gg=500, gp=1000, th=2.0, bm=256, tp=10, ts=10, rk=100000, ms=5, mf=10, pr="medium_memory"),
            "balanced": dict(depth=6, gg=300, gp=600, th=1.0, bm=256, tp=6, ts=6, rk=75000, ms=4, mf=8, pr="medium_memory"),
            "fast": dict(depth=3, gg=150, gp=300, th=0.5, bm=256, tp=3, ts=3, rk=50000, ms=3, mf=5, pr="medium_memory"),
        }
        if mode in presets and hasattr(self, "_adv_depth"):
            p = presets[mode]
            self._adv_depth.set(p["depth"]); self._adv_gg.set(p["gg"]); self._adv_gp.set(p["gp"])
            self._adv_th.set(p["th"]); self._adv_bm.set(p["bm"]); self._adv_rk.set(p["rk"])
            self._adv_ms.set(p["ms"]); self._adv_mf.set(p["mf"]); self._adv_tp.set(p["tp"]); self._adv_ts.set(p["ts"])
            self._preset_var.set(p["pr"])

    def _apply_low_memory(self):
        self._preset_var.set("low_memory")
        self._adv_bm.set(min(self._adv_bm.get(), 128))
        self._adv_rk.set(min(self._adv_rk.get(), 8000))
        self._adv_gp.set(min(self._adv_gp.get(), 300))
        self._adv_ms.set(min(self._adv_ms.get(), 3))
        self._adv_mf.set(min(self._adv_mf.get(), 5))
        self._nb.select(2)
        self._log_system("Applied Low-Memory settings (preset=low_memory, bloom≤128MB, K≤8000, "
                          "genetic population≤300, MAB trials reduced). Re-run when ready.")

    # ── Device Scanning ─────────────────────────────────────────────

    def _scan_devices(self):
        self._dev_status.config(text="Scanning…", fg=THEME.warning)
        self._log_system("Scanning for OpenCL devices…")
        threading.Thread(target=self._scan_thread, daemon=True).start()

    def _scan_thread(self):
        py = sys.executable
        rulest_py = os.path.join(SCRIPT_DIR, "rulest_v2.py")
        try:
            result = subprocess.run([py, rulest_py, "--list-devices"], capture_output=True, text=True, timeout=30)
            raw = result.stdout + result.stderr
        except Exception as e:
            self.after(0, lambda: self._scan_failed(str(e)))
            return
        clean = strip_ansi(raw)
        devices = [("auto", "Auto-detect (recommended)")]
        for line in clean.splitlines():
            m = re.search(r'\[?\b(\d+)\]?\s*[:\-]?\s*(.+)', line)
            if m and any(k in line.lower() for k in ["nvidia", "amd", "intel", "gpu", "geforce", "radeon"]):
                dev_id = m.group(1)
                desc = m.group(2).strip()
                devices.append((dev_id, f"[{dev_id}] {desc}"))
        self.after(0, lambda: self._scan_complete(devices, raw))

    def _scan_failed(self, error: str):
        self._dev_status.config(text=f"Scan failed: {error}", fg=THEME.danger)
        self._log_error(f"Device scan failed: {error}")

    def _scan_complete(self, devices: List[Tuple[str, str]], raw: str):
        self._devices = devices
        self._dev_combo["values"] = [d[1] for d in devices]
        self._dev_combo.set(devices[0][1])
        count = len(devices) - 1
        if count > 0:
            self._dev_status.config(text=f"Found {count} device(s). Auto-detect recommended.", fg=THEME.success)
        else:
            self._dev_status.config(text="No OpenCL devices found. CPU fallback will be used.", fg=THEME.warning)
        self._log_system(f"Device scan complete. {count} device(s) found.")
        self._log_muted(strip_ansi(raw))

    # ── Log Writing ─────────────────────────────────────────────────

    def _log_system(self, text: str):
        line = f"[{time.strftime('%H:%M:%S')}] {text}\n"
        self._write_to_disk_and_tail(line)
        self._log_queue.put(("system", line))

    def _log_error(self, text: str):
        line = f"[{time.strftime('%H:%M:%S')}] ERROR: {text}\n"
        self._write_to_disk_and_tail(line)
        self._log_queue.put(("error", line))

    def _log_muted(self, text: str):
        line = text + "\n"
        self._write_to_disk_and_tail(line)
        self._log_queue.put(("muted", line))

    def _log_line(self, text: str):
        line = text + "\n"
        self._write_to_disk_and_tail(line)
        self._log_queue.put(("ansi_line", line))

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

    def _open_log_stream(self):
        os.makedirs(self._outdir_var.get(), exist_ok=True)
        ts = time.strftime("%Y%m%d_%H%M%S")
        self._log_file_path = os.path.join(self._outdir_var.get(), f"rcr_run_{ts}.log")
        try:
            with self._log_file_lock:
                self._log_file = open(self._log_file_path, "a", encoding="utf-8", errors="replace")
        except Exception as e:
            self._log_file = None
            self._log_error(f"Could not open log file for writing: {e}")

    def _close_log_stream(self):
        with self._log_file_lock:
            if self._log_file:
                try:
                    self._log_file.close()
                except Exception:
                    pass
                self._log_file = None

    def _write_to_disk_and_tail(self, text: str):
        """Called immediately when a log message is produced (may be from a
        background thread), so the on-disk log and the OOM-detection tail are
        always complete — independent of how fast the GUI thread can drain
        the display queue. This guarantees no log lines are ever lost."""
        with self._log_file_lock:
            if self._log_file:
                try:
                    self._log_file.write(strip_ansi(text))
                except Exception:
                    pass
        self._recent_tail.append(text)
        if len(self._recent_tail) > 200:
            self._recent_tail = self._recent_tail[-200:]

    # ── Main Polling Loop ───────────────────────────────────────────

    def _start_polling(self):
        self.after(50, self._poll_loop)
        self.after(2000, self._update_memory)

    def _poll_loop(self):
        processed = 0
        while processed < 200:
            try:
                kind, content = self._log_queue.get_nowait()
            except queue.Empty:
                break
            self._apply_log_entry(kind, content)
            processed += 1

        dropped = self._log_queue.clear_dropped()
        if dropped > 0:
            self._apply_log_entry("system", f"[{time.strftime('%H:%M:%S')}] … {dropped} log lines dropped (backpressure)\n")

        self.after(50, self._poll_loop)

    def _apply_log_entry(self, kind: str, content: str):
        self._log.config(state="normal")

        if kind in ("ansi_line", "system", "error", "muted"):
            tag = {"system": "info", "error": "danger", "muted": "muted"}.get(kind)
            if kind == "ansi_line":
                for chunk, colour in parse_ansi_segments(content):
                    if not chunk:
                        continue
                    if colour:
                        t = f"col_{colour.replace('#', '')}"
                        if t not in self._colour_tags:
                            self._log.tag_config(t, foreground=colour)
                            self._colour_tags.add(t)
                        self._log.insert("end", chunk, t)
                    else:
                        self._log.insert("end", chunk)
            else:
                self._log.insert("end", content, tag)
            self._log_line_count += content.count("\n")

        else:
            self._log.insert("end", content)
            self._log_line_count += content.count("\n")

        if self._autoscroll:
            self._log.see("end")
        self._log.config(state="disabled")

    def _update_memory(self):
        if self._running:
            mem_str = self._mem_monitor.format()
            self._mem_label.config(text=f"RAM: {mem_str}")
            if self._mem_monitor.is_under_pressure():
                self._mem_label.config(fg=THEME.warning)
            else:
                self._mem_label.config(fg=THEME.fg2)
        self.after(2000, self._update_memory)

    # ── Concentrator Post-Processing Filters ─────────────────────────
    #
    # v0.6: The Step-3b filters (1-5) used to be reimplemented here in
    # Python, separately from concentrator.py's own logic — which is why
    # they didn't actually reflect what concentrator does (different
    # occurrence counting, a stripped-down functional-redundancy check,
    # etc). They are now passed straight through to concentrator.py's own
    # --filter-min-occ / --filter-max-rules / --filter-func-redundancy /
    # --filter-inverse / --filter-hashcat-cleanup CLI flags (see
    # _concentrator_filter_args() and the Stage 2 block in
    # _pipeline_thread), so RCR always uses concentrator's real, single
    # source of truth for these filters. Each flag is independent — only
    # the ones the user checked are passed — and concentrator applies
    # them in the fixed order 1→5 in a single pass so occurrence counts
    # stay consistent from one filter to the next.

    def _concentrator_filter_args(self) -> List[str]:
        """Build the --filter-* CLI args for concentrator.py from whichever
        Step-3b checkboxes are enabled. Only enabled options are included,
        so each of the 5 filters is executed independently."""
        conc_args: List[str] = []
        if self._conc_min_occ_var.get():
            conc_args += ["--filter-min-occ", self._conc_min_occ_val.get()]
        if self._conc_max_rules_var.get():
            conc_args += ["--filter-max-rules", self._conc_max_rules_val.get()]
        if self._conc_func_red_var.get():
            conc_args += ["--filter-func-redundancy", "--yes"]
        if self._conc_inv_var.get():
            conc_args += ["--filter-inverse", self._conc_inv_val.get()]
        if self._conc_hashcat_var.get():
            conc_args += ["--filter-hashcat-cleanup", self._conc_hashcat_mode.get()]
        return conc_args

    # ── Pipeline Execution ────────────────────────────────────────

    def _validate(self) -> bool:
        # Check that at least one stage is selected
        if not any([self._run_rulest.get(), self._run_conc.get(), self._run_ranker.get()]):
            messagebox.showerror("No Stage Selected", "Please select at least one stage to run.")
            return False

        # If rulest is not selected but concentrator or ranker is, require external rules file
        if not self._run_rulest.get() and (self._run_conc.get() or self._run_ranker.get()):
            rules_path = self._rules_file_picker.get()
            if not rules_path:
                messagebox.showerror("Missing Rules File", "When skipping rulest, an external rules file is required. Please select one in the 'External Rules Input' section.")
                return False
            if not os.path.isfile(rules_path):
                messagebox.showerror("File Not Found", f"Rules file not found:\n{rules_path}")
                return False

        # If rulest is selected, require base + target wordlists
        if self._run_rulest.get():
            for label, path in [
                ("Base wordlist", self._base_wl.get()),
                ("Target wordlist", self._tgt_wl.get()),
            ]:
                if not path:
                    messagebox.showerror("Missing Input", f"{label} is required when running rulest.")
                    return False
                if not os.path.isfile(path):
                    messagebox.showerror("File Not Found", f"{label}: {path} — File does not exist.")
                    return False

        # If ranker is selected, require cracked passwords and base wordlist
        if self._run_ranker.get():
            for label, path in [
                ("Base wordlist", self._base_wl.get()),
                ("Cracked passwords", self._cracked.get()),
            ]:
                if not path:
                    messagebox.showerror("Missing Input", f"{label} is required when running ranker.")
                    return False
                if not os.path.isfile(path):
                    messagebox.showerror("File Not Found", f"{label}: {path} — File does not exist.")
                    return False

        return True

    def _run(self):
        if self._running or not self._validate():
            return
        self._running = True
        self._cancel_event.clear()
        self._stage = 0
        self._recent_tail = []
        self._run_btn.config(state="disabled")
        self._stop_btn.config(state="normal")
        self._open_log_stream()
        self._log_system(f"Pipeline starting… (full log: {self._log_file_path})")
        self._set_status("Running…", THEME.accent)
        threading.Thread(target=self._pipeline_thread, daemon=True).start()

    def _stop(self):
        if not self._running:
            return
        self._cancel_event.set()
        self._log_system("Stop requested, terminating current process…")
        if self._process:
            self._process.terminate()
            self._process = None
        self._mem_monitor.set_child_pid(None)
        self._finish(aborted=True)

    def _finish(self, aborted: bool = False, error: bool = False):
        if not self._running:
            return
        self._running = False
        self._close_log_stream()
        gc.collect()
        self._run_btn.config(state="normal")
        self._stop_btn.config(state="disabled")
        if aborted:
            self._set_stage(-1)
            self._set_status("Stopped", THEME.warning)
            self._log_system("Pipeline stopped by user.")
        elif error:
            self._set_stage(-1)
            self._set_status("Failed", THEME.danger)
        else:
            self._set_stage(10)
            self._set_status("Complete ✓", THEME.success)
            self._log_system("Pipeline finished successfully.")

    def _set_stage(self, stage: int):
        for i, dot in enumerate(self._stage_dots, 1):
            if stage == -1:
                dot.config(bg=THEME.danger if i == self._stage else THEME.surface,
                           fg="#0a0a0a" if i == self._stage else THEME.fg2)
            elif stage == 10:
                dot.config(bg=THEME.success, fg="#0a0a0a")
            elif i < stage:
                dot.config(bg=THEME.success, fg="#0a0a0a")
            elif i == stage:
                dot.config(bg=THEME.accent, fg="#0a0a0a")
            else:
                dot.config(bg=THEME.surface, fg=THEME.fg2)

    def _device_args(self) -> List[str]:
        dev_display = self._dev_var.get()
        if not dev_display or dev_display.lower().startswith("auto"):
            return []
        m = re.search(r'\[(\d+)\]', dev_display)
        if m:
            return ["--device", m.group(1)]
        if dev_display.isdigit():
            return ["--device", dev_display]
        return ["--device", dev_display]

    def _check_for_oom(self) -> bool:
        tail = "\n".join(self._recent_tail[-100:])
        return bool(OOM_PATTERNS.search(tail))

    def _format_cmd_for_display(self, cmd: List[str]) -> str:
        """Return a platform-appropriate shell-safe string for the log."""
        if sys.platform == "win32":
            # subprocess.list2cmdline produces the exact string Windows
            # CreateProcess would receive — perfect for display.
            return subprocess.list2cmdline(str(a) for a in cmd)
        return " ".join(shlex.quote(str(a)) for a in cmd)

    def _run_step(self, cmd: List[str], label: str) -> int:
        self._log_system(f"{'─' * 50}")
        self._log_system(f"Stage: {label}")
        self._log_system(f"{'─' * 50}")
        self._log_muted(f"$ {self._format_cmd_for_display(cmd)}")

        self._process = ManagedProcess()
        env = os.environ.copy()
        env["PYTHONUNBUFFERED"] = "1"
        # When stdout is piped (no real TTY), progress-bar libraries like
        # tqdm can't detect a terminal width and fall back to a narrow
        # default, truncating things like the GA/minimizer speed readout.
        # Giving them an explicit, generous width avoids that.
        env["COLUMNS"] = "250"
        env["LINES"] = "50"

        if not self._process.start(cmd, self._outdir_var.get(), env):
            self._log_error("Failed to start process")
            return -1

        self._mem_monitor.set_child_pid(self._process.pid)

        proc = self._process
        for kind, text in proc.iter_events(timeout=0.3):
            if self._cancel_event.is_set():
                self._log_system("Cancellation detected, stopping…")
                break
            if not text:
                continue

            clean_text = normalize_progress_bars(text.rstrip('\r'))
            self._log_line(clean_text)

        rc = proc.returncode if proc is not None else -1
        self._process = None
        self._mem_monitor.set_child_pid(None)
        gc.collect()

        if rc not in (0, None) and not self._cancel_event.is_set() and self._check_for_oom():
            self._log_error(
                "This looks like an out-of-memory failure (allocation error / process killed).")
            self._log_system("Suggestion: switch the Memory Preset to Low and reduce K / genetic "
                              "population / MAB trials on the Advanced tab, then re-run.")
            self.after(0, self._offer_low_memory_dialog)

        return rc if rc is not None else -1

    def _stage_succeeded(self, rc: int, expected_path: Optional[str], label: str) -> bool:
        """A non-zero exit code is the primary failure signal, but some of
        these tools can exit non-zero from a benign cleanup issue *after*
        writing valid output. If the expected output file was actually
        written (and isn't empty), treat the stage as successful instead of
        failing the whole pipeline over a false alarm."""
        if rc == 0:
            return True
        if expected_path and os.path.isfile(expected_path) and os.path.getsize(expected_path) > 0:
            self._log_system(
                f"{label} exited with code {rc}, but its output file was written "
                f"successfully ({expected_path}) — continuing as if it succeeded."
            )
            return True
        return False

    def _offer_low_memory_dialog(self):
        if messagebox.askyesno(
            "Possible out-of-memory failure",
            "This stage appears to have failed because it ran out of memory (host RAM or GPU VRAM). Apply the Low-Memory preset now (lower bloom filter size, K, genetic population, and MAB trial counts) so the next run is less likely to hit the same wall?"
        ):
            self._apply_low_memory()

    def _pipeline_thread(self):
        outdir = os.path.normpath(self._outdir_var.get())
        base_wl = os.path.normpath(self._base_wl.get()) if self._base_wl.get() else ""
        tgt_wl = os.path.normpath(self._tgt_wl.get()) if self._tgt_wl.get() else ""
        cracked = os.path.normpath(self._cracked.get()) if self._cracked.get() else ""

        depth = int(self._adv_depth.get())
        gen_gen = int(self._adv_gg.get())
        gen_pop = int(self._adv_gp.get())
        th = float(self._adv_th.get())
        bm = int(self._adv_bm.get())
        s0 = int(self._adv_s0.get())
        tok_p = int(self._adv_tp.get())
        tok_s = int(self._adv_ts.get())
        rk = int(self._adv_rk.get())
        ms = int(self._adv_ms.get())
        mf = int(self._adv_mf.get())
        preset = self._preset_var.get()
        legacy = self._legacy_var.get()

        py = sys.executable
        rulest_py = os.path.join(SCRIPT_DIR, "rulest_v2.py")
        conc_py = os.path.join(SCRIPT_DIR, "concentrator.py")
        rank_py = os.path.join(SCRIPT_DIR, "ranker.py")
        dev_args = self._device_args()

        # ── Stage 1: rulest ─────────────────────────────────────────
        s1 = os.path.join(outdir, "stage1_raw.rule")
        if self._run_rulest.get():
            self.after(0, lambda: self._set_stage(1))
            self.after(0, lambda: self._status_label.config(text="Stage 1/3: rulest…"))

            rc = self._run_step([
                py, rulest_py, base_wl, tgt_wl,
                "-o", s1,
                "--max-depth", str(depth),
                "--token-strip",
                "--genetic",
                "--genetic-generations", str(gen_gen),
                "--genetic-pop", str(gen_pop),
                "--target-hours", str(th),
                "--bloom-mb", str(bm),
                "--token-strip-max-prefix", str(tok_p),
                "--token-strip-max-suffix", str(tok_s),
                "--token-strip-workers", str(s0),
            ] + dev_args, "rulest — rule extraction")

            if self._cancel_event.is_set() or not self._stage_succeeded(rc, s1, "rulest"):
                self.after(0, lambda: self._finish(error=True))
                return

            gc.collect()
            self._log_system("Memory cleanup between stages…")
        else:
            # Use external rules file instead of rulest output
            s1 = os.path.normpath(self._rules_file_picker.get())
            self._log_system(f"Skipping rulest — using external rules: {s1}")

        # ── Stage 2: concentrator ───────────────────────────────────
        s2b = os.path.join(outdir, "stage2_cleaned")
        cleaned = None
        if self._run_conc.get():
            self.after(0, lambda: self._set_stage(2))
            self.after(0, lambda: self._status_label.config(text="Stage 2/3: concentrator…"))

            conc_format = "expanded" if self._concfmt_var.get() else "line"
            filter_args = self._concentrator_filter_args()
            conc_cmd = [
                py, conc_py,
                "-p", s1,
                "--output_base_name", s2b,
                "--output-format", conc_format,
            ] + filter_args

            if filter_args:
                self._log_system(
                    "Step 3b advanced filters enabled — concentrator will run them "
                    "(in order 1→5) as part of this stage."
                )
            rc = self._run_step(conc_cmd, "concentrator — rule optimization + advanced filtering")

            if self._cancel_event.is_set():
                self.after(0, lambda: self._finish(error=True))
                return

            expected = s2b + "_processed.rule"
            matches = [expected] if os.path.isfile(expected) else glob.glob(s2b + "*.rule")
            if not matches:
                fallback = sorted(
                    [f for f in glob.glob(os.path.join(outdir, "*.rule")) if os.path.abspath(f) != os.path.abspath(s1)],
                    key=os.path.getmtime, reverse=True
                )
                if fallback:
                    matches = [fallback[0]]
                    self._log_system(f"Using fallback output: {matches[0]}")
            if not matches:
                extra = f" (process also exited with code {rc})" if rc != 0 else ""
                self._log_error(f"No concentrator output found: {s2b}*.rule{extra}")
                self.after(0, lambda: self._finish(error=True))
                return
            elif rc != 0:
                self._log_system(
                    f"concentrator exited with code {rc}, but its output file was written "
                    f"successfully ({matches[0]}) — continuing as if it succeeded."
                )

            cleaned = matches[0]
            self._log_system(f"Using cleaned rules: {cleaned}")

            gc.collect()
        else:
            # If concentrator is skipped, pass the rules file directly to ranker
            cleaned = s1
            self._log_system(f"Skipping concentrator — passing rules directly to ranker: {cleaned}")

        # ── Stage 3: ranker ─────────────────────────────────────────
        s3 = os.path.join(outdir, "stage3_ranking.csv")
        if self._run_ranker.get():
            self.after(0, lambda: self._set_stage(3))
            self.after(0, lambda: self._status_label.config(text="Stage 3/3: ranker (this may take a while)…"))

            cmd3 = [py, rank_py, "-w", base_wl, "-r", cleaned, "-c", cracked, "-o", s3,
                    "-k", str(rk), "--preset", preset] + dev_args
            if legacy:
                cmd3.append("--legacy")
                self._log_system("Using Legacy (exhaustive) ranker — recommended default, full accuracy.")
            else:
                cmd3 += ["--mab-screening-trials", str(ms), "--mab-final-trials", str(mf)]
                self._log_system("Using MAB (adaptive) ranker — best for very large / imbalanced rule sets.")

            rc = self._run_step(cmd3, "ranker — rule scoring & ranking")
            if self._cancel_event.is_set() or not self._stage_succeeded(rc, s3, "ranker"):
                self.after(0, lambda: self._finish(error=True))
                return
        else:
            self._log_system("Skipping ranker — pipeline complete up to selected stages.")

        self._log_system(f"{'─' * 50}")
        self._log_system("Pipeline complete!")
        if self._run_ranker.get():
            self._log_system(f"Results: {s3}")
        self._log_system(f"{'─' * 50}")
        self.after(0, self._finish)

    # ── Window Management ─────────────────────────────────────────

    def _on_close(self):
        if self._running:
            if messagebox.askyesno("Quit", "Pipeline is running. Stop and quit?"):
                self._stop()
                self.destroy()
        else:
            self._close_log_stream()
            self.destroy()


if __name__ == "__main__":
    app = RCRApp()
    app.mainloop()