"""Align visual events with transcript segments by timestamp proximity.

Co-occurrence ≠ causation. Uncertain relationships stay separate evidence records.
"""

from __future__ import annotations

from app.config import get_settings
from app.schemas.transcription import TranscriptSegment
from app.schemas.video_intelligence import (
    EvidenceReference,
    VideoHighlight,
    VisualEvent,
)

# High-signal labels for recruiter highlights (not every sampled frame).
_PRIORITY_LABELS = frozenset(
    {
        "spoof_suspected",
        "additional_person",
        "person_appeared",
        "person_disappeared",
        "person_count_increased",
        "person_count_decreased",
    }
)
# Routine labels — include at most one coalesced sample each as fallback.
_ROUTINE_LABELS = frozenset({"person_absent", "quality_degraded", "person_present"})


def _segment_mid_ms(seg: TranscriptSegment) -> int:
    return int((int(seg.start_ms) + int(seg.end_ms)) // 2)


def nearest_segment(
    timestamp_ms: int | None,
    segments: list[TranscriptSegment],
    *,
    window_ms: int,
) -> TranscriptSegment | None:
    if timestamp_ms is None or not segments:
        return None
    best: TranscriptSegment | None = None
    best_dist = window_ms + 1
    for seg in segments:
        # Prefer overlap, else distance to midpoint
        if int(seg.start_ms) <= timestamp_ms <= int(seg.end_ms):
            return seg
        dist = abs(_segment_mid_ms(seg) - timestamp_ms)
        if dist < best_dist:
            best_dist = dist
            best = seg
    return best if best_dist <= window_ms else None


def _coalesce_notable(events: list[VisualEvent]) -> list[VisualEvent]:
    """Drop consecutive same-label events (keeps first of a run)."""
    out: list[VisualEvent] = []
    prev_label: str | None = None
    for ev in events:
        if ev.label == prev_label:
            continue
        out.append(ev)
        prev_label = ev.label
    return out


def select_notable_events(visual_events: list[VisualEvent]) -> list[VisualEvent]:
    """Pick highlight-worthy events without flooding on absent/dark frames."""
    priority = [e for e in visual_events if e.label in _PRIORITY_LABELS]
    priority = _coalesce_notable(priority)
    if priority:
        return priority[:12]

    # Fallback: one sample per routine label, then first/last event
    seen_routine: set[str] = set()
    fallback: list[VisualEvent] = []
    for ev in visual_events:
        if ev.label in _ROUTINE_LABELS and ev.label not in seen_routine:
            seen_routine.add(ev.label)
            fallback.append(ev)
        if len(fallback) >= 3:
            break
    if not fallback and visual_events:
        fallback = [visual_events[0]]
        if len(visual_events) > 1:
            fallback.append(visual_events[-1])
    return fallback[:12]


def build_highlights(
    *,
    visual_events: list[VisualEvent],
    segments: list[TranscriptSegment],
    interview_topics: list[str] | None = None,
    window_ms: int | None = None,
) -> list[VideoHighlight]:
    """Build recruiter highlights from co-occurring visual + transcript evidence."""
    settings = get_settings()
    window = int(window_ms if window_ms is not None else settings.video_align_window_ms)
    topics = interview_topics or []
    highlights: list[VideoHighlight] = []

    notable = select_notable_events(visual_events)

    for i, ev in enumerate(notable[:12]):
        seg = nearest_segment(ev.timestamp_ms, segments, window_ms=window)
        # Do not invent topic linkage from list index — that misleads recruiters.
        topic = topics[0] if len(topics) == 1 else None
        evidence: list[EvidenceReference] = [
            EvidenceReference(
                kind="visual_event",
                ref_id=ev.event_id,
                timestamp_ms=ev.timestamp_ms,
                note=ev.evidence,
            )
        ]
        if seg is not None:
            evidence.append(
                EvidenceReference(
                    kind="transcript_segment",
                    ref_id=f"seg-{seg.start_ms}-{seg.end_ms}",
                    timestamp_ms=seg.start_ms,
                    note=seg.text[:160],
                )
            )
            relationship: str = "co_occurring"
            uncertainty = (
                "Timestamps co-occur within alignment window; "
                "not proof of causal relationship"
            )
            excerpt = seg.text
            start_ms = min(x for x in [ev.timestamp_ms, seg.start_ms] if x is not None)
            end_ms = max(
                x
                for x in [ev.timestamp_ms, seg.end_ms, ev.end_timestamp_ms]
                if x is not None
            )
        else:
            relationship = "visual_only" if not segments else "uncertain"
            uncertainty = (
                "No transcript segment within alignment window"
                if segments
                else "Transcript segments unavailable"
            )
            excerpt = None
            start_ms = ev.timestamp_ms
            end_ms = ev.end_timestamp_ms or ev.timestamp_ms

        highlights.append(
            VideoHighlight(
                highlight_id=f"hl-{i}-{ev.event_id}",
                description=ev.evidence or ev.label,
                start_ms=start_ms,
                end_ms=end_ms,
                transcript_excerpt=excerpt,
                visual_observations=[ev.label],
                interview_topic=topic,
                evidence=evidence,
                uncertainty=uncertainty,
                relationship=relationship,  # type: ignore[arg-type]
            )
        )

    # Transcript-only highlights when we have segments but few visual notables
    if segments and len(highlights) < 3:
        for j, seg in enumerate(segments[:3]):
            if any(
                h.transcript_excerpt == seg.text and h.relationship == "co_occurring"
                for h in highlights
            ):
                continue
            highlights.append(
                VideoHighlight(
                    highlight_id=f"hl-tx-{j}",
                    description="Transcript moment (no linked visual event)",
                    start_ms=seg.start_ms,
                    end_ms=seg.end_ms,
                    transcript_excerpt=seg.text,
                    visual_observations=[],
                    interview_topic=topics[0] if len(topics) == 1 else None,
                    evidence=[
                        EvidenceReference(
                            kind="transcript_segment",
                            ref_id=f"seg-{seg.start_ms}-{seg.end_ms}",
                            timestamp_ms=seg.start_ms,
                            note=seg.text[:160],
                        )
                    ],
                    uncertainty="Visual linkage not established",
                    relationship="transcript_only",
                )
            )

    return highlights
