#!/usr/bin/env python3
"""Validate the metadata and local files required for a locked local-3D shot."""

from __future__ import annotations

import json
import sys
from pathlib import Path


def within(root: Path, path: Path) -> bool:
    try:
        path.relative_to(root)
        return True
    except ValueError:
        return False


def resolve_required(lock_dir: Path, unit: Path, value: object, label: str, errors: list[str]) -> None:
    if not isinstance(value, str) or not value.strip():
        errors.append(f"{label} is required")
        return
    target = (lock_dir / value).resolve()
    if not within(unit, target):
        errors.append(f"{label} escapes the unit directory: {value}")
    elif not target.is_file():
        errors.append(f"{label} does not exist: {value}")


def main() -> int:
    if len(sys.argv) == 2 and sys.argv[1] in {"-h", "--help"}:
        print("usage: python3 validate_local_asset_lock.py /absolute/path/to/shot-unit")
        return 0
    if len(sys.argv) != 2:
        print("usage: validate_local_asset_lock.py <unit-directory>", file=sys.stderr)
        return 64

    unit = Path(sys.argv[1]).resolve()
    lock_path = unit / "01-authority" / "asset-lock.json"
    errors: list[str] = []
    if not lock_path.is_file():
        errors.append("missing 01-authority/asset-lock.json")
        lock: dict[str, object] = {}
    else:
        try:
            parsed = json.loads(lock_path.read_text(encoding="utf-8"))
            if not isinstance(parsed, dict):
                errors.append("asset-lock.json must be a JSON object")
                lock = {}
            else:
                lock = parsed
        except json.JSONDecodeError as exc:
            errors.append(f"invalid asset-lock.json: {exc.msg}")
            lock = {}

    route = lock.get("route")
    if route not in {"local-3d", "reference-i2v"}:
        errors.append("route must be local-3d or reference-i2v")

    assets = lock.get("assets")
    if not isinstance(assets, list) or not assets:
        errors.append("assets must be a non-empty list")
        assets = []
    for index, asset in enumerate(assets):
        if not isinstance(asset, dict):
            errors.append(f"assets[{index}] must be an object")
            continue
        prefix = f"assets[{index}]"
        for field in ("id", "kind", "allowed_state"):
            if not isinstance(asset.get(field), str) or not asset[field].strip():
                errors.append(f"{prefix}.{field} is required")
        resolve_required(lock_path.parent, unit, asset.get("reference"), f"{prefix}.reference", errors)
        if route == "local-3d":
            resolve_required(lock_path.parent, unit, asset.get("editable_asset"), f"{prefix}.editable_asset", errors)

    if route == "local-3d":
        resolve_required(lock_path.parent, unit, lock.get("sceneFileName"), "sceneFileName", errors)

    exclusions = lock.get("exclusions")
    if not isinstance(exclusions, list) or not any(isinstance(item, str) and item.strip() for item in exclusions):
        errors.append("exclusions must name at least one disallowed addition or change")
    resolve_required(lock_path.parent, unit, lock.get("camera_match_preview"), "camera_match_preview", errors)
    if lock.get("preview_review") != "approved":
        errors.append("preview_review must be approved before rendering")

    if errors:
        print("LOCAL 3D ASSET LOCK: BLOCKED")
        print("\n".join(f"- {error}" for error in errors))
        return 2
    print("LOCAL 3D ASSET LOCK: PASS")
    return 0


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