"""Video intelligence — real frame extract + FakeEngine + evidence extras."""

from __future__ import annotations

import base64
import io
from pathlib import Path
from unittest.mock import patch

import cv2
import numpy as np
import pytest
from fastapi.testclient import TestClient
from PIL import Image

from app.config import get_settings
from app.main import app
from app.schemas.transcription import TranscriptSegment
from app.schemas.video_intelligence import VisualEvent
from app.services.face.engine import (
    FaceAnalysisEngine,
    FaceEngineResult,
    FrameAnalysis,
    set_face_engine_override,
)
from app.services.face.video_frames import (
    compute_sample_indices,
    extract_frames_from_bytes,
    frame_timestamp_ms,
)
from app.services.video.align import (
    build_highlights,
    nearest_segment,
    select_notable_events,
)
from app.services.video.audio_demux import DemuxedAudio
from app.services.video.events import build_visual_events
from app.services.voice.wav_util import build_silent_wav

client = TestClient(app)
HEADERS = {"X-Internal-Token": get_settings().internal_api_token}


def _png_b64(color: tuple[int, int, int] = (180, 140, 120), size: int = 160) -> str:
    img = Image.new("RGB", (size, size), color)
    buf = io.BytesIO()
    img.save(buf, format="PNG")
    return base64.b64encode(buf.getvalue()).decode("ascii")


def _make_video_b64(*, frames: int = 8, size: int = 160, fps: float = 4.0) -> str:
    """Create a tiny MJPG AVI in-memory via OpenCV."""
    path = Path("/tmp/tj_test_video.avi")
    fourcc = cv2.VideoWriter_fourcc(*"MJPG")
    writer = cv2.VideoWriter(str(path), fourcc, fps, (size, size))
    assert writer.isOpened()
    for i in range(frames):
        bgr = np.full((size, size, 3), (40 + i * 5, 120, 180), dtype=np.uint8)
        writer.write(bgr)
    writer.release()
    data = path.read_bytes()
    path.unlink(missing_ok=True)
    return base64.b64encode(data).decode("ascii")


class FakeEngine(FaceAnalysisEngine):
    name = "fake"

    def __init__(
        self,
        *,
        identity_matched: bool | None = True,
        liveness_passed: bool = True,
        multi_face: bool = False,
    ) -> None:
        self.identity_matched = identity_matched
        self.liveness_passed = liveness_passed
        self.multi_face = multi_face

    def analyze(self, *, registered_bgr, live_frames_bgr) -> FaceEngineResult:
        identity = None if registered_bgr is None else self.identity_matched
        n = len(live_frames_bgr)
        frame_results: list[FrameAnalysis] = []
        for i in range(n):
            # Alternate absence on first frame when multi_face path not used
            if self.multi_face:
                count = 2 if i % 2 == 0 else 1
            else:
                count = 0 if i == 0 else 1
            frame_results.append(
                FrameAnalysis(
                    face_count=count,
                    is_real=self.liveness_passed if count > 0 else None,
                    antispoof_score=0.91 if count > 0 else None,
                    faces_detected=count > 0,
                    quality_warnings=["Low brightness"] if i == n - 1 else [],
                )
            )
        multi = sum(1 for fr in frame_results if (fr.face_count or 0) >= 2)
        scored = sum(1 for fr in frame_results if fr.faces_detected and fr.antispoof_score is not None)
        return FaceEngineResult(
            identity_matched=identity,
            distance=0.2 if identity is not None else None,
            threshold=0.68 if identity is not None else None,
            match_score=0.9 if identity else None,
            liveness_passed=self.liveness_passed,
            liveness_score=0.91,
            liveness_frame_pass_ratio=1.0 if self.liveness_passed else 0.0,
            model="ArcFace",
            detector="opencv",
            face_count=2 if self.multi_face else 1,
            frame_results=frame_results,
            warnings=[],
            error_code=None
            if (self.liveness_passed and (identity is not False))
            else ("liveness_failed" if not self.liveness_passed else "identity_mismatch"),
            provider="fake",
            faces_detected_ratio=sum(1 for fr in frame_results if fr.faces_detected)
            / max(1, n),
            multi_face_frames=multi,
            scored_frame_count=scored,
        )


