"""Compare Magento product data with Pie (DB) product data."""

from __future__ import annotations

from typing import Any, Dict, List


def _flatten_value(v: Any) -> str:
    if v is None:
        return ""
    if isinstance(v, bool):
        return "1" if v else "0"
    if isinstance(v, (list, dict)):
        import json
        return json.dumps(v, default=str)
    return str(v)


def flatten_magento_product(product: Dict[str, Any]) -> Dict[str, Any]:
    """Flatten Magento product to key->value. Expands custom_attributes, stock_item, etc."""
    out: Dict[str, Any] = {}
    if not product:
        return out

    for k, v in product.items():
        if k == "custom_attributes" and isinstance(v, list):
            for attr in v:
                if isinstance(attr, dict):
                    code = attr.get("attribute_code")
                    val = attr.get("value")
                    if code:
                        out[code] = _flatten_value(val)
        elif k == "extension_attributes" and isinstance(v, dict):
            stock = v.get("stock_item")
            if isinstance(stock, dict):
                for sk, sv in stock.items():
                    out[f"stock_{sk}"] = _flatten_value(sv)
            for ek, ev in v.items():
                if ek != "stock_item":
                    out[ek] = _flatten_value(ev)
        elif k not in ("media_gallery_entries", "options", "product_links", "bundle_options"):
            out[k] = _flatten_value(v)
    return out


def flatten_pie_product(
    snapshot: Dict[str, Any],
    prices: Dict[str, Dict[str, Any]],
    overrides: Dict[str, Dict[str, str]],
) -> Dict[str, Any]:
    """Flatten Pie product (snapshot + attrs + prices + overrides) to key->value."""
    out: Dict[str, Any] = {}
    attrs = snapshot.get("attrs") or {}
    base = {k: v for k, v in snapshot.items() if k not in ("attrs", "id")}
    for k, v in {**attrs, **base}.items():
        out[k] = _flatten_value(v)
    sku = str(snapshot.get("sku", "")).strip()
    if sku:
        if sku in prices:
            for pk, pv in prices[sku].items():
                out[pk] = _flatten_value(pv)
        if sku in overrides:
            for ok, ov in overrides[sku].items():
                out[ok] = _flatten_value(ov)
    return out


def build_comparison(
    magento_flat: Dict[str, Any],
    pie_flat: Dict[str, Any],
) -> Dict[str, str]:
    """
    Build side-by-side comparison: { "field:Magento": "xxx", "field:Pie": "xxx" }.
    Includes all fields from both sides; missing side gets empty string.
    """
    all_keys = set(magento_flat.keys()) | set(pie_flat.keys())
    result: Dict[str, str] = {}
    for key in sorted(all_keys):
        mag_val = str(magento_flat.get(key, "") or "")
        pie_val = str(pie_flat.get(key, "") or "")
        result[f"{key}:Magento"] = mag_val
        result[f"{key}:Pie"] = pie_val
    return result