"""Fail-fast validation for server-local Contextra Runtime configuration."""

from __future__ import annotations

import os
import sys
from pathlib import Path

import yaml


PATH_ENV = {
    "system": ("SYSTEM_CONFIG_PATH", "/etc/contextra/system_config.yaml"),
    "streams": ("STREAMS_CONFIG_PATH", "/etc/contextra/streams.yaml"),
    "camera": ("CAMERA_PTZ_CONFIG_PATH", "/etc/contextra/camera_ptz_config.yaml"),
}


def _load_mapping(path: str, label: str) -> dict:
    candidate = Path(path)
    if not candidate.is_absolute():
        raise ValueError(f"{label} config path must be absolute")
    if not candidate.is_file():
        raise ValueError(f"{label} config file is missing")
    try:
        data = yaml.safe_load(candidate.read_text(encoding="utf-8")) or {}
    except yaml.YAMLError as exc:
        raise ValueError(f"{label} config is not valid YAML") from exc
    if not isinstance(data, dict):
        raise ValueError(f"{label} config root must be a mapping")
    return data


def validate_runtime_config(environ=None) -> dict:
    env = os.environ if environ is None else environ
    loaded = {}
    for label, (variable, default) in PATH_ENV.items():
        path = str(env.get(variable, default) or "").strip()
        loaded[label] = _load_mapping(path, label)

    streams = loaded["streams"].get("streams")
    if not isinstance(streams, list):
        raise ValueError("streams config must contain a streams list")

    cameras = loaded["camera"].get("cameras")
    if not isinstance(cameras, dict):
        raise ValueError("camera config must contain a cameras mapping")

    active_learning = loaded["system"].get("active_learning")
    if not isinstance(active_learning, dict):
        raise ValueError("system config must contain an active_learning mapping")
    if not isinstance(active_learning.get("enabled"), bool):
        raise ValueError("active_learning.enabled must be boolean")

    state_path = Path(
        str(
            env.get(
                "STREAMS_RUNTIME_PATH",
                "/var/lib/contextra/runtime/streams_runtime.yaml",
            )
            or ""
        )
    )
    if not state_path.is_absolute():
        raise ValueError("STREAMS_RUNTIME_PATH must be absolute")
    if not state_path.parent.is_dir():
        raise ValueError("Runtime state directory is missing")
    if not os.access(state_path.parent, os.W_OK):
        raise ValueError("Runtime state directory is not writable")

    return {
        "stream_count": len(streams),
        "active_learning": active_learning["enabled"],
        "runtime_state_path": str(state_path),
    }


def main() -> int:
    try:
        summary = validate_runtime_config()
    except ValueError as exc:
        print(f"[CONFIG][ERROR] {exc}", file=sys.stderr, flush=True)
        return 2
    print(
        "[CONFIG] validation PASS "
        f"streams={summary['stream_count']} "
        f"active_learning={summary['active_learning']}",
        flush=True,
    )
    return 0


if __name__ == "__main__":
    raise SystemExit(main())