#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
AutoVol (Tray) — zero-config, self-healing auto volume learner.

What it tries to do:
- Watch "how loud the system audio is" (best effort: real loopback audio; fallback: peak meter).
- Learn when you turn volume down (stores the loudness level at that moment).
- Next time it detects you're above your learned loudness threshold, it gently ducks volume.

v0.10.11 fixes vs v0.10.10 (quality-of-life + fewer “sampler thrash” loops):
- BETTER: Smarter audio-device picking (especially avoids HDMI/Display endpoints when possible).
  * soundcard loopback no longer blindly prefers a “bad” default speaker (HDMI/display/etc).
  * sounddevice WASAPI output selection uses a score-based pick, not just default output.
- BETTER: Sampler selection preflight now requires actual sample flow (recent window n>0),
  not just “stream opened”. This prevents picking a sampler that’s dead-on-arrival.
- BETTER: Adds per-sampler exponential backoff when a sampler repeatedly fails preflight,
  so the system doesn’t rotate through the same broken sources every ~15s forever.
- BETTER: Pycaw “degraded” threshold relaxed so it keeps trying longer on flaky COM systems
  instead of force-switching too aggressively.
- KEEP: Prior COM-finalizer safety and WinVolSTA thread join behavior.

Run:
  python autovol_tray.py

Data dir (Windows):
  %LOCALAPPDATA%\\AutoVol
