"""Per-device diagnostic: probes each video index, reports real FOURCC/size/brightness."""

from __future__ import annotations

import sys

import time

from pathlib import Path

import cv2

import numpy as np

from rich.console import Console

console = Console()

LOG_DIR = Path(__file__).resolve().parents[1] / "logs"

def fourcc_to_str(val: float) -> str:

    v = int(val)

    if v <= 0:

        return "NONE"

    return "".join(chr((v >> (8 * i)) & 0xFF) for i in range(4))

def probe(idx: int, target_w: int = 1920, target_h: int = 1080, target_fps: int = 60) -> dict:

    result: dict = {"index": idx, "opened": False}

    cap = cv2.VideoCapture(idx, cv2.CAP_DSHOW)

    if not cap.isOpened():

        cap.release()

        return result

    result["opened"] = True

    result["default_size"] = (int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)), int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)))

    result["default_fourcc"] = fourcc_to_str(cap.get(cv2.CAP_PROP_FOURCC))

    result["default_fps"] = cap.get(cv2.CAP_PROP_FPS)

    mjpg = cv2.VideoWriter_fourcc(*"MJPG")

    cap.set(cv2.CAP_PROP_FOURCC, mjpg)

    cap.set(cv2.CAP_PROP_FRAME_WIDTH, target_w)

    cap.set(cv2.CAP_PROP_FRAME_HEIGHT, target_h)

    cap.set(cv2.CAP_PROP_FPS, target_fps)

    result["set_size"] = (int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)), int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)))

    result["set_fourcc"] = fourcc_to_str(cap.get(cv2.CAP_PROP_FOURCC))

    result["set_fps"] = cap.get(cv2.CAP_PROP_FPS)

    frame_count = 0

    first: np.ndarray | None = None

    mean_brightness: list[float] = []

    t_start = time.perf_counter()

    deadline = t_start + 3.0

    while time.perf_counter() < deadline:

        ok, frame = cap.read()

        if not ok or frame is None:

            continue

        if first is None:

            first = frame.copy()

        mean_brightness.append(float(frame.mean()))

        frame_count += 1

    elapsed = time.perf_counter() - t_start

    cap.release()

    result["frames"] = frame_count

    result["elapsed"] = elapsed

    result["fps"] = frame_count / elapsed if elapsed > 0 else 0.0

    if first is not None:

        result["frame_shape"] = first.shape

        result["brightness_mean"] = float(np.mean(mean_brightness)) if mean_brightness else 0.0

        result["brightness_std"] = float(np.std(mean_brightness)) if mean_brightness else 0.0

        out = LOG_DIR / f"diag_device_{idx}.png"

        cv2.imwrite(str(out), first)

        result["saved"] = str(out)

    return result

def main() -> int:

    LOG_DIR.mkdir(parents=True, exist_ok=True)

    console.print("[bold cyan]Per-device diagnostic (each opens/probes for 3s)[/bold cyan]\n")

    for idx in range(0, 4):

        r = probe(idx)

        console.print(f"[bold]Device {idx}[/bold]")

        if not r["opened"]:

            console.print("  [dim]not openable[/dim]\n")

            continue

        console.print(

            f"  default: {r['default_size'][0]}x{r['default_size'][1]} "

            f"fourcc={r['default_fourcc']} fps={r['default_fps']:.1f}"

        )

        console.print(

            f"  after set MJPG+1080p60: {r['set_size'][0]}x{r['set_size'][1]} "

            f"fourcc={r['set_fourcc']} fps={r['set_fps']:.1f}"

        )

        if "frame_shape" in r:

            console.print(

                f"  captured {r['frames']} frames in {r['elapsed']:.2f}s = [bold]{r['fps']:.2f} FPS[/bold]  "

                f"shape={r['frame_shape']}"

            )

            b = r["brightness_mean"]

            std = r["brightness_std"]

            tag = "[red]ALL BLACK (no signal or HDCP block)[/red]" if b < 3.0 else (

                  "[yellow]very dim[/yellow]" if b < 20.0 else "[green]normal[/green]")

            console.print(f"  brightness: mean={b:.2f} std={std:.2f}  {tag}")

            console.print(f"  saved first frame: {r['saved']}")

        else:

            console.print("  [red]opened but produced no frames[/red]")

        console.print("")

    return 0

if __name__ == "__main__":

    sys.exit(main())