"""
Face recognition: crop face from person bbox, embed, match known people.
Known faces: put images in known_faces/ as name.jpg (e.g. danny.jpg).
Encodings cached in known_faces/encodings.pkl.
"""

from pathlib import Path
from typing import List, Optional, Tuple
import pickle
import logging

import cv2
import numpy as np

try:
    import face_recognition
    HAS_FACE_RECOGNITION = True
except ImportError:
    HAS_FACE_RECOGNITION = False

logger = logging.getLogger("smartdoor.recognizer")

DEFAULT_TOLERANCE = 0.5


class FaceRecognizer:
    def __init__(self, known_faces_dir, tolerance=DEFAULT_TOLERANCE):
        self.known_faces_dir = Path(known_faces_dir)
        self.tolerance = tolerance
        self._encodings_by_name = {}
        self._loaded = False
        self._load_known_faces()

    def _load_known_faces(self):
        if not HAS_FACE_RECOGNITION:
            logger.warning("face_recognition not installed; face recognition disabled")
            return
        cache = self.known_faces_dir / "encodings.pkl"
        if cache.exists():
            try:
                with open(cache, "rb") as f:
                    self._encodings_by_name = pickle.load(f)
                self._loaded = True
                logger.info("Loaded %d known people from cache", len(self._encodings_by_name))
                return
            except Exception as e:
                logger.warning("Could not load encodings cache: %s", e)
        self._encodings_by_name = {}
        for path in self.known_faces_dir.glob("*.jpg"):
            name = path.stem
            encodings = self._encode_image(path)
            if encodings:
                self._encodings_by_name[name] = encodings
                logger.info("Registered %s from %s", name, path.name)
        if self._encodings_by_name:
            self.known_faces_dir.mkdir(parents=True, exist_ok=True)
            try:
                with open(cache, "wb") as f:
                    pickle.dump(self._encodings_by_name, f)
            except Exception as e:
                logger.warning("Could not save encodings cache: %s", e)
        self._loaded = bool(self._encodings_by_name)

    def _encode_image(self, path):
        if not HAS_FACE_RECOGNITION:
            return []
        img = face_recognition.load_image_file(str(path))
        encodings = face_recognition.face_encodings(img)
        return list(encodings)

    def _encode_bgr(self, bgr_frame):
        if not HAS_FACE_RECOGNITION:
            return []
        rgb = cv2.cvtColor(bgr_frame, cv2.COLOR_BGR2RGB)
        encodings = face_recognition.face_encodings(rgb)
        return list(encodings)

    def recognize_face(self, face_crop_bgr):
        if not HAS_FACE_RECOGNITION or not self._encodings_by_name:
            return None
        encodings = self._encode_bgr(face_crop_bgr)
        if not encodings:
            return None
        query = encodings[0]
        for name, known_list in self._encodings_by_name.items():
            matches = face_recognition.compare_faces(
                known_list, query, tolerance=self.tolerance
            )
            if any(matches):
                return name
        return None

    def recognize_faces_in_frame(self, frame_bgr, person_boxes):
        results = []
        if not HAS_FACE_RECOGNITION or not self._encodings_by_name:
            return results
        for (x1, y1, x2, y2) in person_boxes:
            x1, y1, x2, y2 = int(x1), int(y1), int(x2), int(y2)
            h, w = frame_bgr.shape[:2]
            pad = 0.1
            pw = int((x2 - x1) * pad)
            ph = int((y2 - y1) * pad)
            x1 = max(0, x1 - pw)
            y1 = max(0, y1 - ph)
            x2 = min(w, x2 + pw)
            y2 = min(h, y2 + ph)
            crop = frame_bgr[y1:y2, x1:x2]
            if crop.size == 0:
                results.append(((x1, y1, x2, y2), None))
                continue
            rgb_crop = cv2.cvtColor(crop, cv2.COLOR_BGR2RGB)
            face_locs = face_recognition.face_locations(rgb_crop, model="hog")
            if not face_locs:
                results.append(((x1, y1, x2, y2), None))
                continue
            t, r, b, l = face_locs[0]
            face_crop = crop[t:b, l:r]
            if face_crop.size == 0:
                results.append(((x1, y1, x2, y2), None))
                continue
            name = self.recognize_face(face_crop)
            fx1 = x1 + l
            fy1 = y1 + t
            fx2 = x1 + r
            fy2 = y1 + b
            results.append(((fx1, fy1, fx2, fy2), name))
        return results

    @property
    def is_available(self):
        return HAS_FACE_RECOGNITION and self._loaded