"""

from __future__ import annotations

import os
import sys
import math
import time
import json
import platform
import threading
import argparse
import queue
import subprocess
import traceback
import logging
import gc
from logging.handlers import RotatingFileHandler
from typing import Deque, Dict, List, Optional, Tuple, Callable, Any
from collections import deque
from dataclasses import dataclass

__version__ = "0.10.11"
_WIN = platform.system().lower().startswith("win")

DEFAULT_SR = 48000
DEFAULT_FRAME_S = 0.20
DEFAULT_FRAMES = int(round(DEFAULT_SR * DEFAULT_FRAME_S))

# ------------------ dependency bootstrap ------------------

_NO_AUTOINSTALL = ("--no-autoinstall" in sys.argv)


def _pip_install(pkgs: List[str]) -> bool:
    """Best-effort dependency install.

    If you're NOT in a venv, install into per-user site-packages (avoids admin/permission issues).
    If you're in a venv, install into the venv as normal.
    """
    try:
        in_venv = (getattr(sys, "base_prefix", sys.prefix) != sys.prefix) or bool(os.environ.get("VIRTUAL_ENV"))
        cmd = [sys.executable, "-m", "pip", "install", "--upgrade"]
        if not in_venv:
            cmd.append("--user")
        cmd += pkgs
        p = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
        if p.returncode != 0:
            logging.info("[deps] pip failed (%s):\n%s", p.returncode, p.stdout[-3000:])
        return (p.returncode == 0)
    except Exception:
        return False


def _ensure_deps(auto_install: bool = True) -> None:
    need: List[str] = []

    try:
        import numpy  # noqa: F401
    except Exception:
        need.append("numpy")

    try:
        import PIL  # noqa: F401
    except Exception:
        need.append("Pillow")

    try:
        import pystray  # noqa: F401
    except Exception:
        need.append("pystray")

    if _WIN:
        try:
            import comtypes  # noqa: F401
        except Exception:
            need.append("comtypes")
        try:
            import pycaw  # noqa: F401
        except Exception:
            need.append("pycaw")
        try:
            import win32api  # type: ignore  # noqa: F401
        except Exception:
            need.append("pywin32")

    try:
        import sounddevice  # noqa: F401
    except Exception:
        need.append("sounddevice")

    # Optional fallback
    try:
        import soundcard  # noqa: F401
    except Exception:
        if auto_install:
            need.append("soundcard")

    # Optional VAD (do not force install)
    try:
        import webrtcvad  # noqa: F401
    except Exception:
        pass

    if need and auto_install:
        _pip_install(need)


# Install before importing heavy deps (best effort).
try:
    _ensure_deps(auto_install=(not _NO_AUTOINSTALL))
except Exception:
    pass

# Third-party deps
import numpy as np

try:
    import sounddevice as sd
except Exception:
    sd = None

try:
    import soundcard as sc
except Exception:
    sc = None

try:
    import webrtcvad  # type: ignore
    _HAVE_WEBRTCVAD = True
except Exception:
    webrtcvad = None
    _HAVE_WEBRTCVAD = False

import pystray
from pystray import MenuItem as Item, Menu
from PIL import Image, ImageDraw


# ------------------ logging ------------------

def _default_data_dir() -> str:
    if _WIN and "LOCALAPPDATA" in os.environ:
        return os.path.join(os.environ["LOCALAPPDATA"], "AutoVol")
    return os.path.abspath(".")


def setup_logging(data_dir: str) -> str:
    os.makedirs(data_dir, exist_ok=True)
    log_path = os.path.join(data_dir, "autovol.log")

    logger = logging.getLogger()
    logger.setLevel(logging.INFO)

    fmt = logging.Formatter("%(asctime)s %(levelname)s %(threadName)s %(message)s")
    fh = RotatingFileHandler(log_path, maxBytes=512_000, backupCount=2, encoding="utf-8")
    fh.setFormatter(fmt)
    sh = logging.StreamHandler(sys.stdout)
    sh.setFormatter(fmt)

    logger.handlers = []
    logger.addHandler(fh)
    logger.addHandler(sh)

    logging.info("AutoVol starting v%s (win=%s) data_dir=%s", __version__, _WIN, data_dir)
    logging.info("Args: %s", " ".join(sys.argv))
    if _NO_AUTOINSTALL:
        logging.info("Auto-install deps: DISABLED (--no-autoinstall)")
    return log_path


# ------------------ utils ------------------

_BAD_AUDIO_TOKENS = [
    "hdmi", "display", "nvidia", "amd", "intel", "dp audio", "display audio", "vf", "virtual",
    "monitor", "sonic", "nahimic", "remote", "wireless display",
]

_GOOD_AUDIO_TOKENS = [
    "realtek", "speakers", "speaker", "headphones", "headphone", "usb", "dac", "analog", "line out",
]


def clamp(x: float, lo: float, hi: float) -> float:
    return max(lo, min(hi, x))


def db_to_lin(db: float) -> float:
    return 10.0 ** (db / 20.0)


def rms_dbfs(x: np.ndarray, eps: float = 1e-12) -> float:
    if x is None or getattr(x, "size", 0) == 0:
        return -100.0
    if x.ndim == 2 and x.shape[1] > 1:
        x = x.mean(axis=1)
    rms = float(np.sqrt(np.mean(np.square(x), dtype=np.float64)))
    if not np.isfinite(rms) or rms <= eps:
        return -100.0
    db = 20.0 * math.log10(max(eps, rms))
    return float(max(min(db, 0.0), -100.0))


def safe_tooltip(s: str, max_len: int = 120) -> str:
    """
    Windows NOTIFYICONDATAW tooltip limit is 128 WCHAR incl null.
    Keep it comfortably below to avoid pystray ValueError.
    """
    s = s.replace("\n", " ").strip()
    if len(s) <= max_len:
        return s
    return s[: max_len - 1] + "…"


def name_score_audio_device(name: str) -> int:
    """
    Heuristic: prefer likely-real speaker endpoints, avoid HDMI/display/virtual endpoints.
    """
    n = (name or "").lower()
    score = 0
    for t in _GOOD_AUDIO_TOKENS:
        if t in n:
            score += 12
    for t in _BAD_AUDIO_TOKENS:
        if t in n:
            score -= 18
    if "realtek" in n:
        score += 25
    if "speaker" in n:
        score += 10
    if "headphone" in n:
        score += 8
    if "usb" in n:
        score += 6
    return score


def looks_bad_default_endpoint(name: str) -> bool:
    n = (name or "").lower()
    if any(t in n for t in _BAD_AUDIO_TOKENS):
        return True
    # Very low score is suspicious as "default"
    return name_score_audio_device(name) < -5


@dataclass
class Stats:
    p50: float
    p70: float
    p85: float
    p95: float
    n: int


class PercentileWindow:
    def __init__(self, frame_s: float, history_s: float):
        self.frame_s = float(frame_s)
        self.buf: Deque[Tuple[float, float]] = deque(maxlen=int(history_s / frame_s) + 16)
        self.lock = threading.Lock()

    def push(self, ts: float, db: float) -> None:
        with self.lock:
            self.buf.append((ts, db))

    def stats(self, window_s: float) -> Stats:
        cutoff = time.time() - float(window_s)
        with self.lock:
            vals = [db for (ts, db) in self.buf if ts >= cutoff]
        if not vals:
            return Stats(-100.0, -100.0, -100.0, -100.0, 0)
        vals.sort()

        def pct(p: float) -> float:
            k = int(round((len(vals) - 1) * clamp(p, 0.0, 1.0)))
            return float(vals[k])

        return Stats(p50=pct(0.50), p70=pct(0.70), p85=pct(0.85), p95=pct(0.95), n=len(vals))


# ------------------ samplers ------------------

class SamplerBase:
    """
    Samplers should be "alive" even during silence.
    Health is: are samples arriving (n>0), not whether audio is loud.
    """
    def chosen_name(self) -> Optional[str]:
        return None

    def start(self) -> None:
        pass

    def stop(self) -> None:
        pass

    def get_last_block(self) -> Optional[np.ndarray]:
        return None

    def samples_recent(self, window_s: float = 1.5) -> bool:
        try:
            win = getattr(self, "win", None)
            if win is None:
                return False
            st = win.stats(window_s)
            return st.n > 0
        except Exception:
            return False

    def sampler_key(self) -> str:
        return self.__class__.__name__


class LoopbackSampler_SD(SamplerBase):
    """
    sounddevice WASAPI loopback.

    Key detail: some PortAudio/WASAPI builds on Windows do NOT support the blocking API
    (you'll see: "Blocking API not supported yet"). To self-heal across machines, we run
    the stream in CALLBACK mode and never call stream.read().

    Strategy:
    - Prefer explicit "(loopback)" INPUT devices when present.
    - Otherwise, try output devices with WasapiSettings(loopback=True).
    - Score devices to avoid HDMI/display endpoints when possible.
    """

    def __init__(self, sr=DEFAULT_SR, frame_s=DEFAULT_FRAME_S, history_s=150.0):
        self.sr = int(sr)
        self.frame_s = float(frame_s)
        self.frames = int(round(self.frame_s * self.sr))
        self.win = PercentileWindow(frame_s, history_s)

        self.ok = False
        self._stop = threading.Event()
        self._th: Optional[threading.Thread] = None
        self._last_block: Optional[np.ndarray] = None
        self._lb_lock = threading.Lock()

        self._chosen: Optional[str] = None
        self._dev_index: Optional[int] = None
        self._extra = None

    def chosen_name(self) -> Optional[str]:
        return self._chosen if self.ok else None

    def get_last_block(self) -> Optional[np.ndarray]:
        with self._lb_lock:
            return None if self._last_block is None else self._last_block.copy()

    def _wasapi_idx(self) -> Optional[int]:
        if sd is None:
            return None
        try:
            hostapis = sd.query_hostapis()
            for i, h in enumerate(hostapis):
                if "wasapi" in str(h.get("name", "")).lower():
                    return i
        except Exception:
            return None
        return None

    def _pick_loopback_input_device(self) -> Optional[int]:
        """
        Many systems expose loopback capture as a dedicated *input* device with "(loopback)" in name.
        If present, prefer it.
        """
        if sd is None or not _WIN:
            return None
        wasapi_idx = self._wasapi_idx()
        if wasapi_idx is None:
            return None
        try:
            devs = sd.query_devices()
        except Exception:
            return None

        out_name = ""
        try:
            out_idx = int(sd.default.device[1])
            out_name = str(sd.query_devices(out_idx).get("name", "")).lower()
        except Exception:
            out_name = ""

        loopbacks: List[int] = []
        for i, d in enumerate(devs):
            try:
                if int(d.get("hostapi", -1)) != wasapi_idx:
                    continue
                if int(d.get("max_input_channels", 0)) <= 0:
                    continue
                name = str(d.get("name", "")).lower()
                if "loopback" in name or "(loopback)" in name:
                    loopbacks.append(i)
            except Exception:
                continue
        if not loopbacks:
            return None

        # Prefer loopback device that matches the default output device name
        if out_name:
            out_stem = out_name.split("(")[0].strip()
            if out_stem:
                for i in loopbacks:
                    try:
                        name = str(devs[i].get("name", "")).lower()
                        if out_stem in name:
                            return i
                    except Exception:
                        continue

        # Otherwise choose best score (avoid HDMI loopback variants when multiple exist)
        best = None
        best_score = -10_000
        for i in loopbacks:
            try:
                nm = str(devs[i].get("name", ""))
                scv = name_score_audio_device(nm)
                if scv > best_score:
                    best_score = scv
                    best = i
            except Exception:
                continue
        return best if best is not None else loopbacks[0]

    def _pick_output_device(self) -> Optional[int]:
        if sd is None or not _WIN:
            return None
        wasapi_idx = self._wasapi_idx()
        if wasapi_idx is None:
            return None
        try:
            devs = sd.query_devices()
        except Exception:
            return None

        outs: List[int] = []
        for i, d in enumerate(devs):
            try:
                if int(d.get("hostapi", -1)) == wasapi_idx and int(d.get("max_output_channels", 0)) > 0:
                    outs.append(i)
            except Exception:
                continue
        if not outs:
            return None

        # Prefer default output unless it looks like HDMI/display; then pick best-scored output.
        try:
            out_def = int(sd.default.device[1])
            if out_def in outs:
                def_name = str(devs[out_def].get("name", ""))
                if not looks_bad_default_endpoint(def_name):
                    return out_def
        except Exception:
            pass

        best = None
        best_score = -10_000
        for i in outs:
            try:
                nm = str(devs[i].get("name", ""))
                scv = name_score_audio_device(nm)
                if scv > best_score:
                    best_score = scv
                    best = i
            except Exception:
                continue
        return best if best is not None else outs[0]

    def start(self) -> None:
        if self._th or sd is None or not _WIN:
            return

        dev = self._pick_loopback_input_device()
        using_loopback_input = True
        if dev is None:
            dev = self._pick_output_device()
            using_loopback_input = False
        if dev is None:
            logging.info("[SD Loopback] no WASAPI device found.")
            return

        self._dev_index = dev
        try:
            devinfo = sd.query_devices(dev)
            devname = str(devinfo.get("name", "?"))
            max_in = int(devinfo.get("max_input_channels", 0) or 0)
            max_out = int(devinfo.get("max_output_channels", 0) or 0)
            dev_sr = float(devinfo.get("default_samplerate", self.sr) or self.sr)
        except Exception:
            devname, max_in, max_out, dev_sr = f"dev#{dev}", 0, 2, float(self.sr)

        extra = None
        try:
            extra = sd.WasapiSettings(loopback=True)
        except Exception:
            extra = None
        self._extra = extra

        if using_loopback_input:
            self._chosen = f"sd/wasapi loopback-in: {devname}"
            ch_max = max(1, max_in)
        else:
            self._chosen = f"sd/wasapi loopback: {devname}"
            ch_max = max(1, max_out)

        sr_candidates: List[int] = []
        for s in [self.sr, int(dev_sr), 48000, 44100]:
            if s > 8000 and s not in sr_candidates:
                sr_candidates.append(int(s))

        ch_candidates: List[int] = []
        for c in [2, 1]:
            if c <= ch_max:
                ch_candidates.append(c)
        if not ch_candidates:
            ch_candidates = [1]

        def cb(indata, frames, time_info, status):  # noqa: ANN001
            try:
                block = np.asarray(indata, dtype=np.float32)
                self.win.push(time.time(), rms_dbfs(block))
                with self._lb_lock:
                    self._last_block = block.copy()
            except Exception:
                pass

        def run():
            try:
                last_err = None
                stream = None

                for sr_try in sr_candidates:
                    for ch_try in ch_candidates:
                        try:
                            frames = int(round(self.frame_s * sr_try))
                            stream = sd.InputStream(
                                samplerate=sr_try,
                                channels=ch_try,
                                dtype="float32",
                                blocksize=frames,
                                device=self._dev_index,
                                extra_settings=self._extra if _WIN else None,
                                callback=cb,
                            )
                            self.sr = int(sr_try)
                            self.frames = int(frames)
                            self.ok = True
                            logging.info("[SD Loopback] opened sr=%s ch=%s (%s)", sr_try, ch_try, self._chosen)
                            break
                        except Exception as e:
                            last_err = e
                            stream = None
                    if stream is not None:
                        break

                if stream is None:
                    logging.info("[SD Loopback] init error: %r", last_err)
                    self.ok = False
                    return

                with stream:
                    while not self._stop.is_set():
                        time.sleep(0.25)
            except Exception as e:
                logging.info("[SD Loopback] thread error: %r", e)
                self.ok = False

        self._th = threading.Thread(target=run, name="SDLoopback", daemon=True)
        self._th.start()

    def stop(self) -> None:
        self._stop.set()
        if self._th:
            self._th.join(timeout=1.5)


class StereoMixSampler_SD(SamplerBase):
    """
    Capture from an *input* device that looks like "Stereo Mix"/"What U Hear".

    Use CALLBACK mode so we don't depend on PortAudio's blocking API support.
    """

    def __init__(self, sr=DEFAULT_SR, frame_s=DEFAULT_FRAME_S, history_s=150.0):
        self.sr = int(sr)
        self.frame_s = float(frame_s)
        self.frames = int(round(self.frame_s * self.sr))
        self.win = PercentileWindow(frame_s, history_s)

        self.ok = False
        self._stop = threading.Event()
        self._th: Optional[threading.Thread] = None
        self._last_block: Optional[np.ndarray] = None
        self._lb_lock = threading.Lock()

        self._chosen: Optional[str] = None
        self._dev_index: Optional[int] = None

    def chosen_name(self) -> Optional[str]:
        return self._chosen if self.ok else None

    def get_last_block(self) -> Optional[np.ndarray]:
        with self._lb_lock:
            return None if self._last_block is None else self._last_block.copy()

    def _pick_device(self) -> Optional[int]:
        if sd is None:
            return None
        try:
            devs = sd.query_devices()
        except Exception:
            return None

        needles = ["stereo mix", "what u hear", "what you hear"]
        hits: List[int] = []
        for i, d in enumerate(devs):
            try:
                name = str(d.get("name", "")).lower()
                max_in = int(d.get("max_input_channels", 0))
                if max_in <= 0:
                    continue
                if any(n in name for n in needles):
                    hits.append(i)
            except Exception:
                continue

        if not hits:
            return None

        # Prefer higher score names (realtek tends to be correct)
        best = None
        best_score = -10_000
        for i in hits:
            try:
                nm = str(devs[i].get("name", ""))
                scv = name_score_audio_device(nm)
                if scv > best_score:
                    best_score = scv
                    best = i
            except Exception:
                continue
        return best if best is not None else hits[0]

    def start(self) -> None:
        if self._th or sd is None:
            return
        dev = self._pick_device()
        if dev is None:
            return
        self._dev_index = dev

        try:
            devinfo = sd.query_devices(dev)
            devname = str(devinfo.get("name", "?"))
            max_in = int(devinfo.get("max_input_channels", 1) or 1)
            dev_sr = float(devinfo.get("default_samplerate", self.sr) or self.sr)
        except Exception:
            devname, max_in, dev_sr = f"dev#{dev}", 1, float(self.sr)

        self._chosen = f"sd/input: {devname}"

        sr_candidates: List[int] = []
        for s in [self.sr, int(dev_sr), 48000, 44100]:
            if s > 8000 and s not in sr_candidates:
                sr_candidates.append(int(s))

        ch_candidates = [c for c in [2, 1] if c <= max_in] or [1]

        def cb(indata, frames, time_info, status):  # noqa: ANN001
            try:
                block = np.asarray(indata, dtype=np.float32)
                self.win.push(time.time(), rms_dbfs(block))
                with self._lb_lock:
                    self._last_block = block.copy()
            except Exception:
                pass

        def run():
            last_err = None
            stream = None

            for sr_try in sr_candidates:
                for ch_try in ch_candidates:
                    try:
                        frames = int(round(self.frame_s * sr_try))
                        stream = sd.InputStream(
                            samplerate=sr_try,
                            channels=ch_try,
                            dtype="float32",
                            blocksize=frames,
                            device=self._dev_index,
                            callback=cb,
                        )
                        self.sr = int(sr_try)
                        self.frames = int(frames)
                        self.ok = True
                        logging.info("[StereoMix] opened sr=%s ch=%s (%s)", sr_try, ch_try, self._chosen)
                        break
                    except Exception as e:
                        last_err = e
                        stream = None
                if stream is not None:
                    break

            if stream is None:
                logging.info("[StereoMix] init error: %r", last_err)
                self.ok = False
                return

            try:
                with stream:
                    while not self._stop.is_set():
                        time.sleep(0.25)
            except Exception as e:
                logging.info("[StereoMix] thread error: %r", e)
                self.ok = False

        self._th = threading.Thread(target=run, name="StereoMix", daemon=True)
        self._th.start()

    def stop(self) -> None:
        self._stop.set()
        if self._th:
            self._th.join(timeout=1.5)


class LoopbackSampler_SC(SamplerBase):
    """python-soundcard loopback (can pick the "wrong" speaker on multi-output systems)."""

    def __init__(self, sr: int = DEFAULT_SR, frame_s: float = DEFAULT_FRAME_S, history_s: float = 150.0, dev_name: Optional[str] = None):
        self.ok = False
        self.sr = int(sr)
        self.frame_s = float(frame_s)
        self.frames = int(round(self.frame_s * self.sr))
        self.win = PercentileWindow(self.frame_s, history_s)
        self.stop_evt = threading.Event()
        self.th: Optional[threading.Thread] = None
        self._last_block: Optional[np.ndarray] = None
        self._lb_lock = threading.Lock()
        self._chosen_name: Optional[str] = None
        self._dev_name = dev_name

    def chosen_name(self) -> Optional[str]:
        return self._chosen_name if self.ok else None

    def get_last_block(self) -> Optional[np.ndarray]:
        with self._lb_lock:
            return None if self._last_block is None else self._last_block.copy()

    def _speaker_score(self, name: str) -> int:
        return name_score_audio_device(name)

    def _pick_recorder(self):
        """
        python-soundcard loopback.

        Change vs older versions:
        - We do NOT always prioritize sc.default_speaker() if it looks like HDMI/display/etc.
          Instead we score endpoints and choose the best likely-real speaker.
        """
        if sc is None:
            return None

        speakers: List[Any] = []
        try:
            speakers = list(sc.all_speakers())
        except Exception:
            speakers = []

        # If dev_name supplied, try it first.
        if self._dev_name:
            for spk in speakers:
                try:
                    if str(getattr(spk, "name", "")) == str(self._dev_name):
                        try:
                            mic = sc.get_microphone(id=str(spk.name), include_loopback=True)
                            self._chosen_name = f"soundcard loopback: {mic.name}"
                            for ch in (2, 1):
                                try:
                                    rec = mic.recorder(samplerate=self.sr, channels=ch)
                                    return rec
                                except Exception:
                                    continue
                        except Exception:
                            pass
                except Exception:
                    continue

        default_first: List[Any] = []
        try:
            d = sc.default_speaker()
            dname = str(getattr(d, "name", ""))
            if not looks_bad_default_endpoint(dname):
                default_first = [d]
                speakers = [s for s in speakers if getattr(s, "name", None) != getattr(d, "name", None)]
            else:
                # Bad default endpoint: do NOT force it to the front.
                default_first = []
        except Exception:
            default_first = []

        speakers_sorted = sorted(
            speakers,
            key=lambda s: self._speaker_score(getattr(s, "name", "")),
            reverse=True,
        )

        candidates = (default_first + speakers_sorted)[:14]

        for spk in candidates:
            try:
                mic = sc.get_microphone(id=str(spk.name), include_loopback=True)
                self._chosen_name = f"soundcard loopback: {mic.name}"
                for ch in (2, 1):
                    try:
                        rec = mic.recorder(samplerate=self.sr, channels=ch)
                        return rec
                    except Exception:
                        continue
            except Exception:
                continue

        return None

    def start(self) -> None:
        if self.th or sc is None:
            return
        rec = self._pick_recorder()
        if rec is None:
            return

        def run():
            try:
                with rec:
                    while not self.stop_evt.is_set():
                        try:
                            block = rec.record(self.frames)
                            block = np.asarray(block, dtype=np.float32)
                            self.win.push(time.time(), rms_dbfs(block))
                            with self._lb_lock:
                                self._last_block = block.copy()
                        except Exception:
                            time.sleep(0.05)
            except Exception:
                pass

        self.th = threading.Thread(target=run, name="SCLoopback", daemon=True)
        self.th.start()
        self.ok = True
        logging.info("[soundcard loopback] running: %s", self._chosen_name)

    def stop(self) -> None:
        self.stop_evt.set()
        if self.th:
            self.th.join(timeout=1.5)


class PycawPeakSampler(SamplerBase):
    """
    Reliable-ish fallback: system output peak meter via Pycaw.

    Notes:
    - This sampler does NOT provide raw audio blocks (so VAD is disabled).
    - Some systems throw intermittent COM errors on GetPeakValue(). We keep emitting samples
      (using last known value) and aggressively re-acquire the meter to self-heal.

    v0.10.11: relaxed "degraded" threshold so we don't force-switch too aggressively.
    """

    def __init__(self, frame_s=DEFAULT_FRAME_S, history_s=150.0):
        self.frame_s = float(frame_s)
        self.win = PercentileWindow(frame_s, history_s)
        self._stop = threading.Event()
        self._th: Optional[threading.Thread] = None
        self._ok = False

        self._mu = threading.Lock()
        self._succ = 0
        self._fail = 0
        self._fail_streak = 0
        self._last_ok_ts = 0.0

    def chosen_name(self) -> Optional[str]:
        return "pycaw peak meter" if self._ok else None

    def is_degraded(self) -> bool:
        with self._mu:
            if not self._ok:
                return True
            now = time.time()
            # v0.10.11: be less trigger-happy.
            # Only declare degraded if we haven't had a successful read in a long time AND fail streak is huge.
            if (now - self._last_ok_ts) > 60.0 and self._fail_streak >= 500:
                return True
            return False

    def start(self) -> None:
        if self._th or not _WIN:
            return

        def run():
            meter = None
            last_db = -100.0

            def acquire():
                nonlocal meter
                try:
                    import ctypes
                    from ctypes import POINTER
                    from pycaw.pycaw import AudioUtilities, IAudioMeterInformation
                    from comtypes import CLSCTX_ALL

                    dev = AudioUtilities.GetSpeakers()
                    iface = dev.Activate(IAudioMeterInformation._iid_, CLSCTX_ALL, None)
                    meter = ctypes.cast(iface, POINTER(IAudioMeterInformation))
                    return True
                except Exception as e:
                    logging.info("[PycawMeter] acquire failed: %r", e)
                    meter = None
                    return False

            CoUninitialize = None
            try:
                try:
                    from comtypes import CoInitializeEx, CoUninitialize as _CoUninitialize, COINIT_MULTITHREADED
                    CoUninitialize = _CoUninitialize
                    CoInitializeEx(COINIT_MULTITHREADED)
                except Exception:
                    from comtypes import CoInitialize, CoUninitialize as _CoUninitialize
                    CoUninitialize = _CoUninitialize
                    CoInitialize()

                try:
                    ok = acquire()
                    self._ok = bool(ok)
                    if self._ok:
                        logging.info("[PycawMeter] running.")

                    last_log = 0.0
                    while not self._stop.is_set():
                        db = last_db
                        try:
                            if meter is None:
                                acquire()

                            if meter is not None:
                                import ctypes
                                from ctypes import byref, c_float

                                v = c_float()
                                meter.GetPeakValue(byref(v))
                                peak = float(v.value)
                                if peak <= 0.0 or not math.isfinite(peak):
                                    db = -100.0
                                else:
                                    db = 20.0 * math.log10(max(1e-9, peak))
                                last_db = db

                                with self._mu:
                                    self._succ += 1
                                    self._fail_streak = 0
                                    self._last_ok_ts = time.time()
                            else:
                                raise RuntimeError("meter not acquired")
                        except Exception:
                            with self._mu:
                                self._fail += 1
                                self._fail_streak += 1
                                fs = self._fail_streak

                            if fs in (1, 10, 25, 50, 100, 200) or (time.time() - last_log) > 15.0:
                                last_log = time.time()
                                logging.info("[PycawMeter] read error (x%s) — continuing.", fs)

                            # keep trying to reacquire periodically, but don't force-switch early
                            if fs in (3, 10, 25, 50, 100, 200, 350) or (time.time() - self._last_ok_ts) > 10.0:
                                acquire()

                        # ALWAYS push a sample (even last known) so the controller sees "alive"
                        self.win.push(time.time(), db)
                        time.sleep(self.frame_s)
                finally:
                    # IMPORTANT: drop COM interface refs BEFORE CoUninitialize
                    try:
                        meter = None
                        gc.collect()
                    except Exception:
                        pass
                    try:
                        if CoUninitialize is not None:
                            CoUninitialize()
                    except Exception:
                        pass
            except Exception as e:
                logging.info("[PycawMeter] init error: %r", e)

        self._th = threading.Thread(target=run, name="PycawMeter", daemon=True)
        self._th.start()

    def stop(self) -> None:
        self._stop.set()
        if self._th:
            self._th.join(timeout=2.5)


class MeterSampler(SamplerBase):
    """
    Last-resort COM meter via CreateObject("MMDeviceEnumerator") and IAudioMeterInformation.
    """

    def __init__(self, frame_s=DEFAULT_FRAME_S, history_s=150.0):
        self.frame_s = float(frame_s)
        self.win = PercentileWindow(frame_s, history_s)
        self._ok = False
        self._stop = threading.Event()
        self._th: Optional[threading.Thread] = None

        self._mu = threading.Lock()
        self._fail_streak = 0
        self._last_ok_ts = 0.0

    def chosen_name(self) -> Optional[str]:
        return "endpoint peak meter" if self._ok else None

    def is_degraded(self) -> bool:
        with self._mu:
            if not self._ok:
                return True
            # slightly relaxed vs old: require longer time with no ok and a big fail streak
            if (time.time() - self._last_ok_ts) > 60.0 and self._fail_streak >= 500:
                return True
            return False

    def start(self) -> None:
        if self._th or not _WIN:
            return

        def run():
            meter = None
            last_db = -100.0

            def acquire():
                nonlocal meter
                try:
                    import ctypes
                    from ctypes import POINTER, byref, c_float, c_int, c_void_p, c_ulong
                    from comtypes import (
                        IUnknown, GUID, HRESULT, COMMETHOD,
                        CLSCTX_ALL,
                    )
                    from comtypes.client import CreateObject

                    eRender = 0
                    eMultimedia = 1

                    class IMMDevice(IUnknown):
                        _iid_ = GUID('{D666063F-1587-4E43-81F1-B948E807363F}')
                        _methods_ = [
                            COMMETHOD([], HRESULT, 'Activate',
                                      (['in'], GUID, 'iid'),
                                      (['in'], c_ulong, 'dwClsCtx'),
                                      (['in'], c_void_p, 'pActivationParams'),
                                      (['out'], POINTER(c_void_p), 'ppInterface')),
                        ]

                    class IMMDeviceEnumerator(IUnknown):
                        _iid_ = GUID('{A95664D2-9614-4F35-A746-DE8DB63617E6}')
                        _methods_ = [
                            COMMETHOD([], HRESULT, 'GetDefaultAudioEndpoint',
                                      (['in'], c_int, 'dataFlow'),
                                      (['in'], c_int, 'role'),
                                      (['out'], POINTER(POINTER(IMMDevice)), 'ppDevice')),
                        ]

                    class IAudioMeterInformation(IUnknown):
                        _iid_ = GUID('{C02216F6-8C67-4B5B-9D00-D008E73E0064}')
                        _methods_ = [
                            COMMETHOD([], HRESULT, 'GetPeakValue',
                                      (['out'], POINTER(c_float), 'pfPeak')),
                        ]

                    enum = CreateObject("MMDeviceEnumerator", interface=IMMDeviceEnumerator)
                    dev = POINTER(IMMDevice)()
                    hr = enum.GetDefaultAudioEndpoint(eRender, eMultimedia, byref(dev))
                    if hr:
                        raise OSError(f"GetDefaultAudioEndpoint failed hr=0x{hr:08X}")
                    ptr = c_void_p()
                    hr = dev.Activate(IAudioMeterInformation._iid_, CLSCTX_ALL, None, byref(ptr))
                    if hr:
                        raise OSError(f"Activate(IAudioMeterInformation) failed hr=0x{hr:08X}")

                    meter = ctypes.cast(ptr, POINTER(IAudioMeterInformation))
                    return True
                except Exception as e:
                    logging.info("[Meter] acquire failed: %r", e)
                    meter = None
                    return False

            CoUninitialize = None
            try:
                try:
                    from comtypes import CoInitializeEx, CoUninitialize as _CoUninitialize, COINIT_MULTITHREADED
                    CoUninitialize = _CoUninitialize
                    CoInitializeEx(COINIT_MULTITHREADED)
                except Exception:
                    from comtypes import CoInitialize, CoUninitialize as _CoUninitialize
                    CoUninitialize = _CoUninitialize
                    CoInitialize()

                try:
                    ok = acquire()
                    self._ok = bool(ok)
                    if self._ok:
                        logging.info("[Meter] running (COM peak).")

                    last_log = 0.0
                    while not self._stop.is_set():
                        db = last_db
                        try:
                            if meter is None:
                                acquire()

                            if meter is not None:
                                from ctypes import byref, c_float
                                v = c_float()
                                meter.GetPeakValue(byref(v))
                                peak = float(v.value)
                                if peak <= 0.0 or not math.isfinite(peak):
                                    db = -100.0
                                else:
                                    db = 20.0 * math.log10(max(1e-9, peak))
                                last_db = db

                                with self._mu:
                                    self._fail_streak = 0
                                    self._last_ok_ts = time.time()
                            else:
                                raise RuntimeError("meter not acquired")
                        except Exception:
                            with self._mu:
                                self._fail_streak += 1
                                fs = self._fail_streak

                            if fs in (1, 10, 25, 50, 100, 200) or (time.time() - last_log) > 15.0:
                                last_log = time.time()
                                logging.info("[Meter] read error (x%s) — continuing.", fs)

                            if fs in (3, 10, 25, 50, 100, 200, 350):
                                acquire()

                        self.win.push(time.time(), db)
                        time.sleep(self.frame_s)
                finally:
                    # IMPORTANT: drop COM interface refs BEFORE CoUninitialize
                    try:
                        meter = None
                        gc.collect()
                    except Exception:
                        pass
                    try:
                        if CoUninitialize is not None:
                            CoUninitialize()
                    except Exception:
                        pass
            except Exception as e:
                logging.info("[Meter] init error: %r", e)

        self._th = threading.Thread(target=run, name="MeterCOM", daemon=True)
        self._th.start()

    def stop(self) -> None:
        self._stop.set()
        if self._th:
            self._th.join(timeout=2.5)


# ------------------ volume backends ------------------

class VolBackend:
    def get(self) -> float:
        raise NotImplementedError

    def set(self, s: float) -> None:
        raise NotImplementedError


class WinVolSTA(VolBackend):
    """System master volume via pycaw on a dedicated COM thread."""

    def __init__(self):
        self._q: queue.Queue = queue.Queue()
        self._ready = threading.Event()
        self._stop = threading.Event()
        self._th = threading.Thread(target=self._run, name="WinVolCOM", daemon=True)
        self._th.start()
        if not self._ready.wait(timeout=2.5):
            raise RuntimeError("WinVolSTA COM init timed out")

    def _run(self):
        dev = None
        iface = None
        ep = None
        CoUninitialize = None
        try:
            from comtypes import CoInitialize, CoUninitialize as _CoUninitialize, CLSCTX_ALL  # type: ignore
            from ctypes import POINTER, cast
            from pycaw.pycaw import AudioUtilities, IAudioEndpointVolume  # type: ignore

            CoUninitialize = _CoUninitialize

            CoInitialize()
            try:
                dev = AudioUtilities.GetSpeakers()
                iface = dev.Activate(IAudioEndpointVolume._iid_, CLSCTX_ALL, None)
                ep = cast(iface, POINTER(IAudioEndpointVolume))
                self._ready.set()

                while not self._stop.is_set():
                    try:
                        op, val, ack = self._q.get(timeout=0.1)
                    except queue.Empty:
                        continue
                    try:
                        if op == "get":
                            ack.set_result(float(ep.GetMasterVolumeLevelScalar()))
                        elif op == "set":
                            ep.SetMasterVolumeLevelScalar(clamp(float(val), 0.0, 1.0), None)
                            ack.set_result(True)
                        elif op == "quit":
                            ack.set_result(True)
                            break
                    except Exception as e:
                        ack.set_exception(e)
            finally:
                # IMPORTANT: drop COM interface refs BEFORE CoUninitialize
                try:
                    ep = None
                    iface = None
                    dev = None
                    gc.collect()
                except Exception:
                    pass
                try:
                    if CoUninitialize is not None:
                        CoUninitialize()
                except Exception:
                    pass
        except Exception as e:
            self._ready.set()
            try:
                while True:
                    op, val, ack = self._q.get_nowait()
                    ack.set_exception(e)
            except queue.Empty:
                pass

    class _Ack:
        def __init__(self):
            self._ev = threading.Event()
            self._res = None
            self._exc: Optional[BaseException] = None

        def set_result(self, r):
            self._res = r
            self._ev.set()

        def set_exception(self, e: BaseException):
            self._exc = e
            self._ev.set()

        def wait(self, timeout=None):
            ok = self._ev.wait(timeout)
            if not ok:
                raise TimeoutError("WinVolSTA RPC timed out")
            if self._exc:
                raise self._exc
            return self._res

    def _rpc(self, op: str, val=None, timeout=2.0):
        ack = WinVolSTA._Ack()
        self._q.put((op, val, ack))
        return ack.wait(timeout=timeout)

    def get(self) -> float:
        try:
            return float(self._rpc("get"))
        except Exception:
            return 0.5

    def set(self, s: float) -> None:
        try:
            self._rpc("set", s)
        except Exception:
            pass

    def close(self):
        try:
            self._rpc("quit", timeout=1.5)
        except Exception:
            pass
        self._stop.set()
        try:
            if self._th and self._th.is_alive():
                self._th.join(timeout=2.5)
        except Exception:
            pass


class DryVol(VolBackend):
    def __init__(self):
        self._s = 0.4

    def get(self) -> float:
        return self._s

    def set(self, s: float) -> None:
        self._s = clamp(float(s), 0.0, 1.0)


def choose_backend(force_dry: bool = False) -> VolBackend:
    if not _WIN or force_dry:
        logging.info("[Vol] Using DryVol (no system changes).")
        return DryVol()
    try:
        bk = WinVolSTA()
        logging.info("[Vol] Using WinVolSTA (COM thread).")
        return bk
    except Exception as e:
        logging.info("[Vol] Falling back to DryVol: %r", e)
        return DryVol()


# ------------------ learner ------------------

class Learner:
    def __init__(self, path: str, min_events=6, q=0.70):
        self.path = path
        self.min_events = int(min_events)
        self.q = float(q)
        self.global_downs: Deque[float] = deque(maxlen=600)
        self.hour_downs: Dict[int, Deque[float]] = {h: deque(maxlen=300) for h in range(24)}
        self._mu = threading.Lock()
        self.load()

    def load(self):
        if not os.path.exists(self.path):
            return
        try:
            with open(self.path, "r", encoding="utf-8") as f:
                data = json.load(f)
        except Exception as e:
            logging.info("[Learner] load error: %r", e)
            return

        with self._mu:
            self.global_downs.clear()
            for h in range(24):
                self.hour_downs[h].clear()

            g_src = data.get("global_downs", [])
            if isinstance(g_src, list):
                for x in g_src[-600:]:
                    try:
                        self.global_downs.append(float(x))
                    except Exception:
                        pass

            h_src = data.get("hour_downs", {})
            if isinstance(h_src, dict):
                for k, arr in h_src.items():
                    try:
                        h = int(k)
                        if 0 <= h <= 23 and isinstance(arr, list):
                            for x in arr[-300:]:
                                try:
                                    self.hour_downs[h].append(float(x))
                                except Exception:
                                    pass
                    except Exception:
                        continue

    def save(self):
        try:
            with self._mu:
                out = {
                    "global_downs": list(self.global_downs),
                    "hour_downs": {str(h): list(self.hour_downs[h]) for h in range(24)},
                }
            tmp = self.path + ".tmp"
            with open(tmp, "w", encoding="utf-8") as f:
                json.dump(out, f)
            os.replace(tmp, self.path)
        except Exception as e:
            logging.info("[Learner] save error: %r", e)

    @staticmethod
    def _percentile(vals: List[float], q: float) -> float:
        if not vals:
            return -100.0
        s = sorted(vals)
        k = int(round((len(s) - 1) * clamp(q, 0.0, 1.0)))
        return float(s[k])

    def record_down(self, db_at: float, hour: int):
        with self._mu:
            self.global_downs.append(float(db_at))
            if 0 <= hour <= 23:
                self.hour_downs[hour].append(float(db_at))

    def threshold(self, hour: int) -> Optional[float]:
        with self._mu:
            per = self.hour_downs.get(hour, deque())
            g = self.global_downs

            if len(per) >= self.min_events:
                q_use = 0.75 if len(per) > 20 else self.q
                return self._percentile(list(per), q_use)

            if len(g) >= self.min_events:
                q_use = 0.75 if len(g) > 20 else self.q
                return self._percentile(list(g), q_use)

        return None

    def counts(self) -> Tuple[int, Dict[int, int]]:
        with self._mu:
            return len(self.global_downs), {h: len(self.hour_downs[h]) for h in range(24)}

    def reset(self):
        with self._mu:
            self.global_downs.clear()
            for h in range(24):
                self.hour_downs[h].clear()
        self.save()


# ------------------ speech gate ------------------

class SpeechGate:
    def __init__(self, fs_capture: int, frame_ms: int = 20, aggressiveness: int = 2, ema_alpha: float = 0.35):
        self.fs_cap = int(fs_capture)
        self.frame_ms = int(frame_ms)
        self._ema = 0.0
        self._alpha = float(clamp(ema_alpha, 0.0, 1.0))
        self._have_vad = _HAVE_WEBRTCVAD
        if self._have_vad:
            self.vad = webrtcvad.Vad(int(clamp(aggressiveness, 0, 3)))

    def _to_16k_pcm16(self, x: np.ndarray) -> Tuple[bytes, int]:
        if x.ndim > 1:
            x = x.mean(axis=1)
        fs16 = 16000
        if self.fs_cap == 48000:
            x = x[::3]
        else:
            idx = np.linspace(0, len(x) - 1, int(len(x) * fs16 / self.fs_cap))
            x = np.interp(idx, np.arange(len(x)), x).astype(np.float32)
        x = np.clip(x, -1.0, 1.0)
        return (x * 32767.0).astype(np.int16).tobytes(), fs16

    def _heuristic_prob(self, block: np.ndarray) -> float:
        if block.ndim > 1:
            x = block.mean(axis=1).astype(np.float32, copy=False)
        else:
            x = block.astype(np.float32, copy=False)

        e_db = 20.0 * math.log10(max(1e-9, float(np.sqrt(np.mean(x * x)))))
        if e_db <= -55.0 or len(x) < 512:
            return 0.0

        zc = float(np.mean((x[1:] * x[:-1]) < 0.0))
        X = np.fft.rfft(x * np.hanning(len(x)))
        mag = np.abs(X) + 1e-9
        freqs = np.fft.rfftfreq(len(x), 1.0 / self.fs_cap)
        hf = float(mag[freqs >= 2000].sum() / mag.sum())
        return 1.0 if (0.03 <= zc <= 0.25) and (0.05 <= hf <= 0.60) else 0.0

    def prob(self, block: Optional[np.ndarray]) -> float:
        if block is None or getattr(block, "size", 0) == 0:
            self._ema = (1.0 - self._alpha) * self._ema
            return self._ema

        if self._have_vad:
            try:
                pcm16, fs16 = self._to_16k_pcm16(block)
                frame_len = int((self.frame_ms / 1000.0) * fs16)
                hits = 0
                total = 0
                step = frame_len * 2
                for i in range(0, len(pcm16), step):
                    frame = pcm16[i: i + step]
                    if len(frame) < step:
                        break
                    total += 1
                    if self.vad.is_speech(frame, fs16):
                        hits += 1
                raw = (hits / total) if total else 0.0
            except Exception:
                raw = 0.0
        else:
            raw = self._heuristic_prob(block)

        self._ema = self._alpha * raw + (1.0 - self._alpha) * self._ema
        return self._ema


# ------------------ volume poller ------------------

class VolumePoller:
    def __init__(self, bk, poll_s=0.05, min_step=0.005):
        self.bk = bk
        self.poll_s = float(poll_s)
        self.min_step = float(min_step)
        self._stop = threading.Event()
        self._thr: Optional[threading.Thread] = None
        self._prev = self.bk.get()
        self._callbacks: List[Callable[[float, float, float], None]] = []

    def on_change(self, fn: Callable[[float, float, float], None]):
        self._callbacks.append(fn)

    def start(self):
        if self._thr:
            return

        def run():
            while not self._stop.is_set():
                time.sleep(self.poll_s)
                try:
                    cur = self.bk.get()
                except Exception:
                    continue
                prev = self._prev
                if abs(cur - prev) >= self.min_step:
                    ts = time.time()
                    for fn in self._callbacks:
                        try:
                            fn(ts, prev, cur)
                        except Exception:
                            pass
                    self._prev = cur

        self._thr = threading.Thread(target=run, name="VolPoll", daemon=True)
        self._thr.start()

    def stop(self):
        self._stop.set()
        if self._thr:
            self._thr.join(timeout=1.5)


# ------------------ controller ------------------

class AutoVolController:
    def __init__(self, model_path: str, events_path: str, force_dryvol: bool = False):
        self.model_path = model_path
        self.events_path = events_path

        self.FRAME_S = DEFAULT_FRAME_S
        self.BASELINE_WIN_S = 45.0
        self.SHORT_WIN_S = 1.0

        self.OVER_MARGIN_DB = 1.2
        self.ATTACK_DB_MAX = 1.6
        self.RELEASE_DB_MAX = 0.45
        self.MIN_VOL = 0.03

        self.SPEECH_UP_DB = 2.0
        self.NOSPEECH_DOWN_DB = -2.0

        self.IGNORE_OWN_SET_S = 0.8
        self.USER_DOWN_COOLDOWN_S = 1.2
        self.SET_COOLDOWN_S = 1.6
        self.STARTUP_OBS_S = 6.0

        self.NO_SAMPLE_GRACE_S = 8.0
        self.SWITCH_COOLDOWN_S = 15.0

        # v0.10.11: selection preflight and backoff (reduces infinite sampler cycling)
        self.SAMPLER_PREFLIGHT_S = 4.5
        self.SAMPLER_BACKOFF_BASE_S = 25.0
        self.SAMPLER_BACKOFF_MAX_S = 15 * 60.0

        self._stop = threading.Event()
        self._paused = threading.Event()
        self._observe = threading.Event()  # observe-only mode (no volume changes)
        self._thread: Optional[threading.Thread] = None
        self._last_set_ts = 0.0
        self._last_user_down_ts = 0.0
        self._startup_ts = time.time()

        self.observe_only = False

        self._last_th: Optional[float] = None
        self._last_p85 = -100.0
        self._last_p95 = -100.0
        self._speech = 0.0
        self._flash_duck_until = 0.0

        self._signal_state = "INIT"
        self._last_sample_ts = time.time()
        self._last_switch_ts = 0.0

        self.bk = choose_backend(force_dry=force_dryvol)
        self.learner = Learner(path=self.model_path)
        self._downs_total = self.learner.counts()[0]

        try:
            self.events = open(self.events_path, "a", encoding="utf-8")
        except Exception as e:
            logging.info("[AutoVol] cannot open events file: %r", e)
            self.events = None

        self.resting = self.bk.get()
        self.current = self.resting

        self.poll = VolumePoller(self.bk, poll_s=0.05, min_step=0.005)
        self.poll.on_change(self._on_user_change)

        self.vad = SpeechGate(fs_capture=48000, frame_ms=20, aggressiveness=2, ema_alpha=0.35)

        self._samplers: List[SamplerBase] = [
            LoopbackSampler_SD(sr=48000, frame_s=self.FRAME_S, history_s=150.0),
            LoopbackSampler_SC(sr=48000, frame_s=self.FRAME_S, history_s=150.0),
            PycawPeakSampler(frame_s=self.FRAME_S, history_s=150.0),
            StereoMixSampler_SD(sr=48000, frame_s=self.FRAME_S, history_s=150.0),
            MeterSampler(frame_s=self.FRAME_S, history_s=150.0),
        ]

        self.sampler: Optional[SamplerBase] = None
        self._sampler_idx = -1

        # v0.10.11: per-sampler backoff
        self._sampler_fail: Dict[str, Dict[str, float]] = {}

        self._switch_sampler(reason="startup")

        bk_name = "WinVolSTA" if isinstance(self.bk, WinVolSTA) else "DryVol"
        src = self.sampler.chosen_name() if self.sampler else "none"
        logging.info("[AutoVol] backend=%s sampler=%s model=%s events=%s", bk_name, src, self.model_path, self.events_path)

    @property
    def observe_only(self) -> bool:
        """If True, AutoVol will not change system volume (it still learns + shows stats)."""
        return bool(self._observe.is_set())

    @observe_only.setter
    def observe_only(self, v: bool) -> None:
        if bool(v):
            self._observe.set()
        else:
            self._observe.clear()

    def _write_event(self, obj: Dict[str, Any]) -> None:
        try:
            if self.events:
                self.events.write(json.dumps(obj) + "\n")
                self.events.flush()
        except Exception:
            pass

    def _sampler_stats(self, window_s: float) -> Stats:
        if self.sampler is not None and hasattr(self.sampler, "win"):
            try:
                return getattr(self.sampler, "win").stats(window_s)
            except Exception:
                pass
        return Stats(-100.0, -100.0, -100.0, -100.0, 0)

    def _sampler_backoff_until(self, key: str) -> float:
        st = self._sampler_fail.get(key, {})
        return float(st.get("until", 0.0))

    def _mark_sampler_fail(self, key: str) -> None:
        now = time.time()
        st = self._sampler_fail.get(key)
        if not st:
            st = {"fails": 0.0, "until": 0.0}
            self._sampler_fail[key] = st
        st["fails"] = float(st.get("fails", 0.0) + 1.0)
        fails = st["fails"]
        backoff = min(self.SAMPLER_BACKOFF_MAX_S, self.SAMPLER_BACKOFF_BASE_S * (2.0 ** max(0.0, fails - 1.0)))
        st["until"] = now + backoff

    def _switch_sampler(self, reason: str) -> None:
        try:
            if self.sampler:
                self.sampler.stop()
        except Exception:
            pass

        picked = None
        best_name = None

        n_samplers = max(1, len(self._samplers))
        now = time.time()

        for _ in range(n_samplers):
            self._sampler_idx = (self._sampler_idx + 1) % n_samplers
            cand = self._samplers[self._sampler_idx]
            key = cand.sampler_key()

            # v0.10.11: skip samplers in backoff
            if now < self._sampler_backoff_until(key):
                continue

            try:
                cand.start()
            except Exception:
                pass

            # v0.10.11: preflight must see actual sample flow (n>0)
            t0 = time.time()
            ok_flow = False
            while time.time() - t0 < self.SAMPLER_PREFLIGHT_S:
                try:
                    if cand.samples_recent(1.2):
                        ok_flow = True
                        break
                except Exception:
                    pass
                time.sleep(0.2)

            nm = cand.chosen_name()
            if ok_flow:
                picked = cand
                best_name = nm or key
                break

            # preflight failed -> stop and backoff this sampler
            try:
                cand.stop()
            except Exception:
                pass
            self._mark_sampler_fail(key)

        self.sampler = picked
        self._last_switch_ts = time.time()

        if self.sampler:
            logging.info("[Sampler] switched -> %s (%s)", self.sampler.chosen_name() or best_name or self.sampler.sampler_key(), reason)
            self._signal_state = f"SWITCH({reason})"
        else:
            logging.info("[Sampler] no viable sampler found (%s).", reason)
            self._signal_state = "NO SAMPLER"

    def _update_signal_health(self) -> None:
        now = time.time()

        if self.sampler is not None:
            deg = getattr(self.sampler, "is_degraded", None)
            if callable(deg):
                try:
                    if bool(deg()) and (now - self._last_switch_ts) >= self.SWITCH_COOLDOWN_S:
                        self._signal_state = "DEGRADED"
                        self._switch_sampler(reason="degraded")
                        return
                except Exception:
                    pass

        st = self._sampler_stats(1.5)
        if st.n > 0:
            self._last_sample_ts = now
            if (
                self._signal_state in ("INIT", "NO SAMPLES", "NO SAMPLER")
                or self._signal_state.startswith("SWITCH")
                or self._signal_state == "DEGRADED"
            ):
                self._signal_state = "LIVE"
            return

        if (now - self._last_sample_ts) > self.NO_SAMPLE_GRACE_S:
            self._signal_state = "NO SAMPLES"
            if (now - self._last_switch_ts) >= self.SWITCH_COOLDOWN_S:
                self._switch_sampler(reason="no-samples")

    def vol_set(self, new_scalar: float, why: str = "auto") -> None:
        new_scalar = clamp(new_scalar, self.MIN_VOL, 1.0)
        self.bk.set(new_scalar)
        self.current = new_scalar
        now = time.time()
        self._last_set_ts = now
        self._flash_duck_until = now + 2.2

        self._write_event({
            "ts": round(now, 3),
            "type": "AUTO_SET",
            "why": why,
            "vol": round(new_scalar, 3),
            "th_db": None if self._last_th is None else round(self._last_th, 2),
            "p85_db": round(self._last_p85, 2),
            "p95_db": round(self._last_p95, 2),
            "signal": self._signal_state,
            "sampler": self.sampler.chosen_name() if self.sampler else None,
        })

    def _on_user_change(self, ts: float, old: float, new: float):
        if ts - self._last_set_ts <= self.IGNORE_OWN_SET_S:
            return

        self.resting = new
        self.current = new

        if self._paused.is_set():
            return

        st = self._sampler_stats(self.SHORT_WIN_S)
        hour = time.localtime(ts).tm_hour
        db_at = st.p85

        self._write_event({
            "ts": round(ts, 3),
            "type": "USER_SET",
            "hour": hour,
            "dir": "DOWN" if new < old else "UP",
            "p85_db": round(db_at, 2),
            "old": round(old, 3),
            "new": round(new, 3),
            "signal": self._signal_state,
            "sampler": self.sampler.chosen_name() if self.sampler else None,
        })

        if (
            new < old
            and st.n >= 1
            and (ts - self._last_user_down_ts) > self.USER_DOWN_COOLDOWN_S
        ):
            self.learner.record_down(db_at, hour)
            self._last_user_down_ts = ts
            self._downs_total += 1
            self.learner.save()

    def start(self):
        self.poll.start()
        if self._thread:
            return
        self._thread = threading.Thread(target=self._run, name="AutoVolLoop", daemon=True)
        self._thread.start()

    def stop(self):
        self._stop.set()
        try:
            self.poll.stop()
        except Exception:
            pass
        try:
            if isinstance(self.bk, WinVolSTA):
                self.bk.close()
        except Exception:
            pass
        try:
            if self.sampler:
                self.sampler.stop()
        except Exception:
            pass
        try:
            self.learner.save()
            if self.events:
                self.events.close()
        except Exception:
            pass
        if self._thread:
            self._thread.join(timeout=1.5)

    def pause(self, do_pause: bool):
        if do_pause:
            self._paused.set()
            if abs(self.current - self.resting) > 1e-3:
                self.vol_set(self.resting, why="pause->restore")
        else:
            self._paused.clear()

    def reset_learning(self):
        try:
            self.learner.reset()
            self._downs_total = 0
        except Exception:
            pass

    def open_data_folder(self, data_dir: str):
        try:
            if _WIN:
                os.startfile(data_dir)  # type: ignore[attr-defined]
            elif sys.platform == "darwin":
                subprocess.Popen(["open", data_dir])
            else:
                subprocess.Popen(["xdg-open", data_dir])
        except Exception:
            pass

    def stats_text_short(self) -> str:
        mode = "P" if self._paused.is_set() else ("O" if self.observe_only or (time.time() - self._startup_ts < self.STARTUP_OBS_S) else "L")
        th_txt = f"{self._last_th:.0f}" if self._last_th is not None else "—"
        src = self.sampler.chosen_name() if self.sampler else "none"
        return f"{self._signal_state} {mode} vol:{self.current:.2f} p85:{self._last_p85:.0f} th:{th_txt} d:{self._downs_total} ({src})"

    def stats_text_long(self) -> str:
        tag = "vad" if _HAVE_WEBRTCVAD else "lite"
        th_txt = f"{self._last_th:.1f}dB" if (self._last_th is not None) else "—"
        mode_txt = "PAUSED" if self._paused.is_set() else ("OBSERVE" if self.observe_only or (time.time() - self._startup_ts < self.STARTUP_OBS_S) else "LIVE")
        duck_txt = " ↓" if (time.time() < self._flash_duck_until) else ""
        src = self.sampler.chosen_name() if self.sampler else "none"
        return f"{self._signal_state} | {mode_txt}{duck_txt} | downs:{self._downs_total} | p85:{self._last_p85:.1f} | p95:{self._last_p95:.1f} | th:{th_txt} | vol:{self.current:.2f} | sp:{self._speech:.2f}({tag}) | src:{src}"

    def _maybe_promote_sampler(self, now: float) -> None:
        # This method exists in some builds; keep it safe even if called.
        if self._paused.is_set() or self._observe.is_set():
            return

    def _run(self):
        last_save = time.time()

        while not self._stop.is_set():
            time.sleep(0.25)
            now = time.time()

            actual = self.bk.get()
            if abs(actual - self.current) > 0.05:
                self.resting = actual
                self.current = actual

            self._update_signal_health()
            if self._signal_state in ("NO SAMPLER", "NO SAMPLES"):
                continue

            if self._paused.is_set() or self.observe_only or (now - self._startup_ts < self.STARTUP_OBS_S):
                continue

            if not self.sampler:
                continue

            base = self._sampler_stats(self.BASELINE_WIN_S)
            cur = self._sampler_stats(self.SHORT_WIN_S)
            self._last_p85 = cur.p85
            self._last_p95 = cur.p95

            if cur.n < 1:
                continue

            hour = time.localtime().tm_hour
            th = self.learner.threshold(hour)
            if th is None:
                th = max(base.p70, -45.0) + 6.0
            self._last_th = th

            over85 = cur.p85 - th
            if (now - self._last_set_ts) >= self.SET_COOLDOWN_S and over85 > self.OVER_MARGIN_DB:
                step_db = clamp(over85 * 0.35, 0.25, self.ATTACK_DB_MAX)
                self.vol_set(self.current * db_to_lin(-step_db), why="steady_over85")
                continue

            over95 = cur.p95 - th
            if (now - self._last_set_ts) >= self.SET_COOLDOWN_S and over95 > (self.OVER_MARGIN_DB + 1.8):
                step_db = clamp(over95 * 0.55, 0.6, 2.8)
                self.vol_set(self.current * db_to_lin(-step_db), why="spike_over95")
                continue

            block = None
            try:
                block = self.sampler.get_last_block()
            except Exception:
                block = None

            if block is not None and getattr(block, "size", 0) > 0:
                sp_prob = self.vad.prob(block)
                self._speech = 0.6 * sp_prob + 0.4 * self._speech

                if (now - self._last_set_ts) >= self.SET_COOLDOWN_S:
                    target = self.resting
                    if self._speech >= 0.55:
                        target = min(1.0, self.resting * db_to_lin(self.SPEECH_UP_DB))
                    else:
                        target = max(self.MIN_VOL, self.resting * db_to_lin(self.NOSPEECH_DOWN_DB))

                    if abs(target - self.current) > 0.015:
                        step_up = db_to_lin(self.RELEASE_DB_MAX)
                        step_dn = db_to_lin(-self.RELEASE_DB_MAX)
                        if target > self.current:
                            new = min(target, self.current * step_up)
                        else:
                            new = max(target, self.current * step_dn)
                        self.vol_set(new, why="speech_gate")
            else:
                self.vad.prob(None)
                self._speech = 0.0

            if now - last_save >= 25.0:
                last_save = now
                self.learner.save()


# ------------------ tray ------------------

def make_icon(color_fg=(255, 255, 255, 255), color_bg=(0, 0, 0, 0)) -> Image.Image:
    W, H = 64, 64
    img = Image.new("RGBA", (W, H), color_bg)
    d = ImageDraw.Draw(img)
    d.rectangle([12, 24, 24, 40], fill=color_fg)
    d.polygon([(24, 24), (36, 16), (36, 48), (24, 40)], fill=color_fg)
    d.arc([38, 18, 58, 46], start=315, end=45, width=3, fill=color_fg)
    d.arc([42, 14, 62, 50], start=315, end=45, width=2, fill=color_fg)
    return img


def resolve_paths(model_filename: str, events_filename: str) -> Tuple[str, str, str]:
    data_dir = _default_data_dir()
    os.makedirs(data_dir, exist_ok=True)
    model_path = model_filename if os.path.isabs(model_filename) else os.path.join(data_dir, model_filename)
    events_path = events_filename if os.path.isabs(events_filename) else os.path.join(data_dir, events_filename)
    return data_dir, model_path, events_path


def run_tray():
    ap = argparse.ArgumentParser(add_help=True)
    ap.add_argument("--model", default="autovol_learn.json")
    ap.add_argument("--events", default="autovol_events.jsonl")
    ap.add_argument("--force-dryvol", action="store_true", help="don't touch system volume (debug)")
    ap.add_argument("--observe", action="store_true", help="start in observe-only mode (no volume changes)")
    ap.add_argument("--reset", action="store_true", help="reset learned downs before starting")
    ap.add_argument("--no-autoinstall", action="store_true", help="disable auto-install of missing deps")
    args = ap.parse_args()

    data_dir, model_path, events_path = resolve_paths(args.model, args.events)
    log_path = setup_logging(data_dir)
    logging.info("Log file: %s", log_path)

    ctl = AutoVolController(model_path=model_path, events_path=events_path, force_dryvol=args.force_dryvol)
    if args.reset:
        ctl.reset_learning()
        logging.info("Learning reset.")
    ctl.observe_only = bool(args.observe)
    ctl.start()

    icon_img = make_icon()
    icon = pystray.Icon("AutoVol", icon=icon_img, title="AutoVol")

    def update_title():
        icon.title = safe_tooltip("AutoVol — " + ctl.stats_text_short())

    def on_pause(_icon, _item):
        ctl.pause(not ctl._paused.is_set())
        update_title()

    def on_toggle_observe(_icon, _item):
        ctl.observe_only = not ctl.observe_only
        update_title()

    def on_reset(_icon, _item):
        ctl.reset_learning()
        update_title()

    def on_open(_icon, _item):
        ctl.open_data_folder(data_dir)

    def on_quit(icon_obj, _item):
        try:
            ctl.stop()
        finally:
            icon_obj.stop()

    menu = Menu(
        Item(lambda _item: safe_tooltip("Status: " + ctl.stats_text_long(), max_len=120), None, enabled=False),
        Item(lambda _item: "Observe only (no changes)", on_toggle_observe, checked=lambda _item: ctl.observe_only),
        Item(lambda _item: "Resume" if ctl._paused.is_set() else "Pause", on_pause),
        Item("Reset learning", on_reset),
        Item("Open data folder", on_open),
        Item("Quit", on_quit),
    )
    icon.menu = menu

    def refresher():
        while not ctl._stop.is_set():
            update_title()
            time.sleep(1.8)

    threading.Thread(target=refresher, name="TrayRefresh", daemon=True).start()

    logging.info("[AutoVol] tray up — check system tray.")
    update_title()
    icon.run()


if __name__ == "__main__":
    try:
        run_tray()
    except KeyboardInterrupt:
        pass
    except Exception as e:
        try:
            dd = _default_data_dir()
            os.makedirs(dd, exist_ok=True)
            with open(os.path.join(dd, "autovol_crash.txt"), "w", encoding="utf-8") as f:
                f.write(repr(e) + "\n\n")
                f.write(traceback.format_exc())
        except Exception:
            pass
        raise