#!/usr/bin/env python3
"""
Wine Core Fencer (Latency & Frame-Time Optimizer for Wine/Proton Games)
Automatically detects physical CPU & Hyper-Threading topology via sysfs,
pins the game's render/input thread and wineserver to dedicated physical cores
(avoiding Core 0 GPU/USB interrupts and HT siblings), assigns worker threads to
secondary cores, and fences noisy background processes onto remaining CPUs.
"""

import argparse
import glob
import os
import re
import subprocess
import time
from pathlib import Path


def _expand_cpulist(spec: str) -> list:
    cpus = []
    for part in spec.strip().split(","):
        if not part:
            continue
        if "-" in part:
            lo, hi = map(int, part.split("-", 1))
            cpus.extend(range(lo, hi + 1))
        else:
            cpus.append(int(part))
    return cpus


def _format_cpulist(cpus: list) -> str:
    if not cpus:
        return ""
    s = sorted(set(cpus))
    ranges = []
    start = prev = s[0]
    for c in s[1:]:
        if c == prev + 1:
            prev = c
        else:
            ranges.append(f"{start}-{prev}" if start != prev else str(start))
            start = prev = c
    ranges.append(f"{start}-{prev}" if start != prev else str(start))
    return ",".join(ranges)


def detect_cpu_layout() -> dict:
    """Builds optimal render, wineserver, worker, and background CPU masks from sysfs."""
    phys_groups = {}
    all_cpus = []
    for sib_file in sorted(glob.glob("/sys/devices/system/cpu/cpu[0-9]*/topology/thread_siblings_list")):
        try:
            group = tuple(sorted(_expand_cpulist(Path(sib_file).read_text())))
            if group:
                phys_groups[group[0]] = group
                all_cpus.extend(group)
        except Exception:
            continue

    if not phys_groups:
        n = os.cpu_count() or 4
        all_list = list(range(n))
        return {
            "render_core": str(min(2, n - 1)),
            "wine_core": str(min(1, n - 1)),
            "worker_cores": _format_cpulist(all_list[3:] or all_list),
            "bg_cpus": _format_cpulist([0] + all_list[3:]),
        }

    cores = [phys_groups[k] for k in sorted(phys_groups)]
    n_cores = len(cores)
    wine_group = cores[1] if n_cores >= 3 else cores[0]
    render_group = cores[2] if n_cores >= 3 else cores[-1]

    if n_cores >= 8:
        worker_list = [g[0] for g in cores[4:8]]
    elif n_cores >= 4:
        worker_list = [g[0] for g in cores[3:]]
    else:
        worker_list = [render_group[0]]

    isolated_sibs = set(wine_group) | set(render_group)
    bg_list = [c for c in sorted(set(all_cpus)) if c not in isolated_sibs] or sorted(set(all_cpus))

    return {
        "wine_core": str(wine_group[0]),
        "render_core": str(render_group[0]),
        "worker_cores": _format_cpulist(worker_list),
        "bg_cpus": _format_cpulist(bg_list),
    }


def _run_quiet(cmd: list):
    subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=False)


def ensure_performance_governor():
    for gov in glob.glob("/sys/devices/system/cpu/cpu*/cpufreq/scaling_governor"):
        try:
            if Path(gov).read_text().strip() == "powersave":
                _run_quiet(["pkexec", "/usr/lib/gamemode/cpugovctl", "set", "performance"])
                return
        except Exception:
            continue


def find_pid_by_comm(comm: str) -> str:
    try:
        out = subprocess.check_output(["ps", "-eo", "pid,comm"], text=True)
        for line in out.splitlines():
            parts = line.split(None, 1)
            if len(parts) == 2 and parts[1].strip() == comm:
                return parts[0].strip()
    except Exception:
        pass
    return ""


