"""Normalization of raw ALPR reads into canonical form. Pure functions, no DB - unit-testable."""

from __future__ import annotations

import hashlib

import re

from dataclasses import dataclass, field

from datetime import datetime, timezone

from dateutil import parser as dtparser

_PLATE_STRIP = re.compile(r"[^A-Z0-9]")

_DIRECTIONS = {"N", "NE", "E", "SE", "S", "SW", "W", "NW"}

_DIR_WORDS = {

    "north": "N", "northeast": "NE", "east": "E", "southeast": "SE",

    "south": "S", "southwest": "SW", "west": "W", "northwest": "NW",

    "nb": "N", "eb": "E", "sb": "S", "wb": "W",

}

COLUMN_ALIASES: dict[str, list[str]] = {

    "plate": ["plate", "license_plate", "licenseplate", "lp", "tag", "plate_number", "platenumber"],

    "state": ["state", "plate_state", "region", "jurisdiction_state"],

    "read_ts": ["timestamp", "read_time", "captured_at", "datetime", "time", "date_time", "observed_at"],

    "camera": ["camera", "camera_id", "device_id", "cam", "device", "sensor", "camera_name"],

    "lat": ["lat", "latitude", "gps_lat", "y"],

    "lon": ["lon", "lng", "longitude", "gps_lon", "x"],

    "direction": ["direction", "heading", "travel_direction", "bearing", "dir"],

    "confidence": ["confidence", "score", "match_confidence", "ocr_confidence"],

    "lane": ["lane", "lane_id"],

    "make": ["make", "vehicle_make"],

    "model": ["model", "vehicle_model"],

    "color": ["color", "colour", "vehicle_color"],

    "body_type": ["body", "body_type", "vehicle_type", "type"],

    "hotlist": ["hotlist", "hotlist_hit", "hit", "alert", "watchlist"],

    "incident": ["incident", "incident_id", "case", "case_id", "incident_ref"],

}

@dataclass

class RawRead:

    """One row as emitted by a parser, before normalization."""

    fields: dict

    source_row: int = 0

@dataclass

class NormalizedRead:

    plate_raw: str

    plate_norm: str

    state: str | None

    read_ts: datetime

    external_camera_id: str | None

    lat: float | None

    lon: float | None

    direction: str | None

    confidence: float | None

    lane: str | None

    make: str | None = None

    model: str | None = None

    color: str | None = None

    body_type: str | None = None

    hotlist_hit: bool = False

    incident_ref: str | None = None

    raw: dict = field(default_factory=dict)

def build_alias_map(headers: list[str]) -> dict[str, str]:

    """Map canonical field -> actual header present in the file (first match wins)."""

    lowered = {h.lower().strip(): h for h in headers}

    out: dict[str, str] = {}

    for canon, aliases in COLUMN_ALIASES.items():

        for a in aliases:

            if a in lowered:

                out[canon] = lowered[a]

                break

    return out

def normalize_plate(value: str | None) -> str:

    if not value:

        return ""

    return _PLATE_STRIP.sub("", str(value).upper())

def normalize_timestamp(value, source_tz: timezone = timezone.utc) -> datetime | None:

    if value in (None, ""):

        return None

    if isinstance(value, datetime):

        dt = value

    else:

        try:

            dt = dtparser.parse(str(value))

        except (ValueError, OverflowError, TypeError):

            return None

    if dt.tzinfo is None:

        dt = dt.replace(tzinfo=source_tz)

    return dt.astimezone(timezone.utc)

def normalize_direction(value) -> str | None:

    if value in (None, ""):

        return None

    s = str(value).strip().upper()

    if s in _DIRECTIONS:

        return s

    return _DIR_WORDS.get(str(value).strip().lower())

def normalize_confidence(value) -> float | None:

    if value in (None, ""):

        return None

    try:

        f = float(value)

    except (ValueError, TypeError):

        return None

    if f > 1.0:

        f = f / 100.0

    return max(0.0, min(1.0, f))

def _to_float(value) -> float | None:

    try:

        f = float(value)

        return f

    except (ValueError, TypeError):

        return None

def _valid_coord(lat: float | None, lon: float | None) -> tuple[float | None, float | None]:

    if lat is None or lon is None:

        return None, None

    if -90 <= lat <= 90 and -180 <= lon <= 180 and not (lat == 0 and lon == 0):

        return lat, lon

    return None, None

def _truthy(value) -> bool:

    return str(value).strip().lower() in {"1", "true", "yes", "y", "hit", "hotlist"}

def normalize_read(raw: RawRead, alias: dict[str, str], source_tz: timezone = timezone.utc) -> NormalizedRead | None:

    """Project a raw row onto canonical fields. Returns None if no usable plate+timestamp."""

    f = raw.fields

    def g(canon: str):

        col = alias.get(canon)

        return f.get(col) if col else None

    plate_raw = str(g("plate") or "").strip()

    plate_norm = normalize_plate(plate_raw)

    read_ts = normalize_timestamp(g("read_ts"), source_tz)

    if not plate_norm or read_ts is None:

        return None

    lat, lon = _valid_coord(_to_float(g("lat")), _to_float(g("lon")))

    return NormalizedRead(

        plate_raw=plate_raw,

        plate_norm=plate_norm,

        state=(str(g("state")).strip().upper() or None) if g("state") else None,

        read_ts=read_ts,

        external_camera_id=(str(g("camera")).strip() or None) if g("camera") else None,

        lat=lat,

        lon=lon,

        direction=normalize_direction(g("direction")),

        confidence=normalize_confidence(g("confidence")),

        lane=(str(g("lane")).strip() or None) if g("lane") else None,

        make=(str(g("make")).strip() or None) if g("make") else None,

        model=(str(g("model")).strip() or None) if g("model") else None,

        color=(str(g("color")).strip() or None) if g("color") else None,

        body_type=(str(g("body_type")).strip() or None) if g("body_type") else None,

        hotlist_hit=_truthy(g("hotlist")) if g("hotlist") is not None else False,

        incident_ref=(str(g("incident")).strip() or None) if g("incident") else None,

        raw=f,

    )

def dedup_hash(org: str, plate_norm: str, camera_id: str | None, read_ts: datetime,

               window_seconds: int = 1) -> bytes:

    """Stable key for idempotent ingest. Timestamp is bucketed so sub-window bursts collapse."""

    epoch = int(read_ts.timestamp())

    bucket = epoch - (epoch % max(1, window_seconds))

    key = f"{org}|{plate_norm}|{camera_id or '-'}|{bucket}"

    return hashlib.sha256(key.encode()).digest()