"""Subject bbox detection for smart cropping.

Priority: mediapipe face detection -> OpenCV Haar cascade face detection
(no model download required, always available with opencv-python) ->
ultralytics YOLOv8n person detection -> full frame (no crop).

All bboxes are returned as (x1, y1, x2, y2) in pixel space, plus a "kind"
string ("face" | "person" | "full_frame") used by crop_resize.py to pick a
padding multiplier.
"""
import cv2
import numpy as np

_mp_detector = None
_mp_unavailable = False
_haar_cascade = None
_yolo_model = None


def _get_mediapipe_detector(min_conf):
    global _mp_detector, _mp_unavailable
    if _mp_unavailable:
        return None
    if _mp_detector is None:
        try:
            import mediapipe as mp
            _mp_detector = mp.solutions.face_detection.FaceDetection(
                model_selection=1, min_detection_confidence=min_conf
            )
        except Exception:
            _mp_unavailable = True
            return None
    return _mp_detector


def _get_haar_cascade():
    global _haar_cascade
    if _haar_cascade is None:
        path = cv2.data.haarcascades + "haarcascade_frontalface_default.xml"
        _haar_cascade = cv2.CascadeClassifier(path)
    return _haar_cascade


def _get_yolo():
    global _yolo_model
    if _yolo_model is None:
        from ultralytics import YOLO
        _yolo_model = YOLO("yolov8n.pt")
    return _yolo_model


def _largest_bbox(candidates):
    """candidates: list of (x1, y1, x2, y2). Returns the largest-area one."""
    if not candidates:
        return None
    return max(candidates, key=lambda b: max(0, b[2] - b[0]) * max(0, b[3] - b[1]))


def _detect_face_mediapipe(image_bgr, min_conf):
    detector = _get_mediapipe_detector(min_conf)
    if detector is None:
        return None
    h, w = image_bgr.shape[:2]
    rgb = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB)
    try:
        results = detector.process(rgb)
    except Exception:
        return None
    if not results.detections:
        return None
    boxes = []
    for det in results.detections:
        rb = det.location_data.relative_bounding_box
        x1, y1 = rb.xmin * w, rb.ymin * h
        x2, y2 = x1 + rb.width * w, y1 + rb.height * h
        boxes.append((x1, y1, x2, y2))
    return _largest_bbox(boxes)


def _detect_face_haar(image_bgr):
    cascade = _get_haar_cascade()
    gray = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2GRAY)
    faces = cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(40, 40))
    if len(faces) == 0:
        return None
    boxes = [(float(x), float(y), float(x + fw), float(y + fh)) for x, y, fw, fh in faces]
    return _largest_bbox(boxes)


def _detect_person_yolo(image_bgr, min_conf):
    try:
        model = _get_yolo()
        results = model.predict(image_bgr, classes=[0], conf=min_conf, verbose=False)
    except Exception:
        return None
    boxes = []
    for r in results:
        if r.boxes is None:
            continue
        for b in r.boxes:
            x1, y1, x2, y2 = b.xyxy[0].tolist()
            boxes.append((x1, y1, x2, y2))
    return _largest_bbox(boxes)


def detect_subject_bbox(image_bgr: np.ndarray, min_face_conf=0.5, min_person_conf=0.35):
    """Returns (bbox, kind) where kind is 'face', 'person', or 'full_frame'."""
    h, w = image_bgr.shape[:2]

    bbox = _detect_face_mediapipe(image_bgr, min_face_conf)
    if bbox:
        return bbox, "face"

    bbox = _detect_face_haar(image_bgr)
    if bbox:
        return bbox, "face"

    bbox = _detect_person_yolo(image_bgr, min_person_conf)
    if bbox:
        return bbox, "person"

    return (0.0, 0.0, float(w), float(h)), "full_frame"


def subdivide_bbox(bbox, region, frac=0.45):
    """Narrows a bbox to its top or bottom portion (by height), same width.

    Used to bias person-kind crops toward a specific body region (e.g. most
    of the frame is a torso/lower-body shot rather than a full figure) without
    needing a specialized body-part detector -- just a fraction of the
    already-detected person bbox. `region` is "upper", "lower", or anything
    else (returned unchanged, e.g. "auto"/"full").
    """
    x1, y1, x2, y2 = bbox
    h = y2 - y1
    if region == "lower":
        return (x1, y2 - h * frac, x2, y2)
    if region == "upper":
        return (x1, y1, x2, y1 + h * frac)
    return bbox