@pytest.fixture(autouse=True)
def _engine():
    set_face_engine_override(FakeEngine())
    yield
    set_face_engine_override(None)


def test_frame_timestamp_ms() -> None:
    assert frame_timestamp_ms(0, 25.0) == 0
    assert frame_timestamp_ms(25, 25.0) == 1000
    assert frame_timestamp_ms(10, None) is None


def test_compute_sample_indices_spans_full_duration() -> None:
    """max_frames must spread across the clip, not take a prefix only."""
    # 36.5s @ 29.97fps ≈ 1094 frames; sample_fps=1 → want ~37, capped at 10
    frame_count = 1094
    indices = compute_sample_indices(
        frame_count=frame_count,
        source_fps=29.97,
        sample_fps=1.0,
        max_frames=10,
    )
    assert len(indices) == 10
    assert indices[0] == 0
    assert indices[-1] == frame_count - 1
    # Mid samples should leave the first ~10s (≈300 frames)
    assert indices[5] > 300


def test_extract_frames_distributed_across_video() -> None:
    """40 frames @ 10fps (4s); max_frames=5 @ sample_fps=10 → 5 evenly spaced."""
    path = Path("/tmp/tj_test_span_video.avi")
    fourcc = cv2.VideoWriter_fourcc(*"MJPG")
    writer = cv2.VideoWriter(str(path), fourcc, 10.0, (80, 80))
    assert writer.isOpened()
    for i in range(40):
        writer.write(np.full((80, 80, 3), (i * 3, 80, 120), dtype=np.uint8))
    writer.release()
    data = path.read_bytes()
    path.unlink(missing_ok=True)

    extracted = extract_frames_from_bytes(data, sample_fps=10.0, max_frames=5)
    try:
        assert len(extracted.frames_bgr) == 5
        assert extracted.frame_indices[0] == 0
        assert extracted.frame_indices[-1] >= 35  # near end of 40-frame clip
        assert extracted.timestamps_ms[-1] is not None
        assert extracted.timestamps_ms[-1] >= 3500
    finally:
        extracted.cleanup()


def test_build_visual_events_multi_and_transitions() -> None:
    frames = [
        FrameAnalysis(
            face_count=0, is_real=None, antispoof_score=None, faces_detected=False
        ),
        FrameAnalysis(face_count=2, is_real=True, antispoof_score=0.9, faces_detected=True),
        FrameAnalysis(
            face_count=1,
            is_real=False,
            antispoof_score=0.2,
            faces_detected=True,
            quality_warnings=["Low brightness"],
        ),
    ]
    events, quality = build_visual_events(
        frame_results=frames,
        frame_indices=[0, 4, 8],
        timestamps_ms=[0, 1000, 2000],
    )
    labels = {e.label for e in events}
    assert "person_absent" in labels
    assert "additional_person" in labels
    assert "person_appeared" in labels
    assert "spoof_suspected" in labels
    assert "quality_degraded" in labels
    assert any(e.timestamp_ms == 1000 for e in events if e.label == "additional_person")
    assert quality
    assert any(e.kind == "biometric" for e in events)
    # No-face frame must not emit spoof_suspected
    absent_spoofs = [
        e
        for e in events
        if e.label == "spoof_suspected" and e.frame_index == 0
    ]
    assert absent_spoofs == []


def test_no_face_is_not_spoof_event() -> None:
    frames = [
        FrameAnalysis(
            face_count=0,
            is_real=False,  # legacy/incorrect; still must not emit spoof
            antispoof_score=0.0,
            faces_detected=False,
        ),
        FrameAnalysis(
            face_count=0,
            is_real=None,
            antispoof_score=None,
            faces_detected=False,
        ),
    ]
    events, _ = build_visual_events(
        frame_results=frames,
        frame_indices=[0, 30],
        timestamps_ms=[0, 1000],
    )
    assert all(e.label != "spoof_suspected" for e in events)
    assert any(e.label == "person_absent" for e in events)


