shanxia2.0/backend/app/services/pl_contract_plan_qty.py

"""合同产品在运输计划上的安排数量汇总。"""
from __future__ import annotations

from collections import defaultdict
from typing import Any, DefaultDict, Dict, Iterable, Optional, Set, Tuple

from sqlalchemy.orm import Session

from app.models.pl_models import (
    PlPlan,
    PlPlanContract,
    PlPlanDelivery,
    PlPlanDeliveryProduct,
    PlPlanLoad,
    PlPlanLoadProduct,
)
from app.services.pl_plan_service import (
    PLAN_CONTRACT_SIDE_DEMANDER,
    PLAN_CONTRACT_SIDE_SUPPLIER,
)
from app.services.pl_plan_stop_service import (
    PLAN_CONTRACT_SIDE_DELIVERY,
    PLAN_CONTRACT_SIDE_LOAD,
)
from app.utils.crm_package_spec import decode_package_specs

# 待安排 / 等通知 / 作废：不计入「已安排」（见 _bucket_for_plan）

ProductPackageKey = Tuple[str, str]
LINE_OCCUPANCY_PREFIX = "__line__"
PKG_DISPLAY_PREFIX = "__pkg__"


def line_occupancy_key(contract_product_id: Any) -> Optional[ProductPackageKey]:
    cpid = str(contract_product_id or "").strip()
    if not cpid:
        return None
    return (LINE_OCCUPANCY_PREFIX, cpid)


def is_line_occupancy_key(key: Any) -> bool:
    return (
        isinstance(key, tuple)
        and len(key) == 2
        and key[0] == LINE_OCCUPANCY_PREFIX
        and bool(str(key[1] or "").strip())
    )


def normalize_package_spec(value: Any) -> str:
    if value is None:
        return ""
    return str(value).strip()


def product_package_key(product_id: Any, package_spec: Any = None) -> Optional[ProductPackageKey]:
    pid = str(product_id or "").strip()
    if not pid:
        return None
    return (pid, normalize_package_spec(package_spec))


def package_display_key(contract_product_id: Any, package_spec: Any = None) -> Optional[ProductPackageKey]:
    """按合同明细行拆开展示包装数量；不参与行剩余占用，避免与 __line__ 双计。"""
    cpid = str(contract_product_id or "").strip()
    if not cpid:
        return None
    return (PKG_DISPLAY_PREFIX, f"{cpid}\x1f{normalize_package_spec(package_spec)}")


def _stats_for_package_breakdown(
    qty_map: Dict[ProductPackageKey, Dict[str, float]],
    pool_key: Optional[ProductPackageKey],
    zeros: Dict[str, float],
    *,
    contract_product_id: Any = None,
    include_pool_key: bool = True,
) -> Dict[str, float]:
    out = {k: 0.0 for k in zeros}
    if pool_key:
        dkey = package_display_key(contract_product_id, pool_key[1])
        sources = []
        if dkey:
            sources.append(qty_map.get(dkey))
        if include_pool_key:
            sources.append(qty_map.get(pool_key))
        for src in sources:
            if not src:
                continue
            for k in zeros:
                out[k] = round(out[k] + _to_float(src.get(k)), 3)
    return out


def _to_float(value: Any) -> float:
    if value is None:
        return 0.0
    try:
        return float(value)
    except (TypeError, ValueError):
        return 0.0


def contract_line_package_specs(row: Any) -> list[str]:
    """从合同产品行（ORM / dict / SimpleNamespace）解析包装列表。"""
    if isinstance(row, dict):
        raw_list = row.get("packageSpecs") or row.get("package_specs")
        if isinstance(raw_list, (list, tuple)) and raw_list:
            return decode_package_specs(raw_list)
        return decode_package_specs(row.get("packageSpec") or row.get("package_spec"))
    raw_list = getattr(row, "package_specs", None)
    if isinstance(raw_list, (list, tuple)) and raw_list:
        return decode_package_specs(raw_list)
    return decode_package_specs(getattr(row, "package_spec", None))


def pool_keys_for_contract_line(row: Any) -> list[ProductPackageKey]:
    pid = ""
    if isinstance(row, dict):
        pid = str(row.get("productId") or row.get("product_id") or "").strip()
    else:
        pid = str(getattr(row, "product_id", None) or "").strip()
    if not pid:
        return []
    keys: list[ProductPackageKey] = []
    for spec in contract_line_package_specs(row):
        key = product_package_key(pid, spec)
        if key:
            keys.append(key)
    return keys


def sum_qty_stats_for_keys(
    qty_map: Dict[ProductPackageKey, Dict[str, float]],
    keys: Iterable[ProductPackageKey],
) -> Dict[str, float]:
    archived = 0.0
    unarchived = 0.0
    for key in keys or []:
        stats = qty_map.get(key) or {}
        archived += _to_float(stats.get("archivedQty"))
        unarchived += _to_float(stats.get("arrangedUnarchivedQty"))
    archived = round(archived, 3)
    unarchived = round(unarchived, 3)
    return {
        "archivedQty": archived,
        "arrangedUnarchivedQty": unarchived,
        "arrangedTotalQty": round(archived + unarchived, 3),
    }


def contract_product_id_of(row: Any) -> str:
    if isinstance(row, dict):
        return str(row.get("id") or row.get("contractProductId") or "").strip()
    return str(getattr(row, "id", None) or getattr(row, "contract_product_id", None) or "").strip()


def match_first_contract_product_for_key(
    products: Iterable[Any],
    key: Optional[ProductPackageKey],
) -> Optional[Any]:
    """按 productId + 包装∈行内集合匹配第一行（同包装多行不合并）。"""
    if not key:
        return None
    pid, pkg = key[0], key[1]
    for p in products or []:
        if isinstance(p, dict):
            row_pid = str(p.get("productId") or p.get("product_id") or "").strip()
        else:
            row_pid = str(getattr(p, "product_id", None) or "").strip()
        if row_pid != pid:
            continue
        specs = contract_line_package_specs(p)
        if pkg in specs:
            return p
    return None


def occupancy_keys_for_contract_line(
    row: Any,
    all_products: Optional[Iterable[Any]] = None,
) -> list[ProductPackageKey]:
    """行占用键：绑定行用 __line__；无绑定时仅第一匹配行承接包装键（历史计划）。"""
    keys: list[ProductPackageKey] = []
    cpid = contract_product_id_of(row)
    line_key = line_occupancy_key(cpid)
    if line_key:
        keys.append(line_key)
    peers = list(all_products or [])
    for pkg_key in pool_keys_for_contract_line(row):
        first = match_first_contract_product_for_key(peers, pkg_key) if peers else row
        if first is None:
            continue
        if cpid and contract_product_id_of(first) != cpid:
            continue
        keys.append(pkg_key)
    return keys


def match_contract_product_for_key(
    products: Iterable[Any],
    key: Optional[ProductPackageKey],
) -> Optional[Any]:
    """按 productId + 包装∈行内集合 匹配合同产品行；同包装脏数据多行时 quantity 相加。"""
    if not key:
        return None
    pid, pkg = key[0], key[1]
    matched = []
    for p in products or []:
        row_pid = ""
        if isinstance(p, dict):
            row_pid = str(p.get("productId") or p.get("product_id") or "").strip()
        else:
            row_pid = str(getattr(p, "product_id", None) or "").strip()
        if row_pid != pid:
            continue
        specs = contract_line_package_specs(p)
        if pkg in specs:
            matched.append(p)
    if not matched:
        return None
    if len(matched) == 1:
        return matched[0]
    from types import SimpleNamespace

    total_qty = 0.0
    for p in matched:
        if isinstance(p, dict):
            total_qty += _to_float(p.get("quantity"))
        else:
            total_qty += _to_float(getattr(p, "quantity", None))
    base = matched[0]
    if isinstance(base, dict):
        return SimpleNamespace(
            id=base.get("id"),
            product_id=base.get("productId") or base.get("product_id"),
            package_spec=encode_specs_for_attr(contract_line_package_specs(base)),
            product_name=base.get("productName") or base.get("product_name"),
            model=base.get("model"),
            unit=base.get("unit"),
            quantity=total_qty,
            quantity_mode=base.get("quantityMode") or base.get("quantity_mode"),
        )
    return SimpleNamespace(
        id=getattr(base, "id", None),
        product_id=getattr(base, "product_id", None),
        package_spec=getattr(base, "package_spec", None),
        product_name=getattr(base, "product_name", None),
        model=getattr(base, "model", None),
        unit=getattr(base, "unit", None),
        quantity=total_qty,
        quantity_mode=getattr(base, "quantity_mode", None),
    )


