"""Helpers for canonical normalized location registry seeding and lookup."""

from __future__ import annotations

from typing import Any, Dict, Iterable, List, Optional

from sqlalchemy import select
from sqlalchemy.orm import Session

from db.models import MasterBrand, MasterLocationRegistry


DEFAULT_HOME_SURPLUS_LOCATIONS: List[Dict[str, Any]] = [
    {
        "code": "1",
        "name": "Keyport Warehouse",
        "location_kind": "warehouse",
        "aliases": {
            "labels": ["Keyport", "Keyport Warehouse"],
            "is_default": True,
            "geo": {"latitude": 40.4337, "longitude": -74.1996},
            "address": {"city": "Keyport", "state": "NJ", "country": "US"},
        },
        "notes": "Default Home Surplus pickup location",
    },
    {
        "code": "2",
        "name": "Bellmawr Warehouse",
        "location_kind": "warehouse",
        "aliases": {
            "labels": ["Bellmawr", "Bellmawr Warehouse"],
            "geo": {"latitude": 39.8676, "longitude": -75.0946},
            "address": {"city": "Bellmawr", "state": "NJ", "country": "US"},
        },
        "notes": "Default Home Surplus pickup location",
    },
    {
        "code": "3",
        "name": "North Bergen Warehouse",
        "location_kind": "warehouse",
        "aliases": {
            "labels": ["North Bergen", "North Bergen Warehouse"],
            "geo": {"latitude": 40.8043, "longitude": -74.0121},
            "address": {"city": "North Bergen", "state": "NJ", "country": "US"},
        },
        "notes": "Default Home Surplus pickup location",
    },
    {
        "code": "10",
        "name": "Brentwood Warehouse",
        "location_kind": "warehouse",
        "aliases": {
            "labels": ["Brentwood", "Brentwood Warehouse"],
            "geo": {"latitude": 40.7812, "longitude": -73.2462},
            "address": {"city": "Brentwood", "state": "NY", "country": "US"},
        },
        "notes": "Default Home Surplus pickup location",
    },
    {
        "code": "12",
        "name": "Baltimore Warehouse",
        "location_kind": "warehouse",
        "aliases": {
            "labels": ["Baltimore", "Baltimore Warehouse"],
            "geo": {"latitude": 39.2904, "longitude": -76.6122},
            "address": {"city": "Baltimore", "state": "MD", "country": "US"},
        },
        "notes": "Default Home Surplus pickup location",
    },
    {
        "code": "43",
        "name": "Tampa Warehouse",
        "location_kind": "warehouse",
        "aliases": {
            "labels": ["Tampa", "Tampa Warehouse"],
            "geo": {"latitude": 27.9506, "longitude": -82.4572},
            "address": {"city": "Tampa", "state": "FL", "country": "US"},
        },
        "notes": "Default Home Surplus pickup location",
    },
]


def ensure_default_home_surplus_locations(session: Session, *, brand_label: Optional[str] = "Port & Bell") -> Dict[str, Any]:
    return upsert_master_locations(session, DEFAULT_HOME_SURPLUS_LOCATIONS, brand_label=brand_label)


def upsert_master_locations(
    session: Session,
    items: Iterable[Dict[str, Any]],
    *,
    brand_label: Optional[str] = None,
) -> Dict[str, Any]:
    brand_id = _brand_id(session, brand_label)
    upserted = 0
    codes: List[str] = []
    for item in items:
        code = _clean_str(item.get("code"))
        name = _clean_str(item.get("name"))
        if not code or not name:
            raise ValueError("Each location requires code and name")
        row = session.scalar(select(MasterLocationRegistry).where(MasterLocationRegistry.code == code))
        if row is None:
            row = MasterLocationRegistry(code=code, name=name, is_active=True)
            session.add(row)
        row.name = name
        row.location_kind = _clean_str(item.get("location_kind")) or "warehouse"
        row.brand_id = item.get("brand_id") or brand_id
        row.channel_code = _clean_str(item.get("channel_code"))
        row.connection_id = item.get("connection_id")
        row.aliases = item.get("aliases") if isinstance(item.get("aliases"), dict) else {"labels": [name]}
        row.is_active = bool(item.get("is_active", True))
        row.notes = _clean_str(item.get("notes"))
        upserted += 1
        codes.append(code)
    session.flush()
    return {"upserted": upserted, "codes": codes}


def active_location_directory(session: Session) -> List[Dict[str, Any]]:
    rows = session.scalars(
        select(MasterLocationRegistry)
        .where(MasterLocationRegistry.is_active.is_(True))
        .order_by(MasterLocationRegistry.name, MasterLocationRegistry.code)
    ).all()
    return [serialize_location(row) for row in rows]


def serialize_location(row: MasterLocationRegistry) -> Dict[str, Any]:
    aliases = row.aliases if isinstance(row.aliases, dict) else {}
    return {
        "id": row.id,
        "code": row.code,
        "name": row.name,
        "location_kind": row.location_kind,
        "aliases": aliases,
        "labels": [str(item).strip() for item in aliases.get("labels", []) if str(item).strip()],
        "is_default": bool(aliases.get("is_default")),
        "geo": aliases.get("geo") if isinstance(aliases.get("geo"), dict) else None,
        "address": aliases.get("address") if isinstance(aliases.get("address"), dict) else None,
    }


def _brand_id(session: Session, brand_label: Optional[str]) -> Optional[int]:
    if not brand_label:
        return None
    brand = session.scalar(select(MasterBrand).where(MasterBrand.name == brand_label))
    return brand.id if brand is not None else None


def _clean_str(value: Any) -> Optional[str]:
    if value is None:
        return None
    text = str(value).strip()
    return text or None