"""Iteration 2 backend tests: quality gate + multi-face detection.

Covers the new behaviours added to:
 - POST /api/employees/{emp_id}/enroll-face  (quality gate)
 - POST /api/attendance/match  (multi-face schema + dedupe)
"""
from __future__ import annotations

import base64
import io
import os
import sys
from datetime import datetime, timedelta, timezone
from urllib.request import Request, urlopen

import pytest
import requests
from dotenv import load_dotenv
from PIL import Image, ImageFilter

load_dotenv("/app/backend/.env")
load_dotenv("/app/frontend/.env")
sys.path.insert(0, "/app/backend")

from server import (  # noqa: E402
    Employee,
    OtpCode,
    SessionLocal,
    Supervisor,
    password_hash,
)

BASE_URL = os.environ["EXPO_PUBLIC_BACKEND_URL"].rstrip("/") + "/api"


# ---------- fixtures ----------
@pytest.fixture(scope="module")
def token() -> str:
    with SessionLocal() as db:
        sup = db.query(Supervisor).first()
        assert sup, "no supervisor row seeded"
        email = sup.email
        db.query(OtpCode).filter(OtpCode.email == email.lower()).delete()
        db.add(
            OtpCode(
                email=email.lower(),
                code_hash=password_hash.hash("123456"),
                expires_at=datetime.now(timezone.utc).replace(tzinfo=None)
                + timedelta(minutes=5),
                attempts=0,
            )
        )
        db.commit()
    r = requests.post(
        f"{BASE_URL}/auth/verify-otp",
        json={"email": email, "otp": "123456"},
        timeout=60,
    )
    assert r.status_code == 200, r.text
    return r.json()["access_token"]


@pytest.fixture(scope="module")
def headers(token) -> dict:
    return {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}


def _b64_of(img: Image.Image, q: int = 85) -> str:
    buf = io.BytesIO()
    img.save(buf, format="JPEG", quality=q)
    return base64.b64encode(buf.getvalue()).decode()


@pytest.fixture(scope="module")
def ramesh() -> tuple[str, str]:
    """Return (emp_id, photo_url) for DHD-1042."""
    with SessionLocal() as db:
        emp = db.query(Employee).filter(Employee.code == "DHD-1042").first()
        assert emp, "DHD-1042 not seeded"
        return emp.id, emp.photo


@pytest.fixture(scope="module")
def ramesh_face_img(ramesh) -> Image.Image:
    _, photo_url = ramesh
    if photo_url.startswith("data:"):
        raw = base64.b64decode(photo_url.split(",", 1)[1])
    else:
        req = Request(photo_url, headers={"User-Agent": "pytest/1.0"})
        raw = urlopen(req, timeout=15).read()
    im = Image.open(io.BytesIO(raw)).convert("RGB")
    im.thumbnail((640, 640))
    return im


@pytest.fixture(scope="module")
def second_employee(headers, ramesh_face_img):
    """Enrol a second employee (any active non-DHD-1042) with a modified
    version of Ramesh's photo so we get a distinct encoding for the
    multi-face different-employees scenario."""
    with SessionLocal() as db:
        emp = (
            db.query(Employee)
            .filter(Employee.code != "DHD-1042", Employee.status != "Inactive")
            .first()
        )
        assert emp, "need a second employee row seeded"
        emp_id = emp.id
        emp_code = emp.code
        photo_url = emp.photo

    # Try to use that employee's OWN seeded photo so the encoding is genuinely
    # different from DHD-1042. Fall back to the ramesh photo if fetch fails
    # (in which case this test still exercises the multi-face plumbing).
    face_img: Image.Image
    try:
        if photo_url and not photo_url.startswith("data:"):
            req = Request(photo_url, headers={"User-Agent": "pytest/1.0"})
            raw = urlopen(req, timeout=15).read()
            face_img = Image.open(io.BytesIO(raw)).convert("RGB")
            face_img.thumbnail((640, 640))
        elif photo_url and photo_url.startswith("data:"):
            raw = base64.b64decode(photo_url.split(",", 1)[1])
            face_img = Image.open(io.BytesIO(raw)).convert("RGB")
            face_img.thumbnail((640, 640))
        else:
            face_img = ramesh_face_img
    except Exception:
        face_img = ramesh_face_img

    b64 = _b64_of(face_img)
    r = requests.post(
        f"{BASE_URL}/employees/{emp_id}/enroll-face",
        headers=headers,
        json={"image_b64": b64, "update_photo": False},
        timeout=60,
    )
    if r.status_code != 200:
        pytest.skip(
            f"couldn't enrol second employee {emp_code}: {r.status_code} {r.text[:120]}"
        )
    return emp_id, emp_code, face_img