def apply_affinity(ql_pid: str, ws_pid: str, layout: dict, bg_pattern: str, nice_val: int, set_gov: bool):
    if set_gov:
        ensure_performance_governor()

    _run_quiet(["taskset", "-p", "-c", layout["render_core"], ql_pid])

    for task_dir in glob.glob(f"/proc/{ql_pid}/task/*"):
        tid = os.path.basename(task_dir)
        if tid != ql_pid:
            _run_quiet(["taskset", "-p", "-c", layout["worker_cores"], tid])

    if ws_pid:
        _run_quiet(["taskset", "-p", "-c", layout["wine_core"], ws_pid])

    try:
        bg_out = subprocess.check_output(["pgrep", "-fi", bg_pattern], text=True)
        for bg_pid in bg_out.split():
            if bg_pid not in (ql_pid, ws_pid):
                _run_quiet(["taskset", "-a", "-p", "-c", layout["bg_cpus"], bg_pid])
    except Exception:
        pass

    pids = [ql_pid] + ([ws_pid] if ws_pid else [])
    _run_quiet(["renice", "-n", str(nice_val), "-p", *pids])


def clean_quakelive_repconfigs():
    for cfg in glob.glob(os.path.expanduser("~/.local/share/Steam/steamapps/common/Quake Live/*/baseq3/repconfig.cfg")):
        try:
            p = Path(cfg)
            txt = p.read_text(encoding="latin1", errors="ignore")
            new_txt = txt.replace('seta cg_autoAction "3"', 'seta cg_autoAction "0"').replace('seta cg_nopredict "1"', 'seta cg_nopredict "0"')
            if new_txt != txt:
                p.write_text(new_txt, encoding="latin1")
        except Exception:
            pass


def main():
    default_layout = detect_cpu_layout()
    parser = argparse.ArgumentParser(description="CPU core-pinning and background thread fencer for Wine/Proton games.")
    parser.add_argument("--game-comm", default="quakelive_steam", help="Process comm name to pin (default: quakelive_steam)")
    parser.add_argument("--render-core", default=default_layout["render_core"], help="CPU core for game main thread")
    parser.add_argument("--wine-core", default=default_layout["wine_core"], help="CPU core for wineserver")
    parser.add_argument("--worker-cores", default=default_layout["worker_cores"], help="CPU list for secondary game threads")
    parser.add_argument("--bg-cpus", default=default_layout["bg_cpus"], help="CPU list for fenced background processes")
    parser.add_argument("--bg-pattern", default="chrome|brave|steam|discord|plex|pipewire|wireplumber|Xwayland|gnome-shell|winedevice|svchost|tabtip|awesomium|explorer")
    parser.add_argument("--nice", type=int, default=-10, help="Renice priority when permitted (default: -10)")
    parser.add_argument("--no-governor", action="store_true", help="Do not switch cpufreq governor to performance")
    parser.add_argument("--clean-ql-cfg", action="store_true", help="Reset intrusive repconfig.cfg cvars when Quake Live is idle")
    parser.add_argument("--print-layout", action="store_true", help="Print computed CPU topology layout and exit")
    args = parser.parse_args()

    layout = {
        "render_core": args.render_core,
        "wine_core": args.wine_core,
        "worker_cores": args.worker_cores,
        "bg_cpus": args.bg_cpus,
    }
    if args.print_layout:
        print(f"Detected/Active CPU layout: {layout}")
        return

    print(f"[*] Wine Core Fencer watching comm='{args.game_comm}' with layout {layout}")
    if not args.no_governor:
        ensure_performance_governor()

    while True:
        game_pid = find_pid_by_comm(args.game_comm)
        if game_pid:
            ws_pid = find_pid_by_comm("wineserver")
            apply_affinity(game_pid, ws_pid, layout, args.bg_pattern, args.nice, not args.no_governor)
            time.sleep(5)
        else:
            if args.clean_ql_cfg:
                clean_quakelive_repconfigs()
            time.sleep(3)


if __name__ == "__main__":
    main()