def test_align_nearest_and_highlights() -> None:
    segs = [
        TranscriptSegment(start_ms=0, end_ms=1500, text="Hello"),
        TranscriptSegment(start_ms=4000, end_ms=6000, text="I led the project"),
    ]
    assert nearest_segment(1200, segs, window_ms=5000) is segs[0]
    assert nearest_segment(5000, segs, window_ms=5000) is segs[1]
    assert nearest_segment(50_000, segs, window_ms=1000) is None

    events = [
        VisualEvent(
            event_id="ev-1",
            label="additional_person",
            timestamp_ms=4500,
            frame_index=10,
            evidence="2 faces",
        )
    ]
    hls = build_highlights(visual_events=events, segments=segs, interview_topics=["Conflict"])
    assert hls
    assert hls[0].relationship == "co_occurring"
    assert hls[0].transcript_excerpt == "I led the project"
    assert hls[0].interview_topic == "Conflict"  # single topic = shared context ok
    assert "causal" in (hls[0].uncertainty or "").lower() or "not proof" in (
        hls[0].uncertainty or ""
    ).lower() or "co-occur" in (hls[0].uncertainty or "").lower()


def test_highlights_skip_routine_absent_flood_and_topic_cycling() -> None:
    events = [
        VisualEvent(
            event_id=f"ev-abs-{i}",
            label="person_absent",
            timestamp_ms=i * 1000,
            frame_index=i,
            evidence="No face",
        )
        for i in range(8)
    ] + [
        VisualEvent(
            event_id="ev-spoof",
            label="spoof_suspected",
            timestamp_ms=9000,
            frame_index=9,
            evidence="not live",
        ),
        VisualEvent(
            event_id="ev-qual",
            label="quality_degraded",
            timestamp_ms=9000,
            frame_index=9,
            evidence="too dark",
        ),
    ]
    notable = select_notable_events(events)
    assert all(e.label != "person_absent" for e in notable)
    assert any(e.label == "spoof_suspected" for e in notable)

    hls = build_highlights(
        visual_events=events,
        segments=[],
        interview_topics=["Q1", "Q2", "Q3"],
    )
    # Multiple topics must not be cycled onto unrelated visual moments
    assert all(h.interview_topic is None for h in hls)
    assert len(hls) <= 3
    assert hls[0].visual_observations == ["spoof_suspected"]


def test_video_analysis_with_identity() -> None:
    video = _make_video_b64()
    res = client.post(
        "/api/v1/video-intelligence",
        headers=HEADERS,
        json={
            "interview_id": "vid-1",
            "video_base64": video,
            "sample_fps": 2.0,
            "registered_photo_base64": _png_b64(),
            "consent_given": True,
            "consent_id": "cv-1",
        },
    )
    assert res.status_code == 200
    body = res.json()
    assert body["stub"] is False
    assert body["frames_analyzed"] >= 2
    assert body["liveness"]["passed"] is True
    assert body["identity"]["matched"] is True
    assert body["identity_matched"] is True
    assert body["liveness_passed"] is True
    assert body["verified"] is True
    assert body["engagement_score"] is not None
    assert any(s["name"] == "face_presence" for s in body["signals"])
    assert body["consent_recorded"] is True
    # Additive timestamp fields on frames
    assert body["frame_results"]
    assert "timestamp_ms" in body["frame_results"][0]
    assert "frame_index" in body["frame_results"][0]
    assert body["visual_events"]
    assert body["analysis_completeness"] == "biometric_only"


def test_video_liveness_only_without_registered_photo() -> None:
    res = client.post(
        "/api/v1/video-intelligence",
        headers=HEADERS,
        json={
            "interview_id": "vid-2",
            "video_base64": _make_video_b64(),
            "consent_given": True,
        },
    )
    body = res.json()
    assert body["identity_matched"] is None
    assert body["identity"]["matched"] is None
    assert body["identity"]["error_code"] == "identity_not_requested"
    assert body["liveness_passed"] is True
    # verified requires an identity match — liveness-only must not set verified true
    assert body["verified"] is False
    assert body["status"] == "succeeded"
    assert body["error_code"] is None


def test_video_consent_required() -> None:
    res = client.post(
        "/api/v1/video-intelligence",
        headers=HEADERS,
        json={
            "interview_id": "vid-3",
            "video_base64": _make_video_b64(frames=4),
            "consent_given": False,
        },
    )
    body = res.json()
    assert body["verified"] is False
    assert body["error_code"] == "consent_required"


