"""Phase-2: SSRF, upload limits, temp cleanup, metrics (no live DeepFace)."""

from __future__ import annotations

import base64
import time
from pathlib import Path
from unittest.mock import AsyncMock, MagicMock, patch

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

from app.config import get_settings
from app.main import app
from app.services.face.engine import (
    FaceAnalysisEngine,
    FaceEngineResult,
    FrameAnalysis,
    set_face_engine_override,
)
from app.services.face.video_frames import VideoFrameError, decode_video_base64
from app.services.video.temp_cleanup import cleanup_orphaned_video_temps
from app.services.video.url_safety import assert_public_http_url, looks_like_video_bytes

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


class FakeEngine(FaceAnalysisEngine):
    name = "fake"

    def analyze(self, *, registered_bgr, live_frames_bgr) -> FaceEngineResult:
        return FaceEngineResult(
            identity_matched=None,
            distance=None,
            threshold=None,
            match_score=None,
            liveness_passed=True,
            liveness_score=0.9,
            model="ArcFace",
            detector="opencv",
            face_count=1,
            frame_results=[
                FrameAnalysis(
                    face_count=1,
                    is_real=True,
                    antispoof_score=0.9,
                    faces_detected=True,
                )
                for _ in live_frames_bgr
            ],
            warnings=[],
            error_code=None,
            provider="fake",
            faces_detected_ratio=1.0,
            multi_face_frames=0,
        )


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


def _make_video_bytes(*, frames: int = 8, size: int = 120, fps: float = 4.0) -> bytes:
    path = Path("/tmp/tj_phase2_vid.avi")
    fourcc = cv2.VideoWriter_fourcc(*"MJPG")
    writer = cv2.VideoWriter(str(path), fourcc, fps, (size, size))
    assert writer.isOpened()
    for i in range(frames):
        writer.write(np.full((size, size, 3), (40 + i, 100, 160), dtype=np.uint8))
    writer.release()
    data = path.read_bytes()
    path.unlink(missing_ok=True)
    return data


def test_ssrf_blocks_loopback_and_private() -> None:
    with pytest.raises(VideoFrameError) as ei:
        assert_public_http_url("http://127.0.0.1/video.mp4", resolve_dns=False)
    assert ei.value.code == "ssrf_blocked"

    with pytest.raises(VideoFrameError) as ei2:
        assert_public_http_url("http://localhost/x", resolve_dns=False)
    assert ei2.value.code == "ssrf_blocked"

    with pytest.raises(VideoFrameError) as ei3:
        assert_public_http_url("http://10.0.0.5/clip.mp4", resolve_dns=False)
    assert ei3.value.code == "ssrf_blocked"

    with pytest.raises(VideoFrameError) as ei4:
        assert_public_http_url("http://169.254.169.254/latest/meta-data/", resolve_dns=False)
    assert ei4.value.code == "ssrf_blocked"


def test_ssrf_blocks_ftp_and_file_via_http_assert() -> None:
    with pytest.raises(VideoFrameError) as ei:
        assert_public_http_url("ftp://example.com/a.mp4", resolve_dns=False)
    assert ei.value.code == "invalid_source_url"


def test_api_rejects_private_source_url() -> None:
    res = client.post(
        "/api/v1/video-intelligence",
        headers=HEADERS,
        json={
            "interview_id": "ssrf-1",
            "source_url": "http://127.0.0.1:8000/secret.mp4",
            "consent_given": True,
        },
    )
    body = res.json()
    assert body["verified"] is False
    assert body["error_code"] == "ssrf_blocked"


def test_base64_size_rejected_before_decode() -> None:
    settings = get_settings()
    # Force tiny limit
    prev = settings.video_max_upload_bytes
    settings.video_max_upload_bytes = 100
    try:
        # ~200 bytes decoded estimate from long base64
        huge = base64.b64encode(b"x" * 500).decode("ascii")
        with pytest.raises(VideoFrameError) as ei:
            decode_video_base64(huge, max_bytes=100)
        assert ei.value.code == "video_too_large"
    finally:
        settings.video_max_upload_bytes = prev


def test_looks_like_video_bytes_avi() -> None:
    data = _make_video_bytes(frames=2)
    assert looks_like_video_bytes(data) is True
    assert looks_like_video_bytes(b"not-a-video") is False


def test_http_redirect_to_private_blocked() -> None:
    from app.services.video.intelligence import VideoIntelligenceService

    svc = VideoIntelligenceService()

    redirect = MagicMock()
    redirect.status_code = 302
    redirect.headers = {"location": "http://127.0.0.1/evil.mp4"}

    with patch("httpx.AsyncClient") as client_cls:
        instance = AsyncMock()
        instance.__aenter__.return_value = instance
        instance.__aexit__.return_value = None
        instance.get = AsyncMock(return_value=redirect)
        client_cls.return_value = instance

        with pytest.raises(VideoFrameError) as ei:
            import asyncio

            asyncio.run(svc._fetch_http("https://example.com/clip.mp4"))
        assert ei.value.code == "ssrf_blocked"


def test_max_frames_enforced() -> None:
    from app.services.face.video_frames import extract_frames_from_bytes

    data = _make_video_bytes(frames=40, fps=10.0)
    extracted = extract_frames_from_bytes(data, sample_fps=10.0, max_frames=5)
    try:
        assert len(extracted.frames_bgr) == 5
        assert len(extracted.frame_indices) == 5
        assert len(extracted.timestamps_ms) == 5
        # Distributed across full clip (not only first 0.5s)
        assert extracted.frame_indices[0] == 0
        assert extracted.frame_indices[-1] >= 30
    finally:
        extracted.cleanup()


def test_temp_cleanup_respects_retention(tmp_path: Path) -> None:
    old = tmp_path / "tj_video_old"
    new = tmp_path / "tj_video_new"
    other = tmp_path / "keep_me"
    old.mkdir()
    new.mkdir()
    other.mkdir()
    old_file = old / "x.bin"
    old_file.write_bytes(b"abc")
    # Age the old dir
    import os

    past = time.time() - 48 * 3600
    os.utime(old, (past, past))
    result = cleanup_orphaned_video_temps(
        retention_hours=24.0, tmp_root=tmp_path, dry_run=False
    )
    assert result["removed"] >= 1
    assert not old.exists()
    assert new.exists()
    assert other.exists()


def test_metrics_endpoint_auth_and_no_cv_init() -> None:
    from app.services.face.lazy_deepface import deepface_import_attempts, is_deepface_loaded

    attempts_before = deepface_import_attempts()
    loaded_before = is_deepface_loaded()
    bare = client.get("/api/v1/metrics")
    assert bare.status_code in {401, 403}
    res = client.get("/api/v1/metrics", headers=HEADERS)
    assert res.status_code == 200
    body = res.json()
    assert body.get("enabled") is True
    assert "counters" in body
    assert is_deepface_loaded() is loaded_before
    assert deepface_import_attempts() == attempts_before


def test_health_still_light() -> None:
    from app.services.face.lazy_deepface import is_deepface_loaded

    assert client.get("/api/v1/health").json()["status"] == "ok"
    # FakeEngine override active but DeepFace API not imported
    assert is_deepface_loaded() is False