def encode_specs_for_attr(specs: list[str]) -> str:
    from app.utils.crm_package_spec import encode_package_specs

    return encode_package_specs(specs)


def _bucket_for_plan(*, archive_status: Optional[str], follow_status: Optional[str], transport_status: Optional[str]) -> Optional[str]:
    """返回 'archived' | 'arranged_unarchived' | None（不计入）。"""
    follow = (follow_status or "").strip()
    if follow == "cancelled" or follow in ("wait_notice", "pending_arrange"):
        return None
    archive = (archive_status or "").strip() or "unarchived"
    if archive == "archived":
        return "archived"
    # 已安排未归档（含 archive draft 暂存）
    transport = (transport_status or "").strip()
    if transport == "arranged" or follow in ("arranged", "completed"):
        return "arranged_unarchived"
    return None


def merge_product_qty_maps(
    *,
    archived: Dict[ProductPackageKey, float],
    arranged_unarchived: Dict[ProductPackageKey, float],
) -> Dict[ProductPackageKey, Dict[str, float]]:
    """(product_id, package_spec) -> {archivedQty, arrangedUnarchivedQty, arrangedTotalQty}"""
    keys = set(archived) | set(arranged_unarchived)
    out: Dict[ProductPackageKey, Dict[str, float]] = {}
    for key in keys:
        a = round(float(archived.get(key, 0.0)), 3)
        u = round(float(arranged_unarchived.get(key, 0.0)), 3)
        out[key] = {
            "archivedQty": a,
            "arrangedUnarchivedQty": u,
            "arrangedTotalQty": round(a + u, 3),
        }
    return out


# plan：计划数量；archive_actual：装货 inbound / 送货 outbound，null 回退 plan_qty
QTY_MODE_PLAN = "plan"
QTY_MODE_ARCHIVE_ACTUAL = "archive_actual"


def _resolve_stop_product_qty(
    row: Any,
    *,
    stop_kind: str,
    qty_mode: str,
) -> float:
    """按模式解析段产品计入量。"""
    if qty_mode == QTY_MODE_ARCHIVE_ACTUAL:
        attr = "inbound_qty" if stop_kind == "load" else "outbound_qty"
        raw = getattr(row, attr, None)
        if raw is not None:
            return _to_float(raw)
        return _to_float(getattr(row, "plan_qty", None))
    return _to_float(getattr(row, "plan_qty", None))


def accumulate_stop_products(
    target: DefaultDict[ProductPackageKey, float],
    products: Iterable[Any],
    *,
    stop_kind: str = "load",
    qty_mode: str = QTY_MODE_PLAN,
) -> None:
    for row in products or []:
        qty = _resolve_stop_product_qty(row, stop_kind=stop_kind, qty_mode=qty_mode)
        if not qty:
            continue
        line_key = line_occupancy_key(
            getattr(row, "contract_product_id", None)
            if not isinstance(row, dict)
            else row.get("contractProductId") or row.get("contract_product_id")
        )
        key = product_package_key(
            getattr(row, "product_id", None)
            if not isinstance(row, dict)
            else row.get("productId") or row.get("product_id"),
            getattr(row, "package_spec", None)
            if not isinstance(row, dict)
            else row.get("packageSpec") or row.get("package_spec"),
        )
        display_key = (
            package_display_key(line_key[1], key[1] if key else "") if line_key else None
        )
        if line_key:
            target[line_key] += qty
            if display_key:
                target[display_key] += qty
            continue
        if not key:
            continue
        target[key] += qty


def resolve_linked_plan_scopes(
    link_rows: Iterable[PlPlanContract],
    legacy_plan_ids: Iterable[str],
) -> Dict[str, Dict[str, Any]]:
    """
    plan_id -> {
      load_ids: set[str] | None,   # None = 该侧全部装货段
      delivery_ids: set[str] | None,
      use_all_stops: bool,         # 遗留主表合同：优先送货段，否则装货段，各产品只计一次
    }
    """
    scopes: Dict[str, Dict[str, Any]] = {}

    def _ensure(plan_id: str) -> Dict[str, Any]:
        if plan_id not in scopes:
            scopes[plan_id] = {
                "load_ids": set(),
                "delivery_ids": set(),
                "use_all_stops": False,
                "has_explicit": False,
            }
        return scopes[plan_id]

    for row in link_rows or []:
        plan_id = str(getattr(row, "plan_id", None) or "").strip()
        if not plan_id:
            continue
        scope = _ensure(plan_id)
        side = (getattr(row, "side", None) or "").strip()
        stop_id = str(getattr(row, "stop_id", None) or "").strip()
        scope["has_explicit"] = True
        if side in (PLAN_CONTRACT_SIDE_LOAD, PLAN_CONTRACT_SIDE_SUPPLIER):
            if stop_id:
                scope["load_ids"].add(stop_id)
            else:
                scope["load_ids"] = None  # type: ignore[assignment]
        elif side in (PLAN_CONTRACT_SIDE_DELIVERY, PLAN_CONTRACT_SIDE_DEMANDER):
            if stop_id:
                scope["delivery_ids"].add(stop_id)
            else:
                scope["delivery_ids"] = None  # type: ignore[assignment]
        elif stop_id:
            # 未知 side 但有 stop：两边都尝试匹配时由调用方按 id 过滤
            scope["load_ids"].add(stop_id)
            scope["delivery_ids"].add(stop_id)

    for plan_id in legacy_plan_ids or []:
        pid = str(plan_id or "").strip()
        if not pid:
            continue
        scope = _ensure(pid)
        if not scope["has_explicit"]:
            scope["use_all_stops"] = True

    return scopes


def sum_qtys_for_scope(
    *,
    load_products_by_load: Dict[str, list],
    delivery_products_by_delivery: Dict[str, list],
    all_load_ids: Set[str],
    all_delivery_ids: Set[str],
    scope: Dict[str, Any],
    qty_mode: str = QTY_MODE_PLAN,
) -> Dict[ProductPackageKey, float]:
    acc: DefaultDict[ProductPackageKey, float] = defaultdict(float)

    if scope.get("use_all_stops"):
        # 遗留：优先送货段数量；无送货则用装货，避免装+送双计
        if all_delivery_ids:
            for did in all_delivery_ids:
                accumulate_stop_products(
                    acc,
                    delivery_products_by_delivery.get(did, []),
                    stop_kind="delivery",
                    qty_mode=qty_mode,
                )
        else:
            for lid in all_load_ids:
                accumulate_stop_products(
                    acc,
                    load_products_by_load.get(lid, []),
                    stop_kind="load",
                    qty_mode=qty_mode,
                )
        return dict(acc)

    load_ids = scope.get("load_ids")
    delivery_ids = scope.get("delivery_ids")

    if load_ids is None:
        for lid in all_load_ids:
            accumulate_stop_products(
                acc,
                load_products_by_load.get(lid, []),
                stop_kind="load",
                qty_mode=qty_mode,
            )
    elif load_ids:
        for lid in load_ids:
            accumulate_stop_products(
                acc,
                load_products_by_load.get(lid, []),
                stop_kind="load",
                qty_mode=qty_mode,
            )

    if delivery_ids is None:
        for did in all_delivery_ids:
            accumulate_stop_products(
                acc,
                delivery_products_by_delivery.get(did, []),
                stop_kind="delivery",
                qty_mode=qty_mode,
            )
    elif delivery_ids:
        for did in delivery_ids:
            accumulate_stop_products(
                acc,
                delivery_products_by_delivery.get(did, []),
                stop_kind="delivery",
                qty_mode=qty_mode,
            )

    return dict(acc)