def test_video_identity_mismatch_keeps_liveness_separate() -> None:
    set_face_engine_override(FakeEngine(identity_matched=False, liveness_passed=True))
    res = client.post(
        "/api/v1/video-intelligence",
        headers=HEADERS,
        json={
            "interview_id": "vid-4",
            "video_base64": _make_video_b64(),
            "registered_photo_base64": _png_b64(),
            "consent_given": True,
        },
    )
    body = res.json()
    assert body["verified"] is False
    assert body["liveness_passed"] is True
    assert body["identity_matched"] is False
    assert body["error_code"] == "identity_mismatch"


def test_invalid_video_payload() -> None:
    res = client.post(
        "/api/v1/video-intelligence",
        headers=HEADERS,
        json={
            "interview_id": "vid-bad",
            "video_base64": "AAAA",
            "consent_given": True,
        },
    )
    body = res.json()
    assert body["verified"] is False
    assert body["error_code"] in {"invalid_video", "unsupported_video", "no_frames"}


def test_multi_face_visual_events() -> None:
    set_face_engine_override(FakeEngine(multi_face=True))
    res = client.post(
        "/api/v1/video-intelligence",
        headers=HEADERS,
        json={
            "interview_id": "vid-multi",
            "video_base64": _make_video_b64(frames=6),
            "consent_given": True,
        },
    )
    body = res.json()
    assert body["multi_face_frames"] >= 1
    assert any(e["label"] == "additional_person" for e in body["visual_events"])


def test_include_transcript_no_audio_is_partial() -> None:
    """Silent AVI → demux fails gracefully; biometric path still returns."""
    res = client.post(
        "/api/v1/video-intelligence",
        headers=HEADERS,
        json={
            "interview_id": "vid-silent",
            "video_base64": _make_video_b64(frames=4),
            "consent_given": True,
            "include_transcript": True,
            "options": {"transcript_provider": "stub"},
        },
    )
    body = res.json()
    assert res.status_code == 200
    assert body["status"] == "succeeded"
    assert body["verified"] is False
    assert body["identity"]["error_code"] == "identity_not_requested"
    assert body["visual_events"]
    assert body["transcript"] is not None
    assert body["transcript"]["error_code"] in {
        "no_audio_track",
        "audio_demux_failed",
        "ffmpeg_missing",
    }
    assert body["transcript"]["text"] is None
    assert body["analysis_completeness"] == "partial"


def test_include_report_only_without_transcript() -> None:
    res = client.post(
        "/api/v1/video-intelligence",
        headers=HEADERS,
        json={
            "interview_id": "vid-report-only",
            "video_base64": _make_video_b64(frames=4),
            "consent_given": True,
            "include_report": True,
            "include_transcript": False,
        },
    )
    body = res.json()
    assert res.status_code == 200
    assert body["transcript"] is None
    assert body["report"] is not None
    assert body["report"]["summary"]
    assert body["report"]["transcript_excerpts"] == []
    assert body["report"]["verification_summary"]
    assert "not_requested" in (body["report"]["verification_summary"] or "")
    assert any(
        "Transcript not requested" in lim for lim in body["report"]["limitations"]
    )
    # Do not invent transcript follow-ups when no speech was available
    assert not any(
        "transcript accuracy" in str(item).lower()
        for item in body["report"]["follow_up_items"]
    )


