Multi-Channel Sync Challenges Between
Mercado Libre and Shopify

import threading
from dataclasses import dataclass, field
from typing import Literal

# In-process committed counter — back with Redis in production
_committed: dict[str, int] = {}
_lock = threading.Lock()

SAFETY_BUFFER = 5    # base buffer — never pushed
MELI_EXTRA    = 2    # extra for MELI's slower ack loop

def on_sale(sku: str, qty_sold: int, source: Literal["meli", "shopify"]):
    """
    Called immediately on any order webhook from either channel.
    Decrements committed counter and pushes updated qty to the OTHER channel.
    """
    with _lock:
        _committed[sku] = _committed.get(sku, 0) + qty_sold

    # Pull fresh available qty from Odoo (authoritative source)
    odoo_available = get_odoo_available(sku)

    # Net available = Odoo stock minus all uncommitted sales across channels
    net_available = max(0, odoo_available - _committed.get(sku, 0))

    # Push to the OTHER channel — the one that just sold already decremented itself
    if source == "meli":
        # Sale on MELI → update Shopify immediately
        shopify_qty = max(0, net_available - SAFETY_BUFFER)
        shopify_set_inventory(sku=sku, qty=shopify_qty)
    else:
        # Sale on Shopify → update MELI immediately
        meli_qty = max(0, net_available - SAFETY_BUFFER - MELI_EXTRA)
        meli_update_stock(sku=sku, qty=meli_qty)

def scheduled_full_sync(sku: str):
    """
    Runs every 15 min — reconciles committed counter against ERP reality.
    Clears drift from any sales that bypassed the event-driven path.
    """
    odoo_available = get_odoo_available(sku)
    with _lock:
        _committed[sku] = 0   # reset — ERP is now the single source of truth

    shopify_qty = max(0, odoo_available - SAFETY_BUFFER)
    meli_qty    = max(0, odoo_available - SAFETY_BUFFER - MELI_EXTRA)

    shopify_set_inventory(sku=sku, qty=shopify_qty)
    meli_update_stock(sku=sku, qty=meli_qty)

def daily_sku_mapping_audit() -> list[dict]:
    """
    Compares SKU mapping tables across MELI, Shopify, and Odoo.
    Returns list of discrepancies for ops team review.
    """
    models, uid = odoo_connect()
    issues = []

    # Get all Odoo products that have MELI mapping
    odoo_products = models.execute_kw(ODOO_DB, uid, ODOO_KEY,
        "product.template", "search_read",
        [[("x_meli_item_id", "!=", False), ("active", "=", True)]],
        {"fields": ["id", "name", "default_code", "x_meli_item_id", "x_meli_site_id"]}
    )

    for prod in odoo_products:
        meli_id  = prod["x_meli_item_id"]
        site_id  = prod["x_meli_site_id"]

        # 1. Check MELI item still exists and is active
        try:
            item = meli_get(f"/items/{meli_id}", site_id=site_id)
            if item.get("status") != "active":
                issues.append({
                    "sku":     prod["default_code"],
                    "issue":   "MELI item not active",
                    "detail":  f"Status: {item.get('status')} on {site_id}",
                })
        except Exception as e:
            issues.append({
                "sku":     prod["default_code"],
                "issue":   "MELI item not found",
                "detail":  f"item_id {meli_id} returned error: {e}",
            })

        # 2. Check Shopify variant exists with matching SKU
        shopify_variants = shopify_find_variant_by_sku(prod["default_code"])
        if not shopify_variants:
            issues.append({
                "sku":     prod["default_code"],
                "issue":   "Shopify variant not found",
                "detail":  f"No Shopify variant with sku={prod['default_code']}",
            })

    return sorted(issues, key=lambda x: x["issue"])

def get_shopify_safe_qty(sku: str, odoo_wh_id: int, meli_full_location_id: int) -> int:
    """
    Returns the quantity that is safe to show on Shopify:
    - On-hand at YOUR warehouse (not MELI FULL FC)
    - Minus reserved for open orders
    - Minus safety buffer
    Never includes stock at MELI FULL locations.
    """
    models, uid = odoo_connect()

    # Warehouse stock (excludes MELI FULL location)
    warehouse_quants = models.execute_kw(ODOO_DB, uid, ODOO_KEY,
        "stock.quant", "search_read",
        [[
            ("product_id.default_code", "=", sku),
            ("location_id.usage", "=", "internal"),
            ("location_id.warehouse_id", "=", odoo_wh_id),
            ("location_id", "!=", meli_full_location_id),   # exclude FULL
        ]],
        {"fields": ["quantity", "reserved_quantity"]}
    )
    warehouse_available = sum(
        q["quantity"] - q["reserved_quantity"] for q in warehouse_quants
    )

    # MELI FULL stock (read-only — used for MELI sync only, NEVER for Shopify)
    full_quants = models.execute_kw(ODOO_DB, uid, ODOO_KEY,
        "stock.quant", "search_read",
        [[("product_id.default_code", "=", sku),
          ("location_id", "=", meli_full_location_id)]],
        {"fields": ["quantity"]}
    )
    full_qty = sum(q["quantity"] for q in full_quants)

    # Log the split for ops visibility
    log_inventory_split(sku=sku, warehouse=warehouse_available, meli_full=full_qty)

    return max(0, int(warehouse_available) - SAFETY_BUFFER)