def aggregate_contract_product_plan_qtys(
    db: Session,
    *,
    tenant_no: str,
    contract_id: str,
) -> Dict[ProductPackageKey, Dict[str, float]]:
    """返回 (productId, packageSpec) -> 三数量字段。"""
    cid = (contract_id or "").strip()
    if not cid:
        return {}

    link_rows = (
        db.query(PlPlanContract)
        .filter(
            PlPlanContract.tenant_no == tenant_no,
            PlPlanContract.del_flag == 0,
            PlPlanContract.contract_id == cid,
        )
        .all()
    )
    link_plan_ids = {str(r.plan_id) for r in link_rows if r.plan_id}

    legacy_plans = (
        db.query(PlPlan)
        .filter(
            PlPlan.tenant_no == tenant_no,
            PlPlan.del_flag == 0,
            PlPlan.contract_id == cid,
        )
        .all()
    )
    legacy_only_ids = {p.id for p in legacy_plans if p.id not in link_plan_ids}

    scopes = resolve_linked_plan_scopes(link_rows, legacy_only_ids)
    plan_ids = list(scopes.keys())
    if not plan_ids:
        return {}

    plans = (
        db.query(PlPlan)
        .filter(
            PlPlan.tenant_no == tenant_no,
            PlPlan.del_flag == 0,
            PlPlan.id.in_(plan_ids),
            PlPlan.follow_status != "cancelled",
        )
        .all()
    )
    plan_by_id = {p.id: p for p in plans}

    loads = (
        db.query(PlPlanLoad)
        .filter(
            PlPlanLoad.tenant_no == tenant_no,
            PlPlanLoad.del_flag == 0,
            PlPlanLoad.plan_id.in_(plan_ids),
        )
        .all()
    )
    deliveries = (
        db.query(PlPlanDelivery)
        .filter(
            PlPlanDelivery.tenant_no == tenant_no,
            PlPlanDelivery.del_flag == 0,
            PlPlanDelivery.plan_id.in_(plan_ids),
        )
        .all()
    )
    load_ids_by_plan: DefaultDict[str, Set[str]] = defaultdict(set)
    delivery_ids_by_plan: DefaultDict[str, Set[str]] = defaultdict(set)
    for row in loads:
        load_ids_by_plan[row.plan_id].add(row.id)
    for row in deliveries:
        delivery_ids_by_plan[row.plan_id].add(row.id)

    all_load_ids = {row.id for row in loads}
    all_delivery_ids = {row.id for row in deliveries}

    load_products_by_load: DefaultDict[str, list] = defaultdict(list)
    if all_load_ids:
        for prod in (
            db.query(PlPlanLoadProduct)
            .filter(
                PlPlanLoadProduct.tenant_no == tenant_no,
                PlPlanLoadProduct.del_flag == 0,
                PlPlanLoadProduct.load_id.in_(all_load_ids),
            )
            .all()
        ):
            load_products_by_load[prod.load_id].append(prod)

    delivery_products_by_delivery: DefaultDict[str, list] = defaultdict(list)
    if all_delivery_ids:
        for prod in (
            db.query(PlPlanDeliveryProduct)
            .filter(
                PlPlanDeliveryProduct.tenant_no == tenant_no,
                PlPlanDeliveryProduct.del_flag == 0,
                PlPlanDeliveryProduct.delivery_id.in_(all_delivery_ids),
            )
            .all()
        ):
            delivery_products_by_delivery[prod.delivery_id].append(prod)

    archived: DefaultDict[ProductPackageKey, float] = defaultdict(float)
    arranged_unarchived: DefaultDict[ProductPackageKey, float] = defaultdict(float)

    for plan_id, scope in scopes.items():
        plan = plan_by_id.get(plan_id)
        if not plan:
            continue
        bucket = _bucket_for_plan(
            archive_status=plan.archive_status,
            follow_status=plan.follow_status,
            transport_status=plan.transport_status,
        )
        if not bucket:
            continue
        qty_mode = (
            QTY_MODE_ARCHIVE_ACTUAL if bucket == "archived" else QTY_MODE_PLAN
        )
        qtys = sum_qtys_for_scope(
            load_products_by_load=load_products_by_load,
            delivery_products_by_delivery=delivery_products_by_delivery,
            all_load_ids=load_ids_by_plan.get(plan_id, set()),
            all_delivery_ids=delivery_ids_by_plan.get(plan_id, set()),
            scope=scope,
            qty_mode=qty_mode,
        )
        target = archived if bucket == "archived" else arranged_unarchived
        for pid, qty in qtys.items():
            target[pid] += qty

    return merge_product_qty_maps(archived=dict(archived), arranged_unarchived=dict(arranged_unarchived))


def attach_plan_qty_fields_to_products(
    products: list,
    qty_by_product_id: Dict[ProductPackageKey, Dict[str, float]],
) -> None:
    zeros = {
        "archivedQty": 0.0,
        "arrangedUnarchivedQty": 0.0,
        "arrangedTotalQty": 0.0,
    }
    for item in products or []:
        if not isinstance(item, dict):
            continue
        specs = contract_line_package_specs(item)
        item["packageSpecs"] = specs
        if specs:
            item["packageSpec"] = specs[0]
        elif not item.get("packageSpec"):
            item["packageSpec"] = ""
        keys = pool_keys_for_contract_line(item)
        cpid = contract_product_id_of(item)
        breakdown: list[Dict[str, Any]] = []
        for key in keys:
            first = match_first_contract_product_for_key(products, key) if products else item
            include_pool = first is not None and (
                not cpid or contract_product_id_of(first) == cpid
            )
            stats = _stats_for_package_breakdown(
                qty_by_product_id,
                key,
                zeros,
                contract_product_id=cpid,
                include_pool_key=include_pool,
            )
            breakdown.append(
                {
                    "packageSpec": key[1] if key else "",
                    "archivedQty": stats["archivedQty"],
                    "arrangedUnarchivedQty": stats["arrangedUnarchivedQty"],
                    "arrangedTotalQty": stats["arrangedTotalQty"],
                }
            )
        occ_keys = occupancy_keys_for_contract_line(item, products)
        line_stats = (
            sum_qty_stats_for_keys(qty_by_product_id, occ_keys) if occ_keys else dict(zeros)
        )
        item["archivedQty"] = line_stats["archivedQty"]
        item["arrangedUnarchivedQty"] = line_stats["arrangedUnarchivedQty"]
        item["arrangedTotalQty"] = line_stats["arrangedTotalQty"]
        item["packageQtyBreakdown"] = breakdown
        line_qty = _to_float(item.get("quantity"))
        if line_qty > 0:
            item["remainingQty"] = round(line_qty - line_stats["arrangedTotalQty"], 3)
        else:
            item["remainingQty"] = None


def plan_ids_linked_to_contract(
    db: Session,
    *,
    tenant_no: str,
    contract_id: str,
) -> Set[str]:
    cid = (contract_id or "").strip()
    if not cid:
        return set()
    ids: Set[str] = set()
    for (plan_id,) in (
        db.query(PlPlanContract.plan_id)
        .filter(
            PlPlanContract.tenant_no == tenant_no,
            PlPlanContract.del_flag == 0,
            PlPlanContract.contract_id == cid,
        )
        .distinct()
        .all()
    ):
        if plan_id:
            ids.add(str(plan_id))
    for (plan_id,) in (
        db.query(PlPlan.id)
        .filter(
            PlPlan.tenant_no == tenant_no,
            PlPlan.del_flag == 0,
            PlPlan.contract_id == cid,
        )
        .all()
    ):
        if plan_id:
            ids.add(str(plan_id))
    return ids


def contract_ids_linked_to_plan(
    db: Session,
    *,
    tenant_no: str,
    plan: PlPlan,
) -> Set[str]:
    ids: Set[str] = set()
    if plan.contract_id:
        ids.add(str(plan.contract_id).strip())
    for (cid,) in (
        db.query(PlPlanContract.contract_id)
        .filter(
            PlPlanContract.tenant_no == tenant_no,
            PlPlanContract.del_flag == 0,
            PlPlanContract.plan_id == plan.id,
        )
        .distinct()
        .all()
    ):
        if cid:
            ids.add(str(cid).strip())
    return {x for x in ids if x}


