"""Build timestamped visual events from face-engine frame results.

Observations only — no intent, misconduct, or hiring suitability claims.
Object detectors (YOLO COCO phone/laptop) are not wired; events come from
DeepFace/OpenCV face counts and quality signals already produced by VI.
"""

from __future__ import annotations

from app.schemas.video_intelligence import VisualEvent, VideoQualityObservation
from app.services.face.engine import FrameAnalysis


def build_visual_events(
    *,
    frame_results: list[FrameAnalysis],
    frame_indices: list[int],
    timestamps_ms: list[int | None],
) -> tuple[list[VisualEvent], list[VideoQualityObservation]]:
    events: list[VisualEvent] = []
    quality: list[VideoQualityObservation] = []
    n = min(len(frame_results), len(frame_indices), len(timestamps_ms))
    prev_count: int | None = None

    for i in range(n):
        fr = frame_results[i]
        idx = frame_indices[i]
        ts = timestamps_ms[i]
        count = int(fr.face_count or 0)

        if count >= 1:
            events.append(
                VisualEvent(
                    event_id=f"ev-person-{i}",
                    label="person_present",
                    kind="observation",
                    timestamp_ms=ts,
                    frame_index=idx,
                    confidence=None,
                    evidence=f"{count} face(s) detected in sampled frame",
                    interpretation=None,
                    source="deepface",
                )
            )
        else:
            events.append(
                VisualEvent(
                    event_id=f"ev-absent-{i}",
                    label="person_absent",
                    kind="observation",
                    timestamp_ms=ts,
                    frame_index=idx,
                    evidence="No face detected in sampled frame",
                    source="deepface",
                )
            )

        if count >= 2:
            events.append(
                VisualEvent(
                    event_id=f"ev-multi-{i}",
                    label="additional_person",
                    kind="observation",
                    timestamp_ms=ts,
                    frame_index=idx,
                    evidence=f"{count} faces in frame (additional person visible)",
                    interpretation=(
                        "Co-occurrence only — does not prove coaching, "
                        "impersonation, or misconduct"
                    ),
                    source="deepface",
                )
            )

        if prev_count is not None:
            if prev_count == 0 and count >= 1:
                events.append(
                    VisualEvent(
                        event_id=f"ev-enter-{i}",
                        label="person_appeared",
                        kind="observation",
                        timestamp_ms=ts,
                        frame_index=idx,
                        evidence="Face became visible after an absent sample",
                        source="heuristic",
                    )
                )
            elif prev_count >= 1 and count == 0:
                events.append(
                    VisualEvent(
                        event_id=f"ev-leave-{i}",
                        label="person_disappeared",
                        kind="observation",
                        timestamp_ms=ts,
                        frame_index=idx,
                        evidence="Face no longer visible after a present sample",
                        source="heuristic",
                    )
                )
            elif count > prev_count >= 1:
                events.append(
                    VisualEvent(
                        event_id=f"ev-join-{i}",
                        label="person_count_increased",
                        kind="observation",
                        timestamp_ms=ts,
                        frame_index=idx,
                        evidence=f"Face count {prev_count} → {count}",
                        interpretation="Not causal proof of someone entering the room",
                        source="heuristic",
                    )
                )
            elif 0 < count < prev_count:
                events.append(
                    VisualEvent(
                        event_id=f"ev-drop-{i}",
                        label="person_count_decreased",
                        kind="observation",
                        timestamp_ms=ts,
                        frame_index=idx,
                        evidence=f"Face count {prev_count} → {count}",
                        source="heuristic",
                    )
                )
        prev_count = count

        # Spoof only when a face was detected and anti-spoof explicitly failed.
        # No-face / detection errors are person_absent + quality — not spoof.
        if (
            fr.faces_detected
            and fr.is_real is False
            and fr.antispoof_score is not None
        ):
            events.append(
                VisualEvent(
                    event_id=f"ev-spoof-{i}",
                    label="spoof_suspected",
                    kind="biometric",
                    timestamp_ms=ts,
                    frame_index=idx,
                    confidence=fr.antispoof_score,
                    evidence="Anti-spoof model scored detected face as not live",
                    interpretation="Biometric signal only — not a fraud determination",
                    source="deepface",
                )
            )

        for w in fr.quality_warnings or []:
            quality.append(
                VideoQualityObservation(
                    name="frame_quality",
                    severity="warning",
                    timestamp_ms=ts,
                    detail=w,
                )
            )
            events.append(
                VisualEvent(
                    event_id=f"ev-qual-{i}-{len(quality)}",
                    label="quality_degraded",
                    kind="quality",
                    timestamp_ms=ts,
                    frame_index=idx,
                    evidence=w,
                    source="opencv_face",
                )
            )

        if fr.error:
            quality.append(
                VideoQualityObservation(
                    name="frame_analysis_error",
                    severity="error",
                    timestamp_ms=ts,
                    detail=fr.error,
                )
            )

    return events, quality