def test_include_transcript_and_report_with_mocked_demux() -> None:
    wav = build_silent_wav(duration_ms=800, sample_rate=16000)
    demux = DemuxedAudio(wav_bytes=wav, warnings=[])

    with patch(
        "app.services.video.intelligence.extract_audio_wav_from_video",
        return_value=demux,
    ):
        res = client.post(
            "/api/v1/video-intelligence",
            headers=HEADERS,
            json={
                "interview_id": "vid-report",
                "video_base64": _make_video_b64(frames=6),
                "consent_given": True,
                "include_transcript": True,
                "include_report": True,
                "interview_topics": ["Tell me about yourself"],
                "options": {
                    "transcript_provider": "stub",
                    "stub_transcript": "I led the migration last quarter.",
                    "stub_segments": [
                        {
                            "start_ms": 0,
                            "end_ms": 2000,
                            "text": "I led the migration last quarter.",
                        }
                    ],
                },
            },
        )
    body = res.json()
    assert res.status_code == 200
    assert body["status"] == "succeeded"
    assert body["verified"] is False
    assert body["analysis_completeness"] == "full"
    assert body["transcript"]["text"] == "I led the migration last quarter."
    assert body["transcript"]["error_code"] is None
    assert body["transcript"]["segments"]
    assert body["transcript"]["segments"][0]["start_ms"] == 0
    assert body["transcript"]["segments"][0]["end_ms"] == 2000
    assert body["highlights"]
    assert body["report"] is not None
    assert body["report"]["summary"]
    assert body["report"]["transcript_excerpts"]
    assert body["report"]["processing_status"] in {"complete", "partial"}
    assert body["report"]["summary_source"] in {"llm", "local"}
    assert body["report"]["evidence_notes"]
    assert body["report"]["limitations"] is not None
    assert body["report"]["visual_observations"]


def test_include_transcript_stt_provider_error_propagates_code() -> None:
    from app.schemas.common import JobStatus
    from app.schemas.transcription import TranscriptionProvider, TranscriptionResponse

    wav = build_silent_wav(duration_ms=400, sample_rate=16000)
    demux = DemuxedAudio(wav_bytes=wav, warnings=["near-silent"])

    async def _fail_transcribe(self, payload):  # noqa: ANN001
        return TranscriptionResponse(
            interview_id=payload.interview_id,
            provider=TranscriptionProvider.OPENAI,
            status=JobStatus.FAILED,
            stub=True,
            message="OPENAI_API_KEY not configured",
            text=None,
            segments=[],
            error_code="stt_not_configured",
        )

    with patch(
        "app.services.video.intelligence.extract_audio_wav_from_video",
        return_value=demux,
    ), patch(
        "app.services.video.intelligence.TranscriptionService.transcribe",
        _fail_transcribe,
    ):
        res = client.post(
            "/api/v1/video-intelligence",
            headers=HEADERS,
            json={
                "interview_id": "vid-stt-fail",
                "video_base64": _make_video_b64(frames=4),
                "consent_given": True,
                "include_transcript": True,
                "options": {"transcript_provider": "openai"},
            },
        )
    body = res.json()
    assert body["status"] == "succeeded"
    assert body["analysis_completeness"] == "partial"
    assert body["transcript"]["error_code"] == "stt_not_configured"
    assert body["transcript"]["text"] is None
    # Must not invent speech on STT failure
    assert not any(
        (h.get("transcript_excerpt") or "").strip()
        for h in body.get("highlights") or []
    )


def test_include_transcript_ffmpeg_missing() -> None:
    from app.services.video.audio_demux import VideoAudioError

    with patch(
        "app.services.video.intelligence.extract_audio_wav_from_video",
        side_effect=VideoAudioError("FFmpeg not found", code="ffmpeg_missing"),
    ):
        res = client.post(
            "/api/v1/video-intelligence",
            headers=HEADERS,
            json={
                "interview_id": "vid-ffmpeg",
                "video_base64": _make_video_b64(frames=3),
                "consent_given": True,
                "include_transcript": True,
            },
        )
    body = res.json()
    assert body["status"] == "succeeded"
    assert body["transcript"]["error_code"] == "ffmpeg_missing"
    assert body["analysis_completeness"] == "partial"