def auto_start_execute_approved_contracts(
    db: Session,
    *,
    tenant_no: str,
    plan: PlPlan,
    user_id: Optional[str] = None,
) -> list[str]:
    """将关联且状态为 approved 的合同置为 executing（不 commit）。返回已推进的合同 id。"""
    from datetime import datetime

    from app.models.crm_models import CrmContract

    started: list[str] = []
    for cid in contract_ids_linked_to_plan(db, tenant_no=tenant_no, plan=plan):
        row = (
            db.query(CrmContract)
            .filter(
                CrmContract.id == cid,
                CrmContract.tenant_no == tenant_no,
                CrmContract.del_flag == 0,
            )
            .first()
        )
        if not row or row.status != "approved":
            continue
        row.status = "executing"
        row.update_by = user_id
        row.update_time = datetime.now()
        started.append(cid)
    return started


# =============================================================================
# 安排运输：合同数量硬拦 / 成功后提醒
# =============================================================================

FRAMEWORK_CONTRACT_TYPES = frozenset({"framework", "framework_sale", "framework_purchase"})


def effective_arranged_total(
    *,
    arranged_total: float,
    old_plan_qty: float,
    new_plan_qty: float,
) -> float:
    """已安排合计 − 本计划旧量 + 本计划新量。"""
    return round(
        _to_float(arranged_total) - _to_float(old_plan_qty) + _to_float(new_plan_qty),
        3,
    )


def contract_product_has_fixed_qty(
    *,
    contract_type: Optional[str],
    quantity: Any,
    quantity_mode: Optional[str],
) -> bool:
    """合同产品行是否按固定数量做超量硬拦。"""
    ctype = (contract_type or "").strip()
    mode = (quantity_mode or "").strip() or "fixed"
    if ctype in FRAMEWORK_CONTRACT_TYPES and mode == "customer_demand":
        return False
    qty = _to_float(quantity)
    return qty > 0


def evaluate_product_qty_for_arrange(
    *,
    has_fixed_qty: bool,
    contract_qty: Optional[float],
    arranged_total: float,
    old_plan_qty: float,
    new_plan_qty: float,
) -> Optional[Dict[str, Any]]:
    """
    返回:
      - None: 跳过（本次无量）
      - kind=violation | remaining | framework_cumulative
    """
    new_qty = _to_float(new_plan_qty)
    if new_qty <= 0:
        return None

    old_qty = _to_float(old_plan_qty)
    arranged = _to_float(arranged_total)
    effective = effective_arranged_total(
        arranged_total=arranged,
        old_plan_qty=old_qty,
        new_plan_qty=new_qty,
    )

    if not has_fixed_qty:
        return {
            "kind": "framework_cumulative",
            "arrangedTotalQty": effective,
            "thisPlanQty": round(new_qty, 3),
            "effectiveTotal": effective,
        }

    cq = _to_float(contract_qty)
    overflow = round(effective - cq, 3)
    base = {
        "contractQty": round(cq, 3),
        "arrangedTotalQty": effective,
        "thisPlanQty": round(new_qty, 3),
        "oldPlanQty": round(old_qty, 3),
        "newPlanQty": round(new_qty, 3),
        "effectiveTotal": effective,
    }
    if overflow > 0:
        return {**base, "kind": "violation", "overflowQty": overflow}
    return {
        **base,
        "kind": "remaining",
        "remainingQty": round(cq - effective, 3),
    }


CONTRACT_QTY_VIOLATION_CODE = "CONTRACT_QTY_OVERFLOW"
ARCHIVE_LINE_QTY_OVERAGE_CODE = "CONTRACT_LINE_QTY_OVERAGE"


def _stop_kind_from_scope(scope: Dict[str, Any]) -> str:
    load_ids = scope.get("load_ids")
    delivery_ids = scope.get("delivery_ids")
    has_load = load_ids is None or bool(load_ids)
    has_delivery = delivery_ids is None or bool(delivery_ids)
    if scope.get("use_all_stops"):
        return "delivery"
    if has_load and not has_delivery:
        return "load"
    if has_delivery and not has_load:
        return "delivery"
    if has_load:
        return "load"
    return "delivery"


def _plan_scope_for_contract(
    *,
    plan_id: str,
    contract_id: str,
    link_rows: list[PlPlanContract],
    legacy_contract_id: Optional[str],
) -> Dict[str, Any]:
    cid = (contract_id or "").strip()
    links = [r for r in link_rows if str(r.contract_id or "").strip() == cid]
    legacy_ids: list[str] = []
    if not links and legacy_contract_id and str(legacy_contract_id).strip() == cid:
        legacy_ids = [plan_id]
    scopes = resolve_linked_plan_scopes(links, legacy_ids)
    return scopes.get(plan_id) or {
        "load_ids": set(),
        "delivery_ids": set(),
        "use_all_stops": False,
        "has_explicit": False,
    }


def _load_plan_stop_product_maps(
    db: Session,
    *,
    tenant_no: str,
    plan_id: str,
) -> tuple[Set[str], Set[str], Dict[str, list], Dict[str, list]]:
    loads = (
        db.query(PlPlanLoad)
        .filter(
            PlPlanLoad.tenant_no == tenant_no,
            PlPlanLoad.del_flag == 0,
            PlPlanLoad.plan_id == plan_id,
        )
        .all()
    )
    deliveries = (
        db.query(PlPlanDelivery)
        .filter(
            PlPlanDelivery.tenant_no == tenant_no,
            PlPlanDelivery.del_flag == 0,
            PlPlanDelivery.plan_id == plan_id,
        )
        .all()
    )
    load_ids = {row.id for row in loads}
    delivery_ids = {row.id for row in deliveries}
    load_products_by_load: DefaultDict[str, list] = defaultdict(list)
    if load_ids:
        for prod in (
            db.query(PlPlanLoadProduct)
            .filter(
                PlPlanLoadProduct.tenant_no == tenant_no,
                PlPlanLoadProduct.del_flag == 0,
                PlPlanLoadProduct.load_id.in_(load_ids),
            )
            .all()
        ):
            load_products_by_load[prod.load_id].append(prod)
    delivery_products_by_delivery: DefaultDict[str, list] = defaultdict(list)
    if delivery_ids:
        for prod in (
            db.query(PlPlanDeliveryProduct)
            .filter(
                PlPlanDeliveryProduct.tenant_no == tenant_no,
                PlPlanDeliveryProduct.del_flag == 0,
                PlPlanDeliveryProduct.delivery_id.in_(delivery_ids),
            )
            .all()
        ):
            delivery_products_by_delivery[prod.delivery_id].append(prod)
    return load_ids, delivery_ids, dict(load_products_by_load), dict(delivery_products_by_delivery)


