"""Face enrollment + interview verify — FakeEngine (no DeepFace weights in CI)."""

from __future__ import annotations

import base64
import io
from pathlib import Path

import pytest
from fastapi.testclient import TestClient
from PIL import Image

from app.config import get_settings
from app.main import app
from app.services.face.audit_store import face_audit_store
from app.services.face.engine import (
    FaceAnalysisEngine,
    FaceEngineResult,
    FrameAnalysis,
    set_face_engine_override,
)
from app.services.face.enrollment_store import face_enrollment_store
from app.services.interviews.session_store import session_store

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")


class FakeEngine(FaceAnalysisEngine):
    name = "fake"

    def __init__(
        self,
        *,
        identity_matched: bool | None = True,
        liveness_passed: bool = True,
        error_code: str | None = None,
        liveness_score: float = 0.92,
        distance: float = 0.25,
        threshold: float = 0.68,
    ) -> None:
        self.identity_matched = identity_matched
        self.liveness_passed = liveness_passed
        self.error_code = error_code
        self.liveness_score = liveness_score
        self.distance = distance
        self.threshold = threshold
        self.calls = 0

    def analyze(self, *, registered_bgr, live_frames_bgr) -> FaceEngineResult:
        self.calls += 1
        assert live_frames_bgr
        identity = self.identity_matched
        if registered_bgr is None:
            identity = None
        if identity is True and self.liveness_passed:
            err = None
        elif not self.liveness_passed and identity is False:
            err = self.error_code or "liveness_and_identity_failed"
        elif not self.liveness_passed:
            err = self.error_code or "liveness_failed"
        elif identity is False:
            err = self.error_code or "identity_mismatch"
        else:
            err = self.error_code
        return FaceEngineResult(
            identity_matched=identity,
            distance=self.distance if identity is not None else None,
            threshold=self.threshold if identity is not None else None,
            match_score=0.82 if identity else (None if identity is None else 0.3),
            liveness_passed=self.liveness_passed,
            liveness_score=self.liveness_score,
            liveness_frame_pass_ratio=1.0 if self.liveness_passed else 0.0,
            model="ArcFace",
            detector="opencv",
            face_count=1,
            frame_results=[
                FrameAnalysis(
                    face_count=1,
                    is_real=self.liveness_passed,
                    antispoof_score=self.liveness_score,
                    faces_detected=True,
                )
                for _ in live_frames_bgr
            ],
            warnings=[] if err is None else ["fake failure"],
            error_code=err,
            provider="fake",
            faces_detected_ratio=1.0,
            multi_face_frames=0,
        )


def _enroll_payload(user_id: str = "user-jane-001", **overrides):
    data = {
        "user_id": user_id,
        "company_id": "co-acme-001",
        "live_frames_base64": [
            _png_b64((198, 158, 138)),
            _png_b64((202, 162, 142)),
        ],
        "consent_given": True,
        "consent_id": "c-enroll-1",
    }
    data.update(overrides)
    return data


def _verify_payload(user_id: str = "user-jane-001", **overrides):
    data = {
        "user_id": user_id,
        "interview_id": "fv-genuine",
        "candidate_id": "cand-1",
        "live_frames_base64": [
            _png_b64((198, 158, 138)),
            _png_b64((202, 162, 142)),
        ],
        "consent_given": True,
        "consent_id": "c-1",
    }
    data.update(overrides)
    return data


def _enroll(user_id: str = "user-jane-001") -> dict:
    res = client.post(
        "/api/v1/face-verification/enroll",
        headers=HEADERS,
        json=_enroll_payload(user_id=user_id),
    )
    assert res.status_code == 200
    body = res.json()
    assert body["enrolled"] is True
    assert body["reference_stored"] is True
    assert "live_frames_base64" not in body
    assert body.get("image_base64") is None
    return body


@pytest.fixture(autouse=True)
def _reset(tmp_path: Path):
    face_audit_store.configure(persist_dir=tmp_path / "face_audits", backend="filesystem")
    face_audit_store.clear()
    face_enrollment_store.configure(persist_dir=tmp_path / "face_enroll")
    face_enrollment_store.clear()
    session_store.configure(persist_dir=tmp_path / "sessions", backend="filesystem")
    session_store.clear()
    set_face_engine_override(FakeEngine())
    yield
    set_face_engine_override(None)
    face_audit_store.clear()
    face_enrollment_store.clear()
    session_store.clear()


def test_enroll_live_face() -> None:
    body = _enroll()
    assert body["liveness_passed"] is True
    assert body["enrollment_id"]
    assert body["enrolled_at"]
    assert body["stub"] is False
    assert face_enrollment_store.get_active("user-jane-001") is not None


def test_enroll_liveness_required() -> None:
    set_face_engine_override(
        FakeEngine(liveness_passed=False, error_code="liveness_failed")
    )
    res = client.post(
        "/api/v1/face-verification/enroll",
        headers=HEADERS,
        json=_enroll_payload(user_id="user-spoof"),
    )
    body = res.json()
    assert body["enrolled"] is False
    assert body["error_code"] == "liveness_failed"
    assert face_enrollment_store.get_active("user-spoof") is None


def test_enroll_consent_required() -> None:
    res = client.post(
        "/api/v1/face-verification/enroll",
        headers=HEADERS,
        json=_enroll_payload(consent_given=False),
    )
    body = res.json()
    assert body["enrolled"] is False
    assert body["error_code"] == "consent_required"


def test_genuine_pass_after_enroll() -> None:
    _enroll()
    res = client.post(
        "/api/v1/face-verification/verify",
        headers=HEADERS,
        json=_verify_payload(),
    )
    assert res.status_code == 200
    body = res.json()
    assert body["verified"] is True
    assert body["identity_matched"] is True
    assert body["liveness_passed"] is True
    assert body["identity"]["matched"] is True
    assert body["identity"]["reference_source"] == "enrollment"
    assert body["reference_source"] == "enrollment"
    assert body["enrollment_id"]
    assert body["liveness"]["passed"] is True
    assert body["consent_recorded"] is True
    assert body["stub"] is False
    assert body["model"] == "ArcFace"
    assert body["distance"] is not None
    assert body["audit_id"]
    assert body["verified_at"]
    assert body["expires_at"]
    assert body["frame_count"] == 2
    assert body["retry_allowed"] is False
    assert any("enrolled" in w.lower() for w in body["warnings"])


def test_consent_required() -> None:
    _enroll()
    res = client.post(
        "/api/v1/face-verification/verify",
        headers=HEADERS,
        json=_verify_payload(consent_given=False, interview_id="fv-noconsent"),
    )
    body = res.json()
    assert body["verified"] is False
    assert body["error_code"] == "consent_required"
    assert body["consent_recorded"] is False


def test_identity_and_liveness_reported_separately() -> None:
    _enroll()
    set_face_engine_override(
        FakeEngine(identity_matched=True, liveness_passed=False, error_code="liveness_failed")
    )
    res = client.post(
        "/api/v1/face-verification/verify",
        headers=HEADERS,
        json=_verify_payload(interview_id="fv-sep"),
    )
    body = res.json()
    assert body["verified"] is False
    assert body["identity"]["matched"] is True
    assert body["liveness"]["passed"] is False
    assert body["identity_matched"] is True
    assert body["liveness_passed"] is False
    assert body["error_code"] == "liveness_failed"
    assert body["manual_review_available"] is True


def test_different_identity_fails() -> None:
    _enroll()
    set_face_engine_override(
        FakeEngine(identity_matched=False, liveness_passed=True, error_code="identity_mismatch")
    )
    res = client.post(
        "/api/v1/face-verification/verify",
        headers=HEADERS,
        json=_verify_payload(
            interview_id="fv-mismatch",
            live_frames_base64=[_png_b64((200, 200, 200)), _png_b64((210, 210, 210))],
        ),
    )
    body = res.json()
    assert body["verified"] is False
    assert body["identity_matched"] is False
    assert body["liveness_passed"] is True
    assert body["error_code"] == "identity_mismatch"
    assert body["retry_allowed"] is True
    assert body["manual_review_available"] is True


def test_enrollment_required() -> None:
    res = client.post(
        "/api/v1/face-verification/verify",
        headers=HEADERS,
        json=_verify_payload(user_id="never-enrolled", interview_id="fv-no-enroll"),
    )
    body = res.json()
    assert body["verified"] is False
    assert body["error_code"] == "enrollment_required"
    assert body["reference_source"] == "none"


def test_spoof_liveness_fails() -> None:
    _enroll()
    set_face_engine_override(
        FakeEngine(identity_matched=True, liveness_passed=False, error_code="liveness_failed")
    )
    res = client.post(
        "/api/v1/face-verification/verify",
        headers=HEADERS,
        json=_verify_payload(
            interview_id="fv-spoof",
            live_image_base64=_png_b64(),
            live_frames_base64=[_png_b64()],
        ),
    )
    body = res.json()
    assert body["verified"] is False
    assert body["liveness_passed"] is False
    assert body["error_code"] == "liveness_failed"


def test_manual_review_route_disabled() -> None:
    res = client.post(
        "/api/v1/face-verification/manual-review",
        headers=HEADERS,
        json={
            "user_id": "user-jane-001",
            "interview_id": "fv-manual",
            "reviewer_id": "rev-admin-1",
            "reason": "False rejection confirmed by recruiter after video call",
        },
    )
    assert res.status_code == 404


def test_corrupt_live_image_fails() -> None:
    _enroll()
    res = client.post(
        "/api/v1/face-verification/verify",
        headers=HEADERS,
        json=_verify_payload(
            interview_id="fv-corrupt",
            live_frames_base64=[
                base64.b64encode(b"not-an-image!!!!").decode(),
                base64.b64encode(b"also-bad").decode(),
            ],
        ),
    )
    body = res.json()
    assert body["status"] == "failed"
    assert body["verified"] is False
    assert body["error_code"] in {"corrupt_image", "invalid_image"}


def test_insufficient_frames() -> None:
    _enroll()
    res = client.post(
        "/api/v1/face-verification/verify",
        headers=HEADERS,
        json=_verify_payload(
            interview_id="fv-frames",
            live_frames_base64=[_png_b64()],
        ),
    )
    assert res.json()["error_code"] == "insufficient_frames"


def test_id_verification_route_disabled() -> None:
    res = client.post(
        "/api/v1/id-verification/verify",
        headers=HEADERS,
        json={
            "interview_id": "int-1",
            "expected_name": "John Doe",
            "id_image_base64": "AAAA",
        },
    )
    assert res.status_code == 404


def test_audit_persisted(tmp_path: Path) -> None:
    _enroll()
    iid = "fv-audit"
    client.post(
        "/api/v1/face-verification/verify",
        headers=HEADERS,
        json=_verify_payload(interview_id=iid),
    )
    rec = face_audit_store.latest_passed(iid, max_age_seconds=3600)
    assert rec is not None
    assert rec.registered_image_sha256
    assert not hasattr(rec, "registered_photo_base64")
    path = Path(face_audit_store._persist_dir) / f"{iid}.jsonl"  # noqa: SLF001
    assert path.exists()
    text = path.read_text(encoding="utf-8")
    assert "live_image_base64" not in text
    assert "registered_photo_base64" not in text
