# apps/wp_invoices_app/integrations/tax_lookup.py
from typing import Dict, Any, Optional

from apps.abn_lookup_app.core import lookup_abn_basic


def _get_nested(d: Dict[str, Any], *path: str) -> Any:
    """
    Helper sencillo para navegar dicts anidados.
    _get_nested(extracted, "invoice", "seller", "abn", "computed")
    """
    current: Any = d
    for key in path:
        if not isinstance(current, dict):
            return None
        current = current.get(key)
    return current


def _extract_best_value(field: Dict[str, Any]) -> Optional[str]:
    """
    Con tu estructura típica:
    {
      "verbatim": "...",
      "computed": "...",
      ...
    }
    Tomamos prioridad: computed > verbatim.
    """
    if not isinstance(field, dict):
        return None
    value = field.get("computed") or field.get("verbatim")
    if not value:
        return None
    return str(value).strip() or None


def _get_seller_abn_from_extracted(extracted: Dict[str, Any]) -> Optional[str]:
    """
    Intenta obtener el ABN del proveedor desde 'extracted'.

    Ajusta las rutas según tu JSON real. Dejo varias opciones típicas:
    - invoice.seller.abn
    - invoice.seller.tax_id
    """
    invoice = extracted.get("invoice") or {}
    header = extracted.get("header") or {}
    supplier = header.get("supplier")

    # Opción 1: seller["abn"]
    abn_field = supplier.get("abn")
    abn = _extract_best_value(abn_field) if abn_field else None

    # Opción 2: seller["tax_id"] (por si usas un campo genérico)
    if not abn:
        tax_id_field = supplier.get("tax_id")
        abn = _extract_best_value(tax_id_field) if tax_id_field else None

    if not abn:
        return None

    # Limpiamos espacios por si vienen con separadores
    abn = abn.replace(" ", "").strip()
    abn = abn.replace("ABN#","").strip()
    print("business extracted?")
    print(abn)
    return abn or None


def _get_seller_country_from_extracted(extracted: Dict[str, Any]) -> str:
    """
    Intenta obtener el país del proveedor. Si no encuentra nada, usa 'AU' por defecto.
    """
    invoice = extracted.get("invoice") or {}
    seller = invoice.get("seller") or {}

    country_field = seller.get("country")
    country = _extract_best_value(country_field) if country_field else None

    if not country:
        return "AU"
    return str(country).strip() or "AU"


def run_basic_tax_lookup(extracted: Dict[str, Any]) -> Optional[Dict[str, Any]]:
    """
    Ejecuta el lookup básico (V0) si la factura tiene un ABN de Australia.
    Devuelve un dict listo para meterse en checks["tax_lookup_basic"],
    o None si no se debe ejecutar.
    """
    country = _get_seller_country_from_extracted(extracted)
    if country.upper() not in ("AU", "AUS", "AUSTRALIA"):
        return None

    abn = _get_seller_abn_from_extracted(extracted)
    if not abn:
        return None

    basic = lookup_abn_basic(abn)

    # Siempre devolvemos algo estructurado, incluso si abn_exists = False
    return {
        "service": basic.get("service", "abn_lookup"),
        "version": basic.get("version", 0),
        "country": basic.get("country", "AU"),
        "tax_id_type": basic.get("tax_id_type", "ABN"),
        "tax_id": basic.get("tax_id", abn),
        "abn_exists": bool(basic.get("abn_exists")),
        "is_active": bool(basic.get("is_active")),
        "gst_registered": bool(basic.get("gst_registered")),
        "entity_name": basic.get("entity_name"),
    }