def collect_plan_contract_qty_checks(
    db: Session,
    *,
    tenant_no: str,
    plan_id: str,
) -> tuple[list[Dict[str, Any]], list[Dict[str, Any]]]:
    """
    返回 (violations, reminders)。
    在写运输前调用；reminders 可缓存到成功响应，勿在状态变更后再算。
    """
    from app.models.crm_models import CrmContract, CrmContractProduct

    plan = (
        db.query(PlPlan)
        .filter(
            PlPlan.id == plan_id,
            PlPlan.tenant_no == tenant_no,
            PlPlan.del_flag == 0,
        )
        .first()
    )
    if not plan:
        return [], []

    link_rows = (
        db.query(PlPlanContract)
        .filter(
            PlPlanContract.tenant_no == tenant_no,
            PlPlanContract.del_flag == 0,
            PlPlanContract.plan_id == plan_id,
        )
        .all()
    )
    contract_ids: Set[str] = set()
    for row in link_rows:
        cid = str(row.contract_id or "").strip()
        if cid:
            contract_ids.add(cid)
    legacy_cid = str(plan.contract_id or "").strip()
    if legacy_cid:
        contract_ids.add(legacy_cid)
    if not contract_ids:
        return [], []

    load_ids, delivery_ids, load_products_by_load, delivery_products_by_delivery = (
        _load_plan_stop_product_maps(db, tenant_no=tenant_no, plan_id=plan_id)
    )
    in_bucket = (
        _bucket_for_plan(
            archive_status=plan.archive_status,
            follow_status=plan.follow_status,
            transport_status=plan.transport_status,
        )
        is not None
    )

    violations: list[Dict[str, Any]] = []
    reminders: list[Dict[str, Any]] = []

    for cid in sorted(contract_ids):
        contract = (
            db.query(CrmContract)
            .filter(
                CrmContract.id == cid,
                CrmContract.tenant_no == tenant_no,
                CrmContract.del_flag == 0,
            )
            .first()
        )
        if not contract:
            continue

        scope = _plan_scope_for_contract(
            plan_id=plan_id,
            contract_id=cid,
            link_rows=link_rows,
            legacy_contract_id=legacy_cid,
        )

        plan_qtys = sum_qtys_for_scope(
            load_products_by_load=load_products_by_load,
            delivery_products_by_delivery=delivery_products_by_delivery,
            all_load_ids=load_ids,
            all_delivery_ids=delivery_ids,
            scope=scope,
        )
        if not plan_qtys:
            continue

        qty_map = aggregate_contract_product_plan_qtys(
            db, tenant_no=tenant_no, contract_id=cid
        )
        products = (
            db.query(CrmContractProduct)
            .filter(
                CrmContractProduct.contract_id == cid,
                CrmContractProduct.tenant_no == tenant_no,
                CrmContractProduct.del_flag == 0,
            )
            .all()
        )
        stop_kind = _stop_kind_from_scope(scope)
        contract_type = (contract.contract_type or "").strip()
        contract_no = contract.contract_no or ""
        customer_name = (contract.customer_name or "").strip()

        products_by_id = {
            str(getattr(p, "id", None) or "").strip(): p
            for p in products
            if str(getattr(p, "id", None) or "").strip()
        }
        line_groups: Dict[str, Dict[str, Any]] = {}
        for key, new_qty_raw in plan_qtys.items():
            new_qty = _to_float(new_qty_raw)
            if new_qty <= 0:
                continue
            if not isinstance(key, tuple) or len(key) != 2:
                continue
            if is_line_occupancy_key(key):
                cp = products_by_id.get(str(key[1]))
                if not cp:
                    continue
                pid = str(getattr(cp, "product_id", None) or "").strip()
                specs = contract_line_package_specs(cp)
                pkg = specs[0] if specs else ""
            elif key[0] == PKG_DISPLAY_PREFIX:
                continue
            else:
                pid, pkg = key[0], key[1]
                cp = match_first_contract_product_for_key(products, key)
                if not cp:
                    continue

            line_id = str(getattr(cp, "id", None) or "").strip()
            if not line_id:
                specs = contract_line_package_specs(cp)
                line_id = f"{pid}\0{'|'.join(specs)}"
            group = line_groups.get(line_id)
            if not group:
                group = {
                    "cp": cp,
                    "pid": pid,
                    "pool_keys": occupancy_keys_for_contract_line(cp, products),
                    "this_plan_qty": 0.0,
                    "packages": [],
                }
                line_groups[line_id] = group
            group["this_plan_qty"] += new_qty
            if pkg:
                group["packages"].append(pkg)

        for group in line_groups.values():
            cp = group["cp"]
            pid = group["pid"]
            new_qty = group["this_plan_qty"]
            pkg_label = "、".join(dict.fromkeys(group["packages"])) or None
            pool_stats = sum_qty_stats_for_keys(qty_map, group["pool_keys"])
            arranged_total = pool_stats["arrangedTotalQty"]
            if in_bucket:
                old_qty = new_qty
                # arranged 已含当前库内量；effective = arranged - old + new = arranged
            else:
                old_qty = 0.0

            has_fixed = contract_product_has_fixed_qty(
                contract_type=contract_type,
                quantity=cp.quantity,
                quantity_mode=cp.quantity_mode,
            )
            evaluated = evaluate_product_qty_for_arrange(
                has_fixed_qty=has_fixed,
                contract_qty=_to_float(cp.quantity) if has_fixed else None,
                arranged_total=arranged_total,
                old_plan_qty=old_qty,
                new_plan_qty=new_qty,
            )
            if not evaluated:
                continue

            unit_price = getattr(cp, "price", None)
            item = {
                "contractId": cid,
                "contractNo": contract_no,
                "contractType": contract_type,
                "customerName": customer_name,
                "stopKind": stop_kind,
                "contractProductId": str(getattr(cp, "id", None) or "").strip() or None,
                "productId": pid,
                "packageSpec": pkg_label,
                "packageSpecs": contract_line_package_specs(cp),
                "productName": cp.product_name or "",
                "model": (cp.model or "").strip() or None,
                "unit": (cp.unit or "").strip() or None,
                "unitPrice": round(_to_float(unit_price), 2) if unit_price is not None else None,
                "thisPlanQty": evaluated.get("thisPlanQty", round(new_qty, 3)),
                "arrangedTotalQty": evaluated["arrangedTotalQty"],
            }
            kind = evaluated["kind"]
            if kind == "violation":
                violations.append(
                    {
                        **item,
                        "contractQty": evaluated["contractQty"],
                        "oldPlanQty": evaluated["oldPlanQty"],
                        "newPlanQty": evaluated["newPlanQty"],
                        "effectiveTotal": evaluated["effectiveTotal"],
                        "overflowQty": evaluated["overflowQty"],
                        # 与提醒表同列：剩余可为负，表示超量
                        "remainingQty": round(
                            evaluated["contractQty"] - evaluated["effectiveTotal"], 3
                        ),
                    }
                )
            elif kind == "remaining":
                reminders.append(
                    {
                        **item,
                        "mode": "remaining",
                        "contractQty": evaluated["contractQty"],
                        "remainingQty": evaluated["remainingQty"],
                    }
                )
            elif kind == "framework_cumulative":
                reminders.append(
                    {
                        **item,
                        "mode": "framework_cumulative",
                    }
                )

    return violations, reminders


def assert_contract_qty_for_arrange(
    db: Session,
    *,
    tenant_no: str,
    plan_id: str,
) -> list[Dict[str, Any]]:
    """超限则 422；通过则返回 reminders（供成功响应复用）。"""
    from fastapi import HTTPException

    violations, reminders = collect_plan_contract_qty_checks(
        db, tenant_no=tenant_no, plan_id=plan_id
    )
    if violations:
        raise HTTPException(
            status_code=422,
            detail={
                "code": CONTRACT_QTY_VIOLATION_CODE,
                "message": "合同产品安排数量超过合同数量",
                "items": violations,
            },
        )
    return reminders


def build_contract_qty_reminder_payload(
    reminders: list[Dict[str, Any]],
) -> Optional[Dict[str, Any]]:
    if not reminders:
        return None
    return {"items": reminders}


def validate_stop_products_package_against_contract(
    *,
    contract_products: Iterable[Any],
    stop_products: Iterable[Any],
) -> tuple[bool, Optional[str]]:
    """
    绑合同时：计划段产品包装必填，且必须属于本合同该产品的包装集合。
    返回 (ok, error_message)。
    """
    allowed_by_pid: DefaultDict[str, Set[str]] = defaultdict(set)
    contract_pids: Set[str] = set()
    for row in contract_products or []:
        pid = ""
        if isinstance(row, dict):
            pid = str(row.get("productId") or row.get("product_id") or "").strip()
        else:
            pid = str(getattr(row, "product_id", None) or "").strip()
        if not pid:
            continue
        contract_pids.add(pid)
        for pkg in contract_line_package_specs(row):
            if pkg:
                allowed_by_pid[pid].add(pkg)

    for row in stop_products or []:
        pid = str(getattr(row, "product_id", None) or "").strip()
        if not pid or pid not in contract_pids:
            continue
        allowed = allowed_by_pid.get(pid) or set()
        if not allowed:
            continue
        pkg = normalize_package_spec(getattr(row, "package_spec", None))
        name = (
            str(getattr(row, "product_name", None) or "").strip()
            or pid
        )
        if not pkg:
            return False, f"请选择包装规格：{name}"
        if pkg not in allowed:
            return False, f"包装规格不在合同明细中：{name}（{pkg}）"
    return True, None


