"""Inspect configurable parent duplicate axis signatures from master DB.

Examples:
    python -m app.jobs.debug_configurable_duplicates --sku GSW-BBC-PARENT
    python -m app.jobs.debug_configurable_duplicates --sku GSW-BBC-PARENT --sku GSW-DB-PARENT
"""

from __future__ import annotations

import argparse
import json
from typing import Any, Dict, List

from sqlalchemy import select

from db.models import MasterProduct, MasterProductRelation
from db.session import get_session
from magento.sync_hashes import _parse_children_from_row
from magento.sync_service import _duplicate_axis_signatures


def inspect_parent(session, sku: str) -> Dict[str, Any]:
    parent = session.scalar(
        select(MasterProduct).where(MasterProduct.sku == str(sku).strip()).limit(1)
    )
    if parent is None:
        return {"sku": sku, "status": "missing"}

    payload = dict(parent.raw_payload or {})
    payload.setdefault("sku", parent.sku)
    payload.setdefault("name", parent.name)
    product_type = getattr(parent, "product_type", None)
    if product_type is None:
        product_type = getattr(parent, "product_type_id", None)
    payload.setdefault("product_type", product_type)

    children, mappings, child_to_mapping = _parse_children_from_row(payload)
    attr_codes = sorted(
        {
            str(key or "").strip().lower()
            for mapping in mappings
            for key in dict(mapping or {}).keys()
            if str(key or "").strip() and str(key or "").strip().lower() != "sku"
        }
    )

    relation_rows = session.scalars(
        select(MasterProductRelation)
        .where(MasterProductRelation.parent_sku == parent.sku)
        .order_by(MasterProductRelation.sort_order, MasterProductRelation.id)
    ).all()
    relation_mappings = {
        str(row.child_sku or "").strip(): {
            str(key or "").strip().lower(): str(value or "").strip()
            for key, value in dict(row.option_mapping or {}).items()
            if str(key or "").strip()
        }
        for row in relation_rows
        if str(row.child_sku or "").strip()
    }
    if relation_mappings:
        child_to_mapping = {**child_to_mapping, **relation_mappings}
        relation_attr_codes = {
            str(key or "").strip().lower()
            for mapping in relation_mappings.values()
            for key in mapping.keys()
            if str(key or "").strip()
        }
        attr_codes = sorted(set(attr_codes) | relation_attr_codes)
        if not children:
            children = list(relation_mappings.keys())

    duplicates = _duplicate_axis_signatures(children, mappings, attr_codes, child_to_mapping)

    return {
        "sku": parent.sku,
        "name": parent.name,
        "product_type": product_type,
        "configurable_attributes": payload.get("configurable_attributes"),
        "configurable_variations": payload.get("configurable_variations"),
        "child_count": len(children),
        "children": children,
        "axis_codes": attr_codes,
        "child_mappings": child_to_mapping,
        "duplicate_axis_signatures": duplicates,
        "status": "ok",
    }


def main() -> int:
    parser = argparse.ArgumentParser(description="Debug configurable duplicate axis signatures")
    parser.add_argument("--sku", action="append", required=True, help="Parent SKU to inspect; repeatable")
    args = parser.parse_args()

    with get_session() as session:
        report: List[Dict[str, Any]] = [inspect_parent(session, sku) for sku in args.sku]

    print(json.dumps(report, indent=2, default=str))
    return 0


if __name__ == "__main__":
    raise SystemExit(main())