def test_include_transcript_empty_stt_text() -> None:
    from app.schemas.common import JobStatus
    from app.schemas.transcription import TranscriptionProvider, TranscriptionResponse

    wav = build_silent_wav(duration_ms=400, sample_rate=16000)
    demux = DemuxedAudio(wav_bytes=wav, warnings=["Extracted audio appears near-silent"])

    async def _empty(self, payload):  # noqa: ANN001
        return TranscriptionResponse(
            interview_id=payload.interview_id,
            provider=TranscriptionProvider.OPENAI,
            status=JobStatus.SUCCEEDED,
            stub=False,
            message="OK",
            text="   ",
            segments=[],
            error_code=None,
        )

    with patch(
        "app.services.video.intelligence.extract_audio_wav_from_video",
        return_value=demux,
    ), patch(
        "app.services.video.intelligence.TranscriptionService.transcribe",
        _empty,
    ):
        res = client.post(
            "/api/v1/video-intelligence",
            headers=HEADERS,
            json={
                "interview_id": "vid-empty-tx",
                "video_base64": _make_video_b64(frames=3),
                "consent_given": True,
                "include_transcript": True,
                "options": {"transcript_provider": "openai"},
            },
        )
    body = res.json()
    assert body["transcript"]["error_code"] == "transcription_empty"
    assert body["analysis_completeness"] == "partial"


def test_transcript_provider_openai_honored_over_env_stub() -> None:
    """Request options.transcript_provider=openai must not silently use env stub."""
    from app.schemas.transcription import TranscriptionProvider, TranscriptionRequest
    from app.services.voice.transcription import _resolve_provider_name

    assert (
        _resolve_provider_name(TranscriptionProvider.OPENAI) == "openai"
    )
    assert _resolve_provider_name(TranscriptionProvider.STUB) == "stub"
    assert _resolve_provider_name(TranscriptionProvider.WHISPER) == "whisper"

    # Build request the same way video intel does
    req = TranscriptionRequest(
        interview_id="x",
        provider=TranscriptionProvider.OPENAI,
        audio_base64="AAAA",
    )
    assert req.provider == TranscriptionProvider.OPENAI


def test_wav_near_silent_detection() -> None:
    from app.services.video.audio_demux import wav_pcm16_rms

    silent = build_silent_wav(duration_ms=500, sample_rate=16000)
    rms = wav_pcm16_rms(silent)
    assert rms is not None
    assert rms < 30.0


def test_auth_required() -> None:
    res = client.post(
        "/api/v1/video-intelligence",
        json={
            "interview_id": "vid-auth",
            "video_base64": _make_video_b64(frames=2),
            "consent_given": True,
        },
    )
    assert res.status_code in {401, 403}


def test_source_url_invalid_scheme_returns_clear_error() -> None:
    res = client.post(
        "/api/v1/video-intelligence",
        headers=HEADERS,
        json={
            "interview_id": "vid-bad-url",
            "source_url": "ftp://example.com/clip.mp4",
            "consent_given": True,
        },
    )
    body = res.json()
    assert body["verified"] is False
    assert body["error_code"] == "invalid_source_url"


def test_source_url_local_absolute_path() -> None:
    settings = get_settings()
    prev = settings.video_allow_local_source
    settings.video_allow_local_source = True
    path = Path("/tmp/tj_test_video_source.avi")
    fourcc = cv2.VideoWriter_fourcc(*"MJPG")
    writer = cv2.VideoWriter(str(path), fourcc, 4.0, (120, 120))
    assert writer.isOpened()
    for i in range(4):
        writer.write(np.full((120, 120, 3), (50 + i, 100, 150), dtype=np.uint8))
    writer.release()
    try:
        res = client.post(
            "/api/v1/video-intelligence",
            headers=HEADERS,
            json={
                "interview_id": "vid-local-path",
                "source_url": str(path),
                "consent_given": True,
            },
        )
        body = res.json()
        assert res.status_code == 200
        assert body["status"] == "succeeded"
        assert body["liveness_passed"] is True
        assert body["verified"] is False  # no registered photo
        assert body["frames_analyzed"] >= 1
        assert body["error_code"] is None
    finally:
        settings.video_allow_local_source = prev
        path.unlink(missing_ok=True)


def test_source_url_local_disabled_by_default() -> None:
    settings = get_settings()
    prev = settings.video_allow_local_source
    settings.video_allow_local_source = False
    try:
        res = client.post(
            "/api/v1/video-intelligence",
            headers=HEADERS,
            json={
                "interview_id": "vid-local-off",
                "source_url": "/tmp/does-not-matter.mp4",
                "consent_given": True,
            },
        )
        body = res.json()
        assert body["verified"] is False
        assert body["error_code"] == "local_source_disabled"
    finally:
        settings.video_allow_local_source = prev