def get_contract_product_arrange_qty_detail(
    db: Session,
    *,
    tenant_no: str,
    contract_id: str,
    product_id: str = "",
    package_spec: Optional[str] = None,
    exclude_plan_id: Optional[str] = None,
    contract_product_id: Optional[str] = None,
) -> Dict[str, Any]:
    """
    表单「可安排数量」与问号弹窗数据。
    arrangedQty / availableQty 均不含 exclude_plan_id（若该计划已在已安排桶中）。
    """
    from app.models.crm_models import CrmContract, CrmContractProduct

    cid = (contract_id or "").strip()
    cpid = str(contract_product_id or "").strip()
    pid = (product_id or "").strip()
    pkg = normalize_package_spec(package_spec)
    key = product_package_key(pid, pkg) if pid else None
    exclude_id = (exclude_plan_id or "").strip() or None
    empty = {
        "contractId": cid,
        "contractNo": None,
        "customerName": None,
        "contractProductId": cpid or None,
        "productId": pid,
        "packageSpec": pkg or None,
        "packageSpecs": [],
        "packageBreakdown": [],
        "productName": None,
        "hasFixedQty": False,
        "contractQty": None,
        "arrangedQty": 0.0,
        "availableQty": None,
        "plans": [],
    }
    if not cid:
        return empty
    if not cpid and (not pid or not key):
        return empty

    contract = (
        db.query(CrmContract)
        .filter(
            CrmContract.id == cid,
            CrmContract.tenant_no == tenant_no,
            CrmContract.del_flag == 0,
        )
        .first()
    )
    if not contract:
        return empty

    all_lines = (
        db.query(CrmContractProduct)
        .filter(
            CrmContractProduct.contract_id == cid,
            CrmContractProduct.tenant_no == tenant_no,
            CrmContractProduct.del_flag == 0,
        )
        .all()
    )
    cp = None
    if cpid:
        cp = next((row for row in all_lines if str(row.id) == cpid), None)
        if cp:
            pid = str(cp.product_id or "").strip()
            specs = contract_line_package_specs(cp)
            if not pkg and specs:
                pkg = specs[0]
            key = product_package_key(pid, pkg) if pid else key
    elif key:
        cp = match_first_contract_product_for_key(all_lines, key)
    contract_type = (contract.contract_type or "").strip()
    has_fixed = False
    contract_qty: Optional[float] = None
    package_specs: list[str] = []
    pool_keys: list[ProductPackageKey] = [key] if key else []
    occupancy_keys: list[ProductPackageKey] = list(pool_keys)
    if cp:
        package_specs = contract_line_package_specs(cp)
        pool_keys = pool_keys_for_contract_line(cp) or pool_keys
        occupancy_keys = occupancy_keys_for_contract_line(cp, all_lines) or occupancy_keys
        has_fixed = contract_product_has_fixed_qty(
            contract_type=contract_type,
            quantity=cp.quantity,
            quantity_mode=cp.quantity_mode,
        )
        if has_fixed:
            contract_qty = round(_to_float(cp.quantity), 3)

    qty_map = aggregate_contract_product_plan_qtys(
        db, tenant_no=tenant_no, contract_id=cid
    )
    arranged_including = sum_qty_stats_for_keys(qty_map, occupancy_keys)["arrangedTotalQty"]
    line_cpid = contract_product_id_of(cp) if cp else cpid
    package_breakdown = []
    for pool_key in pool_keys:
        first = match_first_contract_product_for_key(all_lines, pool_key) if all_lines else cp
        include_pool = first is not None and (
            not line_cpid or contract_product_id_of(first) == line_cpid
        )
        stats = _stats_for_package_breakdown(
            qty_map,
            pool_key,
            {
                "archivedQty": 0.0,
                "arrangedUnarchivedQty": 0.0,
                "arrangedTotalQty": 0.0,
            },
            contract_product_id=line_cpid,
            include_pool_key=include_pool,
        )
        package_breakdown.append(
            {
                "packageSpec": pool_key[1],
                "archivedQty": stats["archivedQty"],
                "arrangedUnarchivedQty": stats["arrangedUnarchivedQty"],
                "arrangedTotalQty": stats["arrangedTotalQty"],
            }
        )
    link_rows = (
        db.query(PlPlanContract)
        .filter(
            PlPlanContract.tenant_no == tenant_no,
            PlPlanContract.del_flag == 0,
            PlPlanContract.contract_id == cid,
        )
        .all()
    )
    link_plan_ids = {str(r.plan_id) for r in link_rows if r.plan_id}
    legacy_plans = (
        db.query(PlPlan)
        .filter(
            PlPlan.tenant_no == tenant_no,
            PlPlan.del_flag == 0,
            PlPlan.contract_id == cid,
        )
        .all()
    )
    legacy_only_ids = {p.id for p in legacy_plans if p.id not in link_plan_ids}
    scopes = resolve_linked_plan_scopes(link_rows, legacy_only_ids)
    plan_ids = list(scopes.keys())

    exclude_qty = 0.0
    plans_out: list[Dict[str, Any]] = []

    if plan_ids:
        plans = (
            db.query(PlPlan)
            .filter(
                PlPlan.tenant_no == tenant_no,
                PlPlan.del_flag == 0,
                PlPlan.id.in_(plan_ids),
                PlPlan.follow_status != "cancelled",
            )
            .all()
        )
        plan_by_id = {p.id: p for p in plans}

        loads = (
            db.query(PlPlanLoad)
            .filter(
                PlPlanLoad.tenant_no == tenant_no,
                PlPlanLoad.del_flag == 0,
                PlPlanLoad.plan_id.in_(plan_ids),
            )
            .all()
        )
        deliveries = (
            db.query(PlPlanDelivery)
            .filter(
                PlPlanDelivery.tenant_no == tenant_no,
                PlPlanDelivery.del_flag == 0,
                PlPlanDelivery.plan_id.in_(plan_ids),
            )
            .all()
        )
        load_ids_by_plan: DefaultDict[str, Set[str]] = defaultdict(set)
        delivery_ids_by_plan: DefaultDict[str, Set[str]] = defaultdict(set)
        for row in loads:
            load_ids_by_plan[row.plan_id].add(row.id)
        for row in deliveries:
            delivery_ids_by_plan[row.plan_id].add(row.id)

        all_load_ids = {row.id for row in loads}
        all_delivery_ids = {row.id for row in deliveries}
        load_products_by_load: DefaultDict[str, list] = defaultdict(list)
        if all_load_ids:
            for prod in (
                db.query(PlPlanLoadProduct)
                .filter(
                    PlPlanLoadProduct.tenant_no == tenant_no,
                    PlPlanLoadProduct.del_flag == 0,
                    PlPlanLoadProduct.load_id.in_(all_load_ids),
                )
                .all()
            ):
                load_products_by_load[prod.load_id].append(prod)
        delivery_products_by_delivery: DefaultDict[str, list] = defaultdict(list)
        if all_delivery_ids:
            for prod in (
                db.query(PlPlanDeliveryProduct)
                .filter(
                    PlPlanDeliveryProduct.tenant_no == tenant_no,
                    PlPlanDeliveryProduct.del_flag == 0,
                    PlPlanDeliveryProduct.delivery_id.in_(all_delivery_ids),
                )
                .all()
            ):
                delivery_products_by_delivery[prod.delivery_id].append(prod)

        for plan_id, scope in scopes.items():
            plan = plan_by_id.get(plan_id)
            if not plan:
                continue
            bucket = _bucket_for_plan(
                archive_status=plan.archive_status,
                follow_status=plan.follow_status,
                transport_status=plan.transport_status,
            )
            if not bucket:
                continue
            qty_mode = (
                QTY_MODE_ARCHIVE_ACTUAL if bucket == "archived" else QTY_MODE_PLAN
            )
            qtys = sum_qtys_for_scope(
                load_products_by_load=load_products_by_load,
                delivery_products_by_delivery=delivery_products_by_delivery,
                all_load_ids=load_ids_by_plan.get(plan_id, set()),
                all_delivery_ids=delivery_ids_by_plan.get(plan_id, set()),
                scope=scope,
                qty_mode=qty_mode,
            )
            pq = 0.0
            for occ_key in occupancy_keys:
                pq += _to_float(qtys.get(occ_key))
            if pq <= 0:
                continue
            if exclude_id and str(plan_id) == exclude_id:
                exclude_qty = pq
                continue
            plan_date = getattr(plan, "plan_date", None)
            plans_out.append(
                {
                    "planId": plan_id,
                    "planNo": plan.plan_no or "",
                    "planDate": plan_date.isoformat() if plan_date else None,
                    "planQty": round(pq, 3),
                    "planType": getattr(plan, "plan_type", None),
                    "belongsCompany": getattr(plan, "belongs_company", None),
                    "supplierName": getattr(plan, "supplier_name", None),
                    "customerName": getattr(plan, "customer_name", None),
                    "licensePlate": getattr(plan, "license_plate", None),
                    "driverName": getattr(plan, "driver_name", None),
                    "followUserName": getattr(plan, "follow_user_name", None),
                    "followStatus": plan.follow_status,
                    "transportStatus": plan.transport_status,
                    "archiveStatus": plan.archive_status,
                    "createTime": plan.create_time.isoformat(sep=" ", timespec="seconds")
                    if getattr(plan, "create_time", None)
                    else None,
                }
            )

        plans_out.sort(key=lambda x: (x.get("planDate") or "", x.get("planNo") or ""), reverse=True)

    arranged_qty = round(max(0.0, arranged_including - exclude_qty), 3)
    available_qty = None
    if has_fixed and contract_qty is not None:
        available_qty = round(contract_qty - arranged_qty, 3)

    return {
        "contractId": cid,
        "contractNo": contract.contract_no or "",
        "customerName": (contract.customer_name or "").strip() or None,
        "contractProductId": str(getattr(cp, "id", None) or "").strip() or cpid or None,
        "productId": pid,
        "packageSpec": pkg or None,
        "packageSpecs": package_specs or ([pkg] if pkg else []),
        "packageBreakdown": package_breakdown,
        "productName": (cp.product_name if cp else None) or None,
        "hasFixedQty": has_fixed,
        "contractQty": contract_qty,
        "arrangedQty": arranged_qty,
        "availableQty": available_qty,
        "plans": plans_out,
    }