# ---------- Enrolment quality gate ----------
class TestEnrolQualityGate:
    def test_dark_image_rejected(self, headers, ramesh):
        emp_id, _ = ramesh
        black = Image.new("RGB", (400, 400), color=(0, 0, 0))
        r = requests.post(
            f"{BASE_URL}/employees/{emp_id}/enroll-face",
            headers=headers,
            json={"image_b64": _b64_of(black, q=80), "update_photo": False},
            timeout=30,
        )
        assert r.status_code == 422, r.text
        assert r.json()["detail"].startswith("The image is too dark"), r.text

    def test_overexposed_image_rejected(self, headers, ramesh):
        emp_id, _ = ramesh
        white = Image.new("RGB", (400, 400), color=(255, 255, 255))
        r = requests.post(
            f"{BASE_URL}/employees/{emp_id}/enroll-face",
            headers=headers,
            json={"image_b64": _b64_of(white, q=80), "update_photo": False},
            timeout=30,
        )
        assert r.status_code == 422, r.text
        assert r.json()["detail"].startswith("The image is over-exposed"), r.text

    def test_blurred_image_rejected(self, headers, ramesh, ramesh_face_img):
        emp_id, _ = ramesh
        blurred = ramesh_face_img.filter(ImageFilter.GaussianBlur(radius=20))
        r = requests.post(
            f"{BASE_URL}/employees/{emp_id}/enroll-face",
            headers=headers,
            json={"image_b64": _b64_of(blurred, q=80), "update_photo": False},
            timeout=30,
        )
        # spec allows detail to be "No face detected." because heavy blur
        # trips the face detector before the sharpness gate.
        assert r.status_code == 422, r.text
        detail = r.json()["detail"]
        assert (
            detail.startswith("The image is too blurry")
            or detail.startswith("No face detected")
        ), detail

    def test_two_faces_rejected(self, headers, ramesh, ramesh_face_img):
        emp_id, _ = ramesh
        w, h = ramesh_face_img.size
        canvas = Image.new("RGB", (w * 2 + 20, h), color=(255, 255, 255))
        canvas.paste(ramesh_face_img, (0, 0))
        canvas.paste(ramesh_face_img, (w + 20, 0))
        r = requests.post(
            f"{BASE_URL}/employees/{emp_id}/enroll-face",
            headers=headers,
            json={"image_b64": _b64_of(canvas), "update_photo": False},
            timeout=60,
        )
        assert r.status_code == 422, r.text
        detail = r.json()["detail"]
        assert "Only one person should be in the frame" in detail, detail
        assert detail.startswith("Detected "), detail

    def test_face_too_far_rejected(self, headers, ramesh, ramesh_face_img):
        """Paste the face into a small region of a much taller canvas so face
        is <15% of image height."""
        emp_id, _ = ramesh
        # Shrink face to ~10% and place in centre of a very tall canvas
        small = ramesh_face_img.copy()
        target_h = 90
        ratio = target_h / small.height
        small = small.resize((int(small.width * ratio), target_h))
        canvas = Image.new("RGB", (max(small.width, 640), 1000), color=(160, 160, 160))
        canvas.paste(small, ((canvas.width - small.width) // 2, 450))
        r = requests.post(
            f"{BASE_URL}/employees/{emp_id}/enroll-face",
            headers=headers,
            json={"image_b64": _b64_of(canvas), "update_photo": False},
            timeout=60,
        )
        # Either "Face is too far away" OR "No face detected" is acceptable —
        # the detector may not find a 90-px face at all. Both are 422 and both
        # correctly REJECT the frame, which is the point of the gate.
        assert r.status_code == 422, r.text
        detail = r.json()["detail"]
        assert (
            detail.startswith("Face is too far away")
            or detail.startswith("No face detected")
        ), detail

    def test_zero_faces_rejected(self, headers, ramesh):
        emp_id, _ = ramesh
        # Plain grey mid-brightness → passes brightness+sharpness but has no face
        im = Image.new("RGB", (400, 400), color=(120, 120, 120))
        # Draw a subtle noise so sharpness isn't zero (still no face)
        import numpy as np
        arr = np.array(im)
        rng = np.random.default_rng(42)
        arr = np.clip(arr + rng.integers(-30, 30, size=arr.shape), 0, 255).astype("uint8")
        noisy = Image.fromarray(arr)
        r = requests.post(
            f"{BASE_URL}/employees/{emp_id}/enroll-face",
            headers=headers,
            json={"image_b64": _b64_of(noisy), "update_photo": False},
            timeout=30,
        )
        assert r.status_code == 422, r.text
        assert r.json()["detail"].startswith("No face detected"), r.text

    def test_happy_path_then_match(self, headers, ramesh, ramesh_face_img):
        emp_id, _ = ramesh
        b64_ok = _b64_of(ramesh_face_img)
        r = requests.post(
            f"{BASE_URL}/employees/{emp_id}/enroll-face",
            headers=headers,
            json={"image_b64": b64_ok, "update_photo": False},
            timeout=60,
        )
        assert r.status_code == 200, r.text

        m = requests.post(
            f"{BASE_URL}/attendance/match",
            headers=headers,
            json={"image_b64": b64_ok, "type": "Check-in", "threshold": 0.6},
            timeout=60,
        )
        assert m.status_code == 200, m.text
        body = m.json()
        assert body["matched"] is True
        assert body["faces_detected"] == 1
        assert body["distance"] is not None
        assert body["distance"] < 0.05
        assert isinstance(body["matches"], list) and len(body["matches"]) == 1


# ---------- Multi-face match ----------
class TestMultiFaceMatch:
    def test_schema_contains_faces_detected_and_matches(self, headers, ramesh_face_img):
        r = requests.post(
            f"{BASE_URL}/attendance/match",
            headers=headers,
            json={
                "image_b64": _b64_of(ramesh_face_img),
                "type": "Check-in",
                "threshold": 0.6,
            },
            timeout=60,
        )
        assert r.status_code == 200, r.text
        body = r.json()
        # Required new keys
        assert "faces_detected" in body
        assert "matches" in body
        assert isinstance(body["faces_detected"], int)
        assert isinstance(body["matches"], list)
        # Backwards compat keys still there
        for k in ("matched", "distance", "employee", "attendance"):
            assert k in body
        # per-face shape
        for m in body["matches"]:
            assert set(["matched", "distance", "employee", "attendance"]).issubset(
                m.keys()
            )

    def test_no_face_frame(self, headers):
        im = Image.new("RGB", (320, 320), color=(120, 120, 120))
        r = requests.post(
            f"{BASE_URL}/attendance/match",
            headers=headers,
            json={"image_b64": _b64_of(im), "type": "Check-in", "threshold": 0.6},
            timeout=30,
        )
        assert r.status_code == 200, r.text
        body = r.json()
        assert body["faces_detected"] == 0
        assert body["matched"] is False
        assert body["matches"] == []

    def test_same_face_twice_dedupes(self, headers, ramesh_face_img):
        """Two copies of the SAME enrolled face side-by-side → faces_detected==2
        but only one matched entry (already_matched_ids dedupe)."""
        w, h = ramesh_face_img.size
        canvas = Image.new("RGB", (w * 2 + 30, h), color=(255, 255, 255))
        canvas.paste(ramesh_face_img, (0, 0))
        canvas.paste(ramesh_face_img, (w + 30, 0))
        r = requests.post(
            f"{BASE_URL}/attendance/match",
            headers=headers,
            json={"image_b64": _b64_of(canvas), "type": "Check-in", "threshold": 0.6},
            timeout=60,
        )
        assert r.status_code == 200, r.text
        body = r.json()
        assert body["faces_detected"] >= 2, body
        matched_count = sum(1 for m in body["matches"] if m["matched"])
        assert matched_count == 1, (
            f"expected exactly one matched entry, got {matched_count}: {body['matches']}"
        )
        # Backward-compat top-level fields point to the first successful match
        assert body["matched"] is True
        assert body["employee"] is not None
        assert body["employee"]["code"] == "DHD-1042"

    def test_two_different_employees(self, headers, ramesh_face_img, second_employee):
        """Paste Ramesh + another enrolled employee side-by-side → both match
        with distinct employee IDs, two AttendanceRecord rows created."""
        emp2_id, emp2_code, face2 = second_employee
        # Ensure both faces are similar size
        h_target = 480
        r1 = ramesh_face_img.copy()
        r1.thumbnail((h_target, h_target))
        r2 = face2.copy()
        r2.thumbnail((h_target, h_target))
        canvas_w = r1.width + r2.width + 30
        canvas_h = max(r1.height, r2.height)
        canvas = Image.new("RGB", (canvas_w, canvas_h), color=(240, 240, 240))
        canvas.paste(r1, (0, 0))
        canvas.paste(r2, (r1.width + 30, 0))

        # Snapshot attendance count before
        before = requests.get(
            f"{BASE_URL}/attendance/today", headers=headers, timeout=15
        )
        before_count = len(before.json()) if before.status_code == 200 else 0

        r = requests.post(
            f"{BASE_URL}/attendance/match",
            headers=headers,
            json={"image_b64": _b64_of(canvas), "type": "Check-in", "threshold": 0.6},
            timeout=60,
        )
        assert r.status_code == 200, r.text
        body = r.json()
        assert body["faces_detected"] >= 2, body
        matched_entries = [m for m in body["matches"] if m["matched"]]
        assert len(matched_entries) >= 2, (
            f"expected >=2 matched, got {len(matched_entries)}: {body}"
        )
        emp_ids = {m["employee"]["id"] for m in matched_entries}
        assert len(emp_ids) >= 2, f"employee IDs not distinct: {emp_ids}"
        # verify DHD-1042 is one of them
        codes = {m["employee"]["code"] for m in matched_entries}
        assert "DHD-1042" in codes
        assert emp2_code in codes

        # Verify BOTH attendance rows created
        after = requests.get(
            f"{BASE_URL}/attendance/today", headers=headers, timeout=15
        )
        after_count = len(after.json())
        assert after_count >= before_count + 2, (
            f"expected at least 2 new attendance rows: before={before_count} after={after_count}"
        )

    def test_no_match_fallback(self, headers):
        """Unenrolled face → matched=false, matches contains one entry per
        detected face all with matched=false, top-level employee/attendance
        are null."""
        # Synthesize a simple face-like drawing that face_recognition MIGHT
        # not detect at all. If none detected, fallback returns matches=[].
        # Use a real face image that is NOT enrolled — since all enrolled
        # employees have similar stock photos, this is hard. Instead, we
        # temporarily raise threshold impossibly low.
        with SessionLocal() as db:
            emp = db.query(Employee).filter(Employee.code == "DHD-1042").first()
            if not emp or not emp.face_encoding:
                pytest.skip("DHD-1042 not enrolled")
            photo_url = emp.photo
        if photo_url.startswith("data:"):
            raw = base64.b64decode(photo_url.split(",", 1)[1])
        else:
            req = Request(photo_url, headers={"User-Agent": "pytest/1.0"})
            raw = urlopen(req, timeout=15).read()
        im = Image.open(io.BytesIO(raw)).convert("RGB")
        im.thumbnail((640, 640))
        r = requests.post(
            f"{BASE_URL}/attendance/match",
            headers=headers,
            # threshold 0.30 (min allowed) → the exact photo still matches with
            # distance ~0 so this alone won't force a no-match. Instead we use
            # a fully solid-color-with-noise image so no face is detected;
            # already covered by test_no_face_frame. Here we assert the
            # NEGATIVE branch shape when a real face exists but no employee
            # matches. Skip if impossible in seed data.
            json={"image_b64": _b64_of(im), "type": "Check-in", "threshold": 0.30},
            timeout=60,
        )
        assert r.status_code == 200
        body = r.json()
        # With threshold 0.30 the ~0 distance still passes → matched=true.
        # Either outcome is fine; assert schema integrity:
        assert isinstance(body["matches"], list)
        assert isinstance(body["faces_detected"], int)
        if not body["matched"]:
            assert body["employee"] is None
            assert body["attendance"] is None
            for m in body["matches"]:
                assert m["matched"] is False