"""job.json 로드·검증 (PRD FR-1~3, ARCHITECTURE 3절)."""
import hashlib
import json
import math
import re
from pathlib import Path

PIPELINE_DIR = Path(__file__).resolve().parent.parent
STUDIO_DIR = PIPELINE_DIR.parent.parent
KNOWN_ROUTES = {"seedance_cli"}
REF_RE = re.compile(r"\{(cast|asset):([A-Za-z0-9_\-]+)\}")


class JobError(Exception):
    pass


def sha256(path):
    h = hashlib.sha256()
    with open(path, "rb") as f:
        for chunk in iter(lambda: f.read(1 << 20), b""):
            h.update(chunk)
    return h.hexdigest()


def load_preset(name):
    p = PIPELINE_DIR / "presets" / f"{name}.json"
    if not p.exists():
        raise JobError(f"프리셋 없음: {name}")
    return json.loads(p.read_text(encoding="utf-8"))


def load_elements(work):
    p = STUDIO_DIR / "works" / work / "elements.json"
    return json.loads(p.read_text(encoding="utf-8")) if p.exists() else {}


def _resolve_path(ep_dir, raw):
    p = Path(raw)
    return p if p.is_absolute() else (ep_dir / p)


def load_job(ep_dir):
    ep_dir = Path(ep_dir).resolve()
    jp = ep_dir / "job.json"
    if not jp.exists():
        raise JobError(f"job.json 없음: {jp}")
    job = json.loads(jp.read_text(encoding="utf-8"))
    job["_ep_dir"] = str(ep_dir)
    return job


def min_gen_sec(speech_sec, preset):
    return math.ceil(speech_sec + preset["pad_total"] - 1e-9)


def validate(job):
    """문제 목록(errors)과 경고(warnings), 채워진 컷 목록을 돌려준다. errors가 있으면 실행 금지."""
    errors, warnings = [], []
    ep_dir = Path(job["_ep_dir"])
    try:
        preset = load_preset(job.get("preset", "drama"))
    except JobError as e:
        return [str(e)], [], []
    elements = load_elements(job.get("work", ""))
    cast = job.get("cast", {})
    for key, ref in cast.items():
        if ref not in elements:
            errors.append(f"cast.{key}: works/{job.get('work')}/elements.json 에 '{ref}' 없음")

    assets = {}
    for key, spec in job.get("assets", {}).items():
        spec = {"path": spec} if isinstance(spec, str) else dict(spec)
        p = _resolve_path(ep_dir, spec["path"])
        if not p.exists():
            errors.append(f"asset.{key}: 파일 없음 {p}")
            continue
        digest = sha256(p)
        if spec.get("sha256") and spec["sha256"].lower() != digest:
            errors.append(f"asset.{key}: 해시 불일치 (기대 {spec['sha256'][:12]}…, 실제 {digest[:12]}…)")
        assets[key] = {"path": str(p), "sha256": digest}

    shots, seen = [], set()
    unregistered_reported = set()
    for s in job.get("shots", []):
        sid = s.get("id", "?")
        if sid in seen:
            errors.append(f"{sid}: 컷 ID 중복")
        seen.add(sid)
        route = s.get("route", preset["default_route"])
        if not isinstance(route, str):
            errors.append(f"{sid}: 생성 경로는 컷당 1개만 (받은 값 {route})")
            continue
        if route not in KNOWN_ROUTES:
            errors.append(f"{sid}: 알 수 없는 경로 '{route}' (가능: {sorted(KNOWN_ROUTES)})")
        prompt = s.get("prompt", "")
        for kind, key in REF_RE.findall(prompt):
            if kind == "cast":
                if key not in cast:
                    errors.append(f"{sid}: 프롬프트의 {{cast:{key}}} 가 cast에 없음")
                else:
                    ref = cast[key]
                    if ref in elements:
                        elem = elements[ref]
                        if route in KNOWN_ROUTES and route not in elem:
                            if (key, route) not in unregistered_reported:
                                unregistered_reported.add((key, route))
                                errors.append(f"{sid}: 인물 '{key}' 는 {route} Element 미등록 (E7 elements register 필요)")
            if kind == "asset" and key not in assets and key not in job.get("assets", {}):
                errors.append(f"{sid}: 프롬프트의 {{asset:{key}}} 가 assets에 없음")
        line = s.get("line")
        gen = s.get("gen_sec")
        if line:
            if line not in prompt:
                errors.append(f"{sid}: 대사(line)가 프롬프트에 그대로 들어 있지 않음")
            speech = s.get("speech_sec")
            if speech is None:
                speech = round(len(re.sub(r"\s", "", line)) / preset["syllables_per_sec"], 2)
                warnings.append(f"{sid}: speech_sec 없음 → 글자 수로 추정 {speech}초")
            need = min_gen_sec(speech, preset)
            if gen is None:
                gen = max(need, preset["duration_range"][0])  # 짧은 대사도 모델 최소 길이(4초) 이상
            elif gen < need:
                errors.append(
                    f"{sid}: 생성 길이 {gen}초 < 발화 {speech}초 + 여유 {preset['pad_total']}초 → 최소 {need}초"
                )
        elif gen is None:
            gen = preset["default_silent_sec"]
        lo, hi = preset["duration_range"]
        if gen is not None and not (lo <= gen <= hi):
            errors.append(f"{sid}: 생성 길이 {gen}초가 허용 범위 {lo}~{hi}초 밖")
        shots.append({**s, "route": route, "gen_sec": gen,
                      "model": s.get("model", preset["model"]),
                      "resolution": s.get("resolution", preset["resolution"]),
                      "ratio": s.get("ratio", preset["ratio"])})
    if not shots:
        errors.append("shots 비어 있음")
    job["_preset"], job["_assets"], job["_elements"] = preset, assets, elements
    return errors, warnings, shots