def _exclude_plan_qty_for_keys(
    db: Session,
    *,
    tenant_no: str,
    contract_id: str,
    exclude_plan_id: str,
    occupancy_keys: list[ProductPackageKey],
) -> float:
    """当前编辑计划在已安排桶中时，从占用中扣回本计划用量（轻量，不拼 plans 列表）。"""
    cid = (contract_id or "").strip()
    exclude_id = (exclude_plan_id or "").strip()
    if not cid or not exclude_id or not occupancy_keys:
        return 0.0
    link_rows = (
        db.query(PlPlanContract)
        .filter(
            PlPlanContract.tenant_no == tenant_no,
            PlPlanContract.del_flag == 0,
            PlPlanContract.contract_id == cid,
            PlPlanContract.plan_id == exclude_id,
        )
        .all()
    )
    legacy = (
        db.query(PlPlan)
        .filter(
            PlPlan.tenant_no == tenant_no,
            PlPlan.del_flag == 0,
            PlPlan.id == exclude_id,
            PlPlan.contract_id == cid,
        )
        .first()
    )
    legacy_only = {exclude_id} if legacy and not link_rows else set()
    scopes = resolve_linked_plan_scopes(link_rows, legacy_only)
    scope = scopes.get(exclude_id)
    if not scope:
        return 0.0
    plan = (
        db.query(PlPlan)
        .filter(
            PlPlan.tenant_no == tenant_no,
            PlPlan.del_flag == 0,
            PlPlan.id == exclude_id,
            PlPlan.follow_status != "cancelled",
        )
        .first()
    )
    if not plan:
        return 0.0
    bucket = _bucket_for_plan(
        archive_status=plan.archive_status,
        follow_status=plan.follow_status,
        transport_status=plan.transport_status,
    )
    if not bucket:
        return 0.0
    qty_mode = QTY_MODE_ARCHIVE_ACTUAL if bucket == "archived" else QTY_MODE_PLAN
    loads = (
        db.query(PlPlanLoad)
        .filter(
            PlPlanLoad.tenant_no == tenant_no,
            PlPlanLoad.del_flag == 0,
            PlPlanLoad.plan_id == exclude_id,
        )
        .all()
    )
    deliveries = (
        db.query(PlPlanDelivery)
        .filter(
            PlPlanDelivery.tenant_no == tenant_no,
            PlPlanDelivery.del_flag == 0,
            PlPlanDelivery.plan_id == exclude_id,
        )
        .all()
    )
    load_ids = {row.id for row in loads}
    delivery_ids = {row.id for row in deliveries}
    load_products_by_load: DefaultDict[str, list] = defaultdict(list)
    if load_ids:
        for prod in (
            db.query(PlPlanLoadProduct)
            .filter(
                PlPlanLoadProduct.tenant_no == tenant_no,
                PlPlanLoadProduct.del_flag == 0,
                PlPlanLoadProduct.load_id.in_(load_ids),
            )
            .all()
        ):
            load_products_by_load[prod.load_id].append(prod)
    delivery_products_by_delivery: DefaultDict[str, list] = defaultdict(list)
    if delivery_ids:
        for prod in (
            db.query(PlPlanDeliveryProduct)
            .filter(
                PlPlanDeliveryProduct.tenant_no == tenant_no,
                PlPlanDeliveryProduct.del_flag == 0,
                PlPlanDeliveryProduct.delivery_id.in_(delivery_ids),
            )
            .all()
        ):
            delivery_products_by_delivery[prod.delivery_id].append(prod)
    qtys = sum_qtys_for_scope(
        load_products_by_load=load_products_by_load,
        delivery_products_by_delivery=delivery_products_by_delivery,
        all_load_ids=load_ids,
        all_delivery_ids=delivery_ids,
        scope=scope,
        qty_mode=qty_mode,
    )
    total = 0.0
    for occ_key in occupancy_keys:
        total += _to_float(qtys.get(occ_key))
    return total


