#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""G4.4 canary — STRICT atmosphere_reference no-layout-import detection (Task 4.3).

Detects 7 furniture / wall / layout tokens (`furniture` / `wall position` /
`room layout` / `same chair` / `same table` / `same wall` / `same window`)
inside `t2i_prompt` of shots with at least one
`previous_shot_refs[i].ref_usage == "atmosphere_reference"` (Override O-11
multi-ref filter — atmosphere co-presence with `exact_background` still
triggers; false-positive baseline >0 → P1 follow-up).

Token list imported from
`render_prompt_card._CONTINUITY_FURNITURE_LAYOUT_TOKENS` (Trap #8 —
module-level constant single source).

Override O-17 — regex brittleness: this regex/substring-based detector is a
1차 detector only. If baseline >0 (e.g. natural usage like "the wall position
is preserved" — a rationale, not an import), escalate to LLM-validator
(gpt-5.4-mini judge) as P1 follow-up. `feedback_no_regex_postprocessing.md`
carry.

Scope: shots where `any(ref.ref_usage == "atmosphere_reference" for ref in
previous_shot_refs)` (R2-B4 carry / Override O-11).

Exit criteria (analyzer, OUT-OF-BAND):
  candidate.metrics.atmosphere_layout_import_count == 0  (STRICT, Override O-1)

Usage (config mode):
    python scripts/canary/g4_4_atmosphere_no_layout_import.py \\
        --config canary_config.json \\
        --cp-root data/projects/<pid>/checkpoints/scene_detail \\
        --prompt-version 19.<timestamp> \\
        --role candidate \\
        --output results/atmosphere_candidate.json
"""
from __future__ import annotations

import argparse
import sys
from datetime import datetime
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parent))
from _g4_4_common import (  # noqa: E402
    _load_scenes_or_fail,
    _validate_scene_preflight,
    build_pinning_scene_set,
    emit_output,
    load_cp_manifest,
    load_pinning_from_args,
    render_prompt_card_imports,
    resolve_cp_root,
    validate_pinning,
)

_CONSTS = render_prompt_card_imports()
_CONTINUITY_FURNITURE_LAYOUT_TOKENS = _CONSTS[
    "_CONTINUITY_FURNITURE_LAYOUT_TOKENS"
]


def iso8601_now() -> str:
    return datetime.utcnow().isoformat() + "Z"


def find_layout_imports(prompt: str) -> list[str]:
    """7 furniture/layout token 중 prompt 안 등장 list 반환.

    Case-insensitive literal substring match — full-text scan
    (CLAUDE.md no-truncation carry). Override O-17: 1차 detector only —
    LLM-validator escalation P1 follow-up.
    """
    # Override O-17 carry: regex is 1차 detector. If baseline ≠ 0, escalate to LLM-validator (gpt-5.4-mini judge) per P1 follow-up.
    found: list[str] = []
    prompt_lower = prompt.lower()
    for token in _CONTINUITY_FURNITURE_LAYOUT_TOKENS:
        if token.lower() in prompt_lower:
            found.append(token)
    return found


def main() -> int:
    parser = argparse.ArgumentParser(
        description=(
            "G4.4 canary: atmosphere_reference no-layout-import detection "
            "(Override O-11 multi-ref filter — Override O-17 regex 1차 only)."
        )
    )
    parser.add_argument("--config", type=str, default=None)
    parser.add_argument("--pid", type=str, default=None)
    parser.add_argument("--cp-root", type=str, default=None)
    parser.add_argument("--prompt-version", type=str, required=True)
    parser.add_argument(
        "--role",
        type=str,
        default="candidate",
        choices=["baseline", "candidate"],
    )
    parser.add_argument("--scene-index-list", type=str, default=None)
    parser.add_argument("--shot-index-list-per-scene", type=str, default=None)
    parser.add_argument("--model-routing", type=str, default=None)
    parser.add_argument(
        "--prompt-source-mode",
        type=str,
        default=None,
        choices=[None, "file", "db"],
    )
    parser.add_argument("--card-commit-hash", type=str, default=None)
    parser.add_argument(
        "--continuity-card-snapshot-hash", type=str, default=None
    )
    parser.add_argument("--output", type=str, required=True)
    args = parser.parse_args()

    pinning = load_pinning_from_args(args)
    validate_pinning(pinning)
    cp_root = resolve_cp_root(args)
    cp = load_cp_manifest(cp_root)

    measurement_failures: list[str] = []
    scenes = _load_scenes_or_fail(cp, measurement_failures)
    if scenes is None:
        out = _empty_output(args, pinning, measurement_failures)
        emit_output(out, args)
        return 1

    pinning_set = build_pinning_scene_set(pinning)
    seen_in_cp: set[tuple[int, int]] = set()

    total_atmosphere_shots = 0
    atmosphere_multi_ref_shots = 0
    atmosphere_layout_import_count = 0
    atmosphere_layout_import_per_shot: dict[str, dict] = {}
    scene_set_out: list[dict] = []

    for scene in scenes:
        if not isinstance(scene, dict):
            measurement_failures.append("scene entry is not dict")
            continue
        si = scene.get("scene_index")
        shi = scene.get("_shot_index")
        if si is None or shi is None:
            continue
        si_int = int(si)
        shi_int = int(shi)
        if (si_int, shi_int) not in pinning_set:
            continue
        seen_in_cp.add((si_int, shi_int))

        variations = _validate_scene_preflight(
            scene, si_int, shi_int, measurement_failures
        )
        if variations is None:
            continue

        rpc = scene["render_prompt_card"]
        ce = rpc["continuity_elements_used"]
        # Trap #1 — explicit key existence + type validation.
        if "previous_shot_refs" not in ce:
            measurement_failures.append(
                f"s{si_int}_sh{shi_int}: continuity_elements_used."
                f"previous_shot_refs key missing"
            )
            continue
        refs = ce["previous_shot_refs"]
        if not isinstance(refs, list):
            measurement_failures.append(
                f"s{si_int}_sh{shi_int}: continuity_elements_used."
                f"previous_shot_refs not list"
            )
            continue

        # Override O-11 — multi-ref filter — any atmosphere ref in shot.
        has_atmosphere = any(
            isinstance(r, dict)
            and r.get("ref_usage") == "atmosphere_reference"
            for r in refs
        )
        has_exact_bg_co_presence = any(
            isinstance(r, dict) and r.get("ref_usage") == "exact_background"
            for r in refs
        )
        ref_usage_signature = sorted({
            r.get("ref_usage")
            for r in refs
            if isinstance(r, dict) and isinstance(r.get("ref_usage"), str)
        })

        scene_set_out.append({
            "scene_index": si_int,
            "shot_index": shi_int,
            "has_atmosphere_reference": has_atmosphere,
            "exact_bg_co_present": has_exact_bg_co_presence,
            "ref_usage_signature": ref_usage_signature,
        })

        if not has_atmosphere:
            continue  # scope 외 — atmosphere_reference 부재 (Override O-11)

        total_atmosphere_shots += 1
        if has_exact_bg_co_presence:
            # multi-ref shot — false-positive 후보 추적 (Override O-11
            # P1 follow-up).
            atmosphere_multi_ref_shots += 1

        shot_count = 0
        shot_layout_tokens: list[str] = []
        for vi, var in enumerate(variations):
            if not isinstance(var, dict):
                measurement_failures.append(
                    f"s{si_int}_sh{shi_int}_v{vi}: variation not a dict"
                )
                continue
            prompt = var.get("t2i_prompt")
            if not isinstance(prompt, str) or not prompt.strip():
                measurement_failures.append(
                    f"s{si_int}_sh{shi_int}_v{vi}: t2i_prompt missing, "
                    f"empty, or not str"
                )
                continue
            layouts = find_layout_imports(prompt)
            shot_count += len(layouts)
            shot_layout_tokens.extend(layouts)

        atmosphere_layout_import_count += shot_count
        atmosphere_layout_import_per_shot[f"{si_int}_{shi_int}"] = {
            "count": shot_count,
            "tokens": shot_layout_tokens,
            "exact_bg_co_present": has_exact_bg_co_presence,
        }

    # Trap #4 — pinned-tuple post-loop validation.
    for (si, shi) in pinning_set:
        if (si, shi) not in seen_in_cp:
            measurement_failures.append(
                f"pinning (s{si}_sh{shi}): not present in CP data.scenes"
            )

    out = {
        "timestamp": iso8601_now(),
        "prompt_version": args.prompt_version,
        "role": args.role,
        "pinning": pinning,
        "scene_set": scene_set_out,
        "metrics": {
            "total_atmosphere_reference_shots": total_atmosphere_shots,
            "atmosphere_multi_ref_shots": atmosphere_multi_ref_shots,
            "atmosphere_layout_import_count": atmosphere_layout_import_count,
            "atmosphere_layout_import_per_shot": (
                atmosphere_layout_import_per_shot
            ),
            "furniture_layout_tokens_used": list(
                _CONTINUITY_FURNITURE_LAYOUT_TOKENS
            ),
        },
        "measurement_failures": measurement_failures,
        "exit_criteria_threshold": 0,
        "exit_criteria_pass": (
            not measurement_failures and atmosphere_layout_import_count == 0
        ),
        "measurement_scripts": {
            "atmosphere_no_layout_import": (
                "scripts/canary/g4_4_atmosphere_no_layout_import.py "
                "(atmosphere_reference shots only — Override O-11 multi-ref "
                "filter, Override O-17 regex 1차 only)"
            )
        },
    }

    emit_output(out, args)

    print(
        f"[g4_4_atmosphere_no_layout_import] role={args.role} "
        f"prompt_version={args.prompt_version}\n"
        f"  total_atmosphere_reference_shots={total_atmosphere_shots}\n"
        f"  atmosphere_multi_ref_shots={atmosphere_multi_ref_shots} "
        f"(P1 follow-up if >0)\n"
        f"  atmosphere_layout_import_count="
        f"{atmosphere_layout_import_count}\n"
        f"  measurement_failures: {len(measurement_failures)}\n"
        f"Exit criteria (STRICT): "
        f"candidate.metrics.atmosphere_layout_import_count == 0",
        file=sys.stderr,
    )

    if measurement_failures:
        return 1
    if args.role == "candidate" and atmosphere_layout_import_count > 0:
        return 1
    return 0


def _empty_output(
    args: argparse.Namespace,
    pinning: dict,
    measurement_failures: list,
) -> dict:
    return {
        "timestamp": iso8601_now(),
        "prompt_version": args.prompt_version,
        "role": args.role,
        "pinning": pinning,
        "scene_set": [],
        "metrics": {
            "total_atmosphere_reference_shots": 0,
            "atmosphere_multi_ref_shots": 0,
            "atmosphere_layout_import_count": 0,
            "atmosphere_layout_import_per_shot": {},
            "furniture_layout_tokens_used": list(
                _CONTINUITY_FURNITURE_LAYOUT_TOKENS
            ),
        },
        "measurement_failures": measurement_failures,
        "exit_criteria_threshold": 0,
        "exit_criteria_pass": False,
        "measurement_scripts": {
            "atmosphere_no_layout_import": (
                "scripts/canary/g4_4_atmosphere_no_layout_import.py "
                "(atmosphere_reference shots only — Override O-11)"
            )
        },
    }


if __name__ == "__main__":
    sys.exit(main())