Shopify + Amazon + ERP:
Choosing a System of Record

SAFETY_BUFFER  = 5   # never push 100% of available
AMAZON_EXTRA   = 3   # FBM-specific extra buffer — FBA is read-only

def push_inventory_all_channels(sku: str, odoo_wh_id: int,
                                   shopify_variant_id: int, shopify_location_id: int,
                                   amazon_seller_sku: str, is_fbm: bool):
    """
    Reads authoritative qty from Odoo and pushes to all channels.
    FBA listings are NEVER pushed to — Amazon manages FBA qty.
    """
    models, uid = odoo_connect()

    # Step 1: Get Odoo available qty at selling warehouse (excludes FBA/FULL locations)
    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.x_is_fba_location", "=", False)]],
        {"fields": ["quantity", "reserved_quantity"]}
    )
    available = sum(q["quantity"] - q["reserved_quantity"] for q in quants)
    base_qty  = max(0, int(available) - SAFETY_BUFFER)

    # Step 2: Push to Shopify
    requests.post(
        f"https://{SHOPIFY_SHOP}.myshopify.com/admin/api/2024-04/inventory_levels/set.json",
        headers=shopify_headers(),
        json={"location_id": shopify_location_id,
              "inventory_item_id": shopify_variant_id,
              "available": base_qty}
    )

    # Step 3: Push to Amazon FBM only (never push to FBA listings)
    if is_fbm:
        fbm_qty = max(0, base_qty - AMAZON_EXTRA)
        sp_api.patch(
            f"/listings/2021-08-01/items/{AMAZON_SELLER_ID}/{amazon_seller_sku}",
            params={"marketplaceIds": AMAZON_MARKETPLACE_ID},
            body={"productType": "PRODUCT", "patches": [{
                "op": "replace",
                "path": "/attributes/fulfillment_availability",
                "value": [{"fulfillment_channel_code": "DEFAULT", "quantity": fbm_qty}]
            }]}
        )

def on_erp_product_updated(odoo_product_id: int, changed_fields: list[str]):
    """
    Called when product.template is written in Odoo.
    Only propagates fields that channels care about.
    """
    models, uid = odoo_connect()
    product = models.execute_kw(ODOO_DB, uid, ODOO_KEY,
        "product.template", "read", [odoo_product_id],
        {"fields": ["name", "default_code", "list_price", "active",
                    "x_meli_item_id", "x_shopify_product_id", "x_amazon_seller_sku"]}
    )

    # Fields that propagate to Shopify
    shopify_propagate = {"list_price", "active"}   # NOT name — Shopify owns its own title
    if shopify_propagate & set(changed_fields):
        shopify_update_product(
            product_id=product["x_shopify_product_id"],
            price=product["list_price"],
            active=product["active"],
        )

    # Fields that propagate to Amazon FBM
    amazon_propagate = {"list_price", "active"}
    if amazon_propagate & set(changed_fields) and product["x_amazon_seller_sku"]:
        amazon_update_listing(
            seller_sku=product["x_amazon_seller_sku"],
            price=compute_amazon_price(product["list_price"]),
        )

    # Fields that propagate to MELI
    meli_propagate = {"list_price"}
    if meli_propagate & set(changed_fields) and product["x_meli_item_id"]:
        meli_update_price(
            item_id=product["x_meli_item_id"],
            price=compute_meli_price(product["list_price"]),
        )

def daily_sor_reconciliation() -> dict:
    """
    Runs daily. Compares ERP state against all channels.
    Returns dict of discrepancies for ops dashboard.
    """
    report = {"inventory_drift": [], "order_gaps": [], "price_mismatches": []}
    active_skus = get_all_active_skus_from_erp()

    for sku in active_skus:
        erp_qty      = get_odoo_available(sku)
        shopify_qty  = shopify_get_inventory(sku)
        amazon_qty   = amazon_get_fbm_qty(sku)    # FBM only

        # Inventory drift check (allow SAFETY_BUFFER variance)
        for channel, ch_qty in {"shopify": shopify_qty, "amazon_fbm": amazon_qty}.items():
            expected = max(0, erp_qty - SAFETY_BUFFER)
            drift = abs(expected - ch_qty)
            if drift > 3:   # more than 3 units drift → investigate
                report["inventory_drift"].append({
                    "sku": sku, "channel": channel,
                    "erp_qty": erp_qty, "channel_qty": ch_qty, "drift": drift
                })

        # Order gap check: ERP orders today vs channel order count today
        erp_orders     = get_erp_orders_today_for_sku(sku)
        shopify_orders = shopify_orders_today(sku)
        amazon_orders  = amazon_orders_today(sku)

        if len(erp_orders) < len(shopify_orders) + len(amazon_orders):
            report["order_gaps"].append({
                "sku": sku,
                "erp_count": len(erp_orders),
                "channel_total": len(shopify_orders) + len(amazon_orders),
            })

    return report