def batch_contract_product_arrange_qty_summaries(
    db: Session,
    *,
    tenant_no: str,
    items: list[Dict[str, Any]],
) -> list[Dict[str, Any]]:
    """
    表单打开时批量取「可安排数量」摘要（不含 plans 明细）。
    同合同只聚合一次用量，供装/送货产品表展示，避免 N 次详情接口。
    """
    from app.models.crm_models import CrmContract, CrmContractProduct

    if not items:
        return []

    by_contract: DefaultDict[str, list[tuple[int, Dict[str, Any]]]] = defaultdict(list)
    for idx, raw in enumerate(items):
        if not isinstance(raw, dict):
            continue
        cid = str(raw.get("contractId") or raw.get("contract_id") or "").strip()
        if not cid:
            continue
        by_contract[cid].append((idx, raw))

    out: list[Optional[Dict[str, Any]]] = [None] * len(items)
    for cid, indexed in by_contract.items():
        contract = (
            db.query(CrmContract)
            .filter(
                CrmContract.id == cid,
                CrmContract.tenant_no == tenant_no,
                CrmContract.del_flag == 0,
            )
            .first()
        )
        if not contract:
            for idx, raw in indexed:
                out[idx] = {
                    "key": str(raw.get("key") or ""),
                    "contractId": cid,
                    "contractNo": None,
                    "customerName": None,
                    "contractProductId": str(
                        raw.get("contractProductId") or raw.get("contract_product_id") or ""
                    ).strip()
                    or None,
                    "productId": str(raw.get("productId") or raw.get("product_id") or "").strip(),
                    "packageSpec": normalize_package_spec(
                        raw.get("packageSpec") or raw.get("package_spec")
                    )
                    or None,
                    "packageSpecs": [],
                    "packageBreakdown": [],
                    "productName": None,
                    "hasFixedQty": False,
                    "contractQty": None,
                    "arrangedQty": 0.0,
                    "availableQty": None,
                    "plans": [],
                }
            continue

        all_lines = (
            db.query(CrmContractProduct)
            .filter(
                CrmContractProduct.contract_id == cid,
                CrmContractProduct.tenant_no == tenant_no,
                CrmContractProduct.del_flag == 0,
            )
            .all()
        )
        qty_map = aggregate_contract_product_plan_qtys(
            db, tenant_no=tenant_no, contract_id=cid
        )
        contract_type = (contract.contract_type or "").strip()
        exclude_cache: Dict[str, Dict[Tuple[ProductPackageKey, ...], float]] = {}

        for idx, raw in indexed:
            cpid = str(
                raw.get("contractProductId") or raw.get("contract_product_id") or ""
            ).strip()
            pid = str(raw.get("productId") or raw.get("product_id") or "").strip()
            pkg = normalize_package_spec(raw.get("packageSpec") or raw.get("package_spec"))
            key = product_package_key(pid, pkg) if pid else None
            exclude_id = str(
                raw.get("excludePlanId") or raw.get("exclude_plan_id") or ""
            ).strip()
            client_key = str(raw.get("key") or "")

            cp = None
            if cpid:
                cp = next((row for row in all_lines if str(row.id) == cpid), None)
                if cp:
                    pid = str(cp.product_id or "").strip()
                    specs = contract_line_package_specs(cp)
                    if not pkg and specs:
                        pkg = specs[0]
                    key = product_package_key(pid, pkg) if pid else key
            elif key:
                cp = match_first_contract_product_for_key(all_lines, key)

            has_fixed = False
            contract_qty: Optional[float] = None
            package_specs: list[str] = []
            pool_keys: list[ProductPackageKey] = [key] if key else []
            occupancy_keys: list[ProductPackageKey] = list(pool_keys)
            if cp:
                package_specs = contract_line_package_specs(cp)
                pool_keys = pool_keys_for_contract_line(cp) or pool_keys
                occupancy_keys = (
                    occupancy_keys_for_contract_line(cp, all_lines) or occupancy_keys
                )
                has_fixed = contract_product_has_fixed_qty(
                    contract_type=contract_type,
                    quantity=cp.quantity,
                    quantity_mode=cp.quantity_mode,
                )
                if has_fixed:
                    contract_qty = round(_to_float(cp.quantity), 3)

            arranged_including = sum_qty_stats_for_keys(qty_map, occupancy_keys)[
                "arrangedTotalQty"
            ]
            exclude_qty = 0.0
            if exclude_id and occupancy_keys:
                occ_tuple = tuple(occupancy_keys)
                by_occ = exclude_cache.setdefault(exclude_id, {})
                if occ_tuple not in by_occ:
                    by_occ[occ_tuple] = _exclude_plan_qty_for_keys(
                        db,
                        tenant_no=tenant_no,
                        contract_id=cid,
                        exclude_plan_id=exclude_id,
                        occupancy_keys=list(occupancy_keys),
                    )
                exclude_qty = by_occ[occ_tuple]

            arranged_qty = round(max(0.0, arranged_including - exclude_qty), 3)
            available_qty = None
            if has_fixed and contract_qty is not None:
                available_qty = round(contract_qty - arranged_qty, 3)

            out[idx] = {
                "key": client_key,
                "contractId": cid,
                "contractNo": contract.contract_no or "",
                "customerName": (contract.customer_name or "").strip() or None,
                "contractProductId": str(getattr(cp, "id", None) or "").strip()
                or cpid
                or None,
                "productId": pid,
                "packageSpec": pkg or None,
                "packageSpecs": package_specs or ([pkg] if pkg else []),
                "packageBreakdown": [],
                "productName": (cp.product_name if cp else None) or None,
                "hasFixedQty": has_fixed,
                "contractQty": contract_qty,
                "arrangedQty": arranged_qty,
                "availableQty": available_qty,
                "plans": [],
            }

    return [row if row is not None else {"key": "", "plans": [], "hasFixedQty": False, "arrangedQty": 0.0, "productId": "", "contractId": ""} for row in out]


def collect_archive_line_overages(
    db: Session,
    *,
    tenant_no: str,
    plan_id: str,
    load_block: Any,
    delivery_blocks: Optional[Iterable[Any]] = None,
) -> list[Dict[str, Any]]:
    """正式归档：实际数量超过合同行剩余时返回超交明细（不含确认标志）。"""
    from app.models.crm_models import CrmContract, CrmContractProduct

    pid = (plan_id or "").strip()
    if not pid:
        return []

    load_ids, delivery_ids, load_products_by_load, delivery_products_by_delivery = (
        _load_plan_stop_product_maps(db, tenant_no=tenant_no, plan_id=pid)
    )
    actual_by_id: Dict[str, float] = {}
    if load_block is not None:
        for item in getattr(load_block, "products", None) or []:
            row_id = str(getattr(item, "id", None) or "").strip()
            if not row_id:
                continue
            qty = getattr(item, "inbound_qty", None)
            if qty is not None:
                actual_by_id[row_id] = _to_float(qty)
    for block in delivery_blocks or []:
        for item in getattr(block, "products", None) or []:
            row_id = str(getattr(item, "id", None) or "").strip()
            if not row_id:
                continue
            qty = getattr(item, "outbound_qty", None)
            if qty is not None:
                actual_by_id[row_id] = _to_float(qty)

    rows: list[Any] = []
    for load_id in load_ids:
        rows.extend(load_products_by_load.get(load_id, []))
    for did in delivery_ids:
        rows.extend(delivery_products_by_delivery.get(did, []))

    qty_map_by_contract: Dict[str, Dict[ProductPackageKey, Dict[str, float]]] = {}
    lines_by_contract: Dict[str, list] = {}
    overages: list[Dict[str, Any]] = []

    for row in rows:
        cpid = str(getattr(row, "contract_product_id", None) or "").strip()
        if not cpid:
            continue
        row_id = str(getattr(row, "id", None) or "").strip()
        if row_id not in actual_by_id:
            continue
        actual = actual_by_id[row_id]
        contract_id = str(getattr(row, "contract_id", None) or "").strip()
        cp = (
            db.query(CrmContractProduct)
            .filter(
                CrmContractProduct.id == cpid,
                CrmContractProduct.tenant_no == tenant_no,
                CrmContractProduct.del_flag == 0,
            )
            .first()
        )
        if not cp:
            continue
        if not contract_id:
            contract_id = str(cp.contract_id or "").strip()
        contract = (
            db.query(CrmContract)
            .filter(
                CrmContract.id == contract_id,
                CrmContract.tenant_no == tenant_no,
                CrmContract.del_flag == 0,
            )
            .first()
        )
        if not contract:
            continue
        contract_type = (contract.contract_type or "").strip()
        has_fixed = contract_product_has_fixed_qty(
            contract_type=contract_type,
            quantity=cp.quantity,
            quantity_mode=cp.quantity_mode,
        )
        if not has_fixed:
            continue
        if contract_id not in qty_map_by_contract:
            qty_map_by_contract[contract_id] = aggregate_contract_product_plan_qtys(
                db, tenant_no=tenant_no, contract_id=contract_id
            )
            lines_by_contract[contract_id] = (
                db.query(CrmContractProduct)
                .filter(
                    CrmContractProduct.contract_id == contract_id,
                    CrmContractProduct.tenant_no == tenant_no,
                    CrmContractProduct.del_flag == 0,
                )
                .all()
            )
        occ_keys = occupancy_keys_for_contract_line(
            cp, lines_by_contract.get(contract_id) or [cp]
        )
        arranged_total = sum_qty_stats_for_keys(
            qty_map_by_contract[contract_id], occ_keys
        )["arrangedTotalQty"]
        this_occupancy = _to_float(getattr(row, "plan_qty", None))
        inbound = getattr(row, "inbound_qty", None)
        outbound = getattr(row, "outbound_qty", None)
        if inbound is not None:
            this_occupancy = _to_float(inbound)
        elif outbound is not None:
            this_occupancy = _to_float(outbound)
        evaluated = evaluate_product_qty_for_arrange(
            has_fixed_qty=True,
            contract_qty=_to_float(cp.quantity),
            arranged_total=arranged_total,
            old_plan_qty=this_occupancy,
            new_plan_qty=actual,
        )
        if not evaluated or evaluated.get("kind") != "violation":
            continue
        specs = contract_line_package_specs(cp)
        overages.append(
            {
                "stopProductId": row_id,
                "contractId": contract_id,
                "contractNo": contract.contract_no or "",
                "contractProductId": cpid,
                "productId": str(cp.product_id or ""),
                "productName": cp.product_name or "",
                "packageSpec": "、".join(specs) if specs else getattr(row, "package_spec", None),
                "unitPrice": round(_to_float(cp.price), 2) if cp.price is not None else None,
                "contractQty": evaluated["contractQty"],
                "remainingQty": round(
                    evaluated["contractQty"] - (arranged_total - this_occupancy), 3
                ),
                "actualQty": round(actual, 3),
                "overflowQty": evaluated["overflowQty"],
            }
        )
    return overages