# test_face_verification_deps_and_engine.py
"""Missing dependencies and engine failure handling for face enroll/verify."""

from __future__ import annotations

import base64
import io

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.deps import FaceStackStatus
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 analyze(self, *, registered_bgr, live_frames_bgr) -> FaceEngineResult:
        return FaceEngineResult(
            identity_matched=None if registered_bgr is None else True,
            distance=0.2 if registered_bgr is not None else None,
            threshold=0.68 if registered_bgr is not None else None,
            match_score=0.9 if registered_bgr is not None else None,
            liveness_passed=True,
            liveness_score=0.95,
            liveness_frame_pass_ratio=1.0,
            model="ArcFace",
            detector="opencv",
            face_count=1,
            frame_results=[
                FrameAnalysis(
                    face_count=1,
                    is_real=True,
                    antispoof_score=0.95,
                    faces_detected=True,
                )
                for _ in live_frames_bgr
            ],
            warnings=[],
            error_code=None,
            provider="fake",
            faces_detected_ratio=1.0,
            multi_face_frames=0,
        )


def _enroll(user_id: str = "user-deps-1") -> None:
    set_face_engine_override(FakeEngine())
    res = client.post(
        "/api/v1/face-verification/enroll",
        headers=HEADERS,
        json={
            "user_id": user_id,
            "live_frames_base64": [_png_b64(), _png_b64()],
            "consent_given": True,
        },
    )
    assert res.status_code == 200
    assert res.json()["enrolled"] is True


def _verify_payload(user_id: str = "user-deps-1", **overrides):
    data = {
        "user_id": user_id,
        "interview_id": "test-deps-engine",
        "candidate_id": "cand-1",
        "live_frames_base64": [_png_b64(), _png_b64()],
        "consent_given": True,
        "consent_id": "c-1",
    }
    data.update(overrides)
    return data


@pytest.fixture(autouse=True)
def _reset(tmp_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(None)
    yield
    set_face_engine_override(None)
    face_audit_store.clear()
    face_enrollment_store.clear()
    session_store.clear()


def test_missing_dependencies_on_enroll(monkeypatch):
    def fake_status():
        return FaceStackStatus(
            ok=False,
            deepface=False,
            opencv=True,
            tensorflow=False,
            arcface_supported=False,
            antispoof_supported=False,
            missing=["deepface", "tensorflow/tf-keras"],
            warnings=[],
            detail="missing deepface and tensorflow",
        )

    monkeypatch.setattr("app.services.face.deps.get_face_stack_status", fake_status)
    set_face_engine_override(None)
    res = client.post(
        "/api/v1/face-verification/enroll",
        headers=HEADERS,
        json={
            "user_id": "user-nodeps",
            "live_frames_base64": [_png_b64(), _png_b64()],
            "consent_given": True,
        },
    )
    body = res.json()
    assert body["status"] == "failed"
    assert body["error_code"] == "deps_unavailable"
    assert body["deps_ok"] is False


def test_missing_dependencies_on_verify(monkeypatch):
    _enroll()
    set_face_engine_override(None)

    def fake_status():
        return FaceStackStatus(
            ok=False,
            deepface=False,
            opencv=True,
            tensorflow=False,
            arcface_supported=False,
            antispoof_supported=False,
            missing=["deepface", "tensorflow/tf-keras"],
            warnings=[],
            detail="missing deepface and tensorflow",
        )

    monkeypatch.setattr("app.services.face.deps.get_face_stack_status", fake_status)
    res = client.post(
        "/api/v1/face-verification/verify",
        headers=HEADERS,
        json=_verify_payload(),
    )
    body = res.json()
    assert body["status"] == "failed"
    assert body["error_code"] == "deps_unavailable"
    assert body["deps_ok"] is False


def test_engine_failure(monkeypatch):
    _enroll()

    class BrokenEngine:
        name = "broken"

        def analyze(self, *, registered_bgr, live_frames_bgr):
            raise RuntimeError("simulated engine failure")

    set_face_engine_override(BrokenEngine())

    def ok_status():
        return FaceStackStatus(
            ok=True,
            deepface=True,
            opencv=True,
            tensorflow=True,
            arcface_supported=True,
            antispoof_supported=True,
            missing=[],
            warnings=[],
            detail="all good",
        )

    monkeypatch.setattr("app.services.face.deps.get_face_stack_status", ok_status)
    res = client.post(
        "/api/v1/face-verification/verify",
        headers=HEADERS,
        json=_verify_payload(),
    )
    body = res.json()
    assert body["status"] == "failed"
    assert body["error_code"] == "engine_error"
    assert body["deps_ok"] is True
