"""ALPR recognition engine: image/video frame -> license plate number(s).

Uses fast-alpr (open-source): an ONNX YOLO plate detector + an ONNX plate-OCR model, CPU-only.

Models download once on first use. This is the 'algorithm' - it turns pixels into plate strings;

the existing normalize/dedup/watchlist pipeline turns those strings into intelligence.

Recognized plates from real images are REAL reads. Provide images you are authorized to process.

"""

from __future__ import annotations

import os

import threading

from dataclasses import dataclass

os.environ.setdefault("OMP_NUM_THREADS", "2")

import numpy as np

_alpr = None

_lock = threading.Lock()

def _engine():

    """Lazily construct the ALPR engine (downloads ONNX models on first call)."""

    global _alpr

    if _alpr is None:

        with _lock:

            if _alpr is None:

                from fast_alpr import ALPR

                _alpr = ALPR(

                    detector_model="yolo-v9-t-384-license-plate-end2end",

                    ocr_model="global-plates-mobile-vit-v2-model",

                )

    return _alpr

@dataclass

class PlateDetection:

    plate: str

    plate_norm: str

    detection_confidence: float

    ocr_confidence: float

    bbox: list[int]

def _norm(s: str) -> str:

    return "".join(ch for ch in (s or "").upper() if ch.isalnum())

def _scalar_conf(c) -> float:

    """OCR confidence may be a per-character list; collapse to a single mean score."""

    try:

        if isinstance(c, (list, tuple, np.ndarray)):

            vals = [float(x) for x in c if x is not None]

            return float(sum(vals) / len(vals)) if vals else 0.0

        return float(c)

    except (TypeError, ValueError):

        return 0.0

def recognize_array(img_bgr: np.ndarray, min_conf: float = 0.4) -> list[PlateDetection]:

    results = _engine().predict(img_bgr)

    out: list[PlateDetection] = []

    for r in results:

        det = getattr(r, "detection", None)

        ocr = getattr(r, "ocr", None)

        text = (ocr.text if ocr else "") or ""

        oconf = _scalar_conf(ocr.confidence) if (ocr and ocr.confidence is not None) else 0.0

        dconf = float(det.confidence) if det and det.confidence is not None else 0.0

        bb = det.bounding_box if det else None

        bbox = [int(bb.x1), int(bb.y1), int(bb.x2), int(bb.y2)] if bb else []

        norm = _norm(text)

        if not norm or oconf < min_conf:

            continue

        out.append(PlateDetection(plate=text.strip(), plate_norm=norm,

                                  detection_confidence=dconf, ocr_confidence=oconf, bbox=bbox))

    return out

def recognize_bytes(data: bytes, min_conf: float = 0.4) -> list[PlateDetection]:

    import cv2

    arr = np.frombuffer(data, dtype=np.uint8)

    img = cv2.imdecode(arr, cv2.IMREAD_COLOR)

    if img is None:

        raise ValueError("could not decode image")

    return recognize_array(img, min_conf=min_conf)