"""OpenCV and image conversion helpers used by the CALY pipeline."""

from __future__ import annotations

from pathlib import Path
from typing import Iterable, Sequence

import cv2
import numpy as np
from PIL import Image


def read_image_bgr(image_path: str | Path) -> np.ndarray:
    """Read an image from disk as BGR and raise a useful error on failure."""

    image = cv2.imread(str(image_path), cv2.IMREAD_COLOR)
    if image is None:
        raise ValueError(f"Could not read image: {image_path}")
    return image


def decode_image_bytes(content: bytes) -> np.ndarray:
    """Decode uploaded image bytes into a BGR OpenCV array."""

    if not content:
        raise ValueError("Uploaded image is empty")
    data = np.frombuffer(content, dtype=np.uint8)
    image = cv2.imdecode(data, cv2.IMREAD_COLOR)
    if image is None:
        raise ValueError("Uploaded file is not a valid image")
    return image


def bgr_to_rgb(image: np.ndarray) -> np.ndarray:
    """Convert a BGR OpenCV image to RGB."""

    return cv2.cvtColor(image, cv2.COLOR_BGR2RGB)


def bgr_to_pil(image: np.ndarray) -> Image.Image:
    """Convert a BGR OpenCV image to a PIL RGB image."""

    return Image.fromarray(bgr_to_rgb(image))


def polygon_to_mask(
    polygon: np.ndarray | None,
    shape: tuple[int, int],
    fallback_bbox: Sequence[float] | None = None,
) -> np.ndarray:
    """Rasterize a polygon to a binary mask, optionally using a bbox fallback."""

    height, width = shape
    mask = np.zeros((height, width), dtype=np.uint8)
    if polygon is not None and len(polygon) >= 3:
        cv2.fillPoly(mask, [np.asarray(polygon, dtype=np.int32)], 1)
        return mask
    if fallback_bbox is not None:
        x1, y1, x2, y2 = [int(round(v)) for v in fallback_bbox]
        x1, y1 = max(0, x1), max(0, y1)
        x2, y2 = min(width, x2), min(height, y2)
        if x2 > x1 and y2 > y1:
            mask[y1:y2, x1:x2] = 1
    return mask


def resize_mask(mask: np.ndarray, shape: tuple[int, int], threshold: float = 0.5) -> np.ndarray:
    """Resize a mask to ``(height, width)`` and return a boolean mask."""

    height, width = shape
    resized = cv2.resize(mask.astype(np.float32), (width, height), interpolation=cv2.INTER_LINEAR)
    return resized > threshold


def draw_mask_overlay(
    image_rgb: np.ndarray,
    mask: np.ndarray,
    color: tuple[int, int, int],
    alpha: float = 0.45,
) -> np.ndarray:
    """Return a copy of ``image_rgb`` with a colored transparent mask overlay."""

    output = image_rgb.copy()
    mask_bool = mask.astype(bool)
    overlay = np.zeros_like(output)
    overlay[:, :] = np.asarray(color, dtype=np.uint8)
    output[mask_bool] = (
        output[mask_bool].astype(np.float32) * (1.0 - alpha)
        + overlay[mask_bool].astype(np.float32) * alpha
    ).astype(np.uint8)
    return output


def estimate_plate_diameter_pixels(
    gray_image: np.ndarray,
    food_boxes: Iterable[Sequence[float]],
    image_width: int,
    image_height: int,
) -> float:
    """Estimate plate diameter from Hough circles, falling back to food extent."""

    blurred = cv2.GaussianBlur(gray_image, (9, 9), 1.5)
    min_dim = min(image_width, image_height)
    circles = cv2.HoughCircles(
        blurred,
        cv2.HOUGH_GRADIENT,
        dp=1.2,
        minDist=max(40, min_dim // 3),
        param1=90,
        param2=28,
        minRadius=max(20, int(min_dim * 0.18)),
        maxRadius=int(min_dim * 0.55),
    )
    if circles is not None and len(circles[0]) > 0:
        circles = np.round(circles[0]).astype(int)
        center = np.array([image_width / 2.0, image_height / 2.0])
        best = min(circles, key=lambda c: np.linalg.norm(np.array([c[0], c[1]]) - center))
        return float(best[2] * 2)

    boxes = list(food_boxes)
    if boxes:
        arr = np.asarray(boxes, dtype=np.float32)
        width = float(arr[:, 2].max() - arr[:, 0].min())
        height = float(arr[:, 3].max() - arr[:, 1].min())
        return max(width, height) * 1.35

    return float(min_dim * 0.80)