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

"""运输计划归档导出：按段次×产品展开（装货行与各送货段各一行）。"""
from __future__ import annotations

from datetime import date, datetime
from decimal import Decimal
from typing import Optional, Union

from sqlalchemy.orm import Session

from app.models.pl_models import PlPlan, PlPlanContract, PlPlanProduct, PlTransport
from app.schemas.pl.plan import PlanDeliveryRead, PlanLoadRead, PlanStopProductRead
from app.services.pl.plan_list_export_segments import (
    format_stop_segment_label,
    iter_segment_product_slots,
)
from app.services.pl.plan_list_filters import customer_name_matches_keywords
from app.services.pl_internal_customer import is_internal_customer_name
from app.services.pl_plan_stop_service import load_plan_stops_grouped
from app.services.pl_product_display import load_crm_product_alias_maps, resolve_product_display_names

StopKind = str  # "load" | "delivery"


def _unique_contract_nos(*sources: Optional[str]) -> str:
    """按出现顺序去重拼接合同编号。"""
    seen: list[str] = []
    for raw in sources:
        for part in str(raw or "").replace("，", ",").split(","):
            no = part.strip()
            if no and no not in seen:
                seen.append(no)
    return "、".join(seen)


def _contract_nos_from_stop_links(contracts: Optional[list]) -> list[str]:
    """段次合同关联 → 编号列表（去重保序）。"""
    seen: list[str] = []
    for item in contracts or []:
        no = (
            getattr(item, "contract_no", None)
            or (item.get("contractNo") if isinstance(item, dict) else None)
            or getattr(item, "contractNo", None)
            or ""
        )
        no = str(no or "").strip()
        if not no:
            cid = (
                getattr(item, "contract_id", None)
                or (item.get("contractId") if isinstance(item, dict) else None)
                or getattr(item, "contractId", None)
                or ""
            )
            no = str(cid or "").strip()
        if no and no not in seen:
            seen.append(no)
    return seen


def format_stop_contract_export_label(
    kind: StopKind,
    contracts: Optional[list],
    customer_name: Optional[str],
) -> str:
    """与前端列表一致：有编号显示编号；山峡/云栋缺合同 → 装货出库 / 送货入库。"""
    nos = _contract_nos_from_stop_links(contracts)
    if nos:
        return "、".join(nos)
    if is_internal_customer_name(customer_name):
        return "出库" if kind == "load" else "入库"
    return ""


def _load_contract_nos_by_plan(
    db: Session, tenant_no: str, plan_ids: list[str]
) -> dict[str, list[str]]:
    if not plan_ids:
        return {}
    rows = (
        db.query(PlPlanContract)
        .filter(
            PlPlanContract.tenant_no == tenant_no,
            PlPlanContract.del_flag == 0,
            PlPlanContract.plan_id.in_(plan_ids),
        )
        .order_by(PlPlanContract.order_num.asc(), PlPlanContract.create_time.asc())
        .all()
    )
    out: dict[str, list[str]] = {pid: [] for pid in plan_ids}
    for row in rows:
        no = (row.contract_no or "").strip()
        if not no:
            continue
        bucket = out.setdefault(row.plan_id, [])
        if no not in bucket:
            bucket.append(no)
    return out


PLAN_TYPE_LABELS = {
    "direct": "直销单",
    "inbound": "入库单",
    "outbound": "出库单",
}

ARCHIVE_STATUS_LABELS = {
    "archived": "已归档",
    "unarchived": "未归档",
    "draft": "已暂存",
}

FOLLOW_STATUS_LABELS = {
    "drafting": "草稿中",
    "wait_notice": "等通知",
    "pending_arrange": "待安排",
    "arranged": "已安排",
    "completed": "已完成",
    "cancelled": "已取消",
    "draft": "待安排",
    "processing": "进行中",
}

FREIGHT_TYPE_LABELS = {
    "by_weight": "按重量",
    "by_trip": "按趟",
}


def resolve_archive_list_io_column(kind: StopKind, customer_name: Optional[str]) -> str:
    """装货/送货段入库出库列方向（与前端 resolveArchiveListIoColumn 一致）。"""
    internal = is_internal_customer_name(customer_name)
    if kind == "load":
        return "outbound" if internal else "inbound"
    return "inbound" if internal else "outbound"


def _format_date_value(value: Optional[Union[date, datetime, str]]) -> str:
    if value is None:
        return ""
    return str(value)[:10]


def _format_plate_display(license_plate: Optional[str], trailer_no: Optional[str]) -> str:
    plate = (license_plate or "").strip()
    trailer = (trailer_no or "").strip()
    if not plate and not trailer:
        return ""
    if plate and trailer:
        return f"{plate}{trailer}"
    return plate or trailer


def _get_stop_archive_actual_qty(product: PlanStopProductRead, kind: StopKind) -> Optional[Decimal]:
    return product.inbound_qty if kind == "load" else product.outbound_qty


def _get_stop_archive_unit_price(product: PlanStopProductRead, kind: StopKind) -> Optional[Decimal]:
    return product.inbound_price if kind == "load" else product.outbound_price


def _get_stop_archive_amount(product: PlanStopProductRead, kind: StopKind) -> Optional[Decimal]:
    stored = product.inbound_amount if kind == "load" else product.outbound_amount
    if stored is not None:
        return stored
    qty = _get_stop_archive_actual_qty(product, kind)
    price = _get_stop_archive_unit_price(product, kind)
    if qty is not None and price is not None:
        return qty * price
    return None


def _stop_time(kind: StopKind, stop: Union[PlanLoadRead, PlanDeliveryRead]) -> str:
    if kind == "load":
        return _format_date_value(getattr(stop, "load_time", None))
    return _format_date_value(getattr(stop, "delivery_time", None))


def _load_legacy_products_by_plan(
    db: Session, tenant_no: str, plan_ids: list[str]
) -> dict[str, list[PlPlanProduct]]:
    if not plan_ids:
        return {}
    products = (
        db.query(PlPlanProduct)
        .filter(
            PlPlanProduct.tenant_no == tenant_no,
            PlPlanProduct.del_flag == 0,
            PlPlanProduct.plan_id.in_(plan_ids),
        )
        .order_by(PlPlanProduct.order_num)
        .all()
    )
    grouped: dict[str, list[PlPlanProduct]] = {}
    for product in products:
        grouped.setdefault(product.plan_id, []).append(product)
    return grouped


def _plan_common_export_fields(
    plan: PlPlan,
    transport: Optional[PlTransport],
    *,
    contract_nos: Optional[list[str]] = None,
) -> dict:
    freight_type_raw = transport.freight_type if transport else "by_weight"
    freight_type_label = FREIGHT_TYPE_LABELS.get(freight_type_raw, freight_type_raw or "")
    freight_price = transport.freight_price if transport else None
    freight_amount = plan.freight_amount
    if freight_amount is None and transport is not None:
        freight_amount = transport.freight_amount
    plan_date = _format_date_value(plan.plan_date)
    link_nos = contract_nos or []
    return {
        "planId": plan.id or "",
        "planNo": plan.plan_no or "",
        "contractNo": _unique_contract_nos(plan.contract_no, *link_nos),
        "planDate": plan_date,
        "archiveStatus": ARCHIVE_STATUS_LABELS.get(plan.archive_status or "", plan.archive_status or ""),
        "followStatus": FOLLOW_STATUS_LABELS.get(plan.follow_status or "", plan.follow_status or ""),
        "planType": PLAN_TYPE_LABELS.get(plan.plan_type or "", plan.plan_type or ""),
        "licensePlate": _format_plate_display(plan.license_plate, plan.trailer_no),
        "erpEntered": "是" if int(plan.erp_entered or 0) == 1 else "否",
        "freightType": freight_type_label,
        "freightPrice": freight_price,
        "freightAmount": freight_amount,
        "remark": plan.remark or "",
    }


def _empty_pair_side_fields(*, side: str) -> dict:
    """side: load | delivery"""
    prefix = "load" if side == "load" else "delivery"
    return {
        f"{prefix}Customer": "",
        f"{prefix}Address": "",
        f"{prefix}Time": "",
        f"{prefix}PlanQty": None,
        f"{prefix}ActualQty": None,
        f"{prefix}InboundQty": None,
        f"{prefix}OutboundQty": None,
        f"{prefix}UnitPrice": None,
        f"{prefix}Amount": None,
    }


def _empty_product_identity_fields() -> dict:
    return {
        "productName": "",
        "brandName": "",
        "aliasName": "",
        "model": "",
        "packageSpec": "",
        "unit": "",
    }


def _format_export_brand_name(plan_product: Optional[PlPlanProduct]) -> str:
    """与表单「品牌」列一致：仅指定品牌时导出品牌名。"""
    if plan_product is None:
        return ""
    if (plan_product.brand_mode or "").strip() != "required":
        return ""
    return (plan_product.brand_name or "").strip()


def _resolve_export_product_display(
    plan_product: Optional[PlPlanProduct],
    stop_product: Optional[PlanStopProductRead],
    *,
    standard_by_id: dict[str, str],
    alias_options_by_id: dict[str, list[str]],
) -> tuple[str, str]:
    """返回 (展示用产品名称, 别名)。"""
    saved_name = ""
    product_id = ""
    if plan_product is not None:
        saved_name = plan_product.product_name or ""
        product_id = plan_product.product_id or ""
    elif stop_product is not None:
        saved_name = stop_product.product_name or ""
        product_id = stop_product.product_id or ""
    display_name, alias = resolve_product_display_names(
        saved_product_name=saved_name,
        product_id=product_id,
        standard_by_id=standard_by_id,
        alias_options_by_id=alias_options_by_id,
    )
    return (display_name or saved_name or "").strip(), (alias or "").strip()


def _lookup_plan_product(
    stop_product: PlanStopProductRead,
    plan_products_by_id: dict[str, PlPlanProduct],
    plan_products_by_product_id: dict[str, PlPlanProduct],
) -> Optional[PlPlanProduct]:
    plan_product_id = str(getattr(stop_product, "plan_product_id", None) or "").strip()
    if plan_product_id and plan_product_id in plan_products_by_id:
        return plan_products_by_id[plan_product_id]
    product_id = str(stop_product.product_id or "").strip()
    if product_id and product_id in plan_products_by_product_id:
        return plan_products_by_product_id[product_id]
    return None


def _product_identity_from_stop(
    product: PlanStopProductRead,
    *,
    plan_product: Optional[PlPlanProduct] = None,
    standard_by_id: Optional[dict[str, str]] = None,
    alias_options_by_id: Optional[dict[str, list[str]]] = None,
) -> dict:
    display_name, alias_name = _resolve_export_product_display(
        plan_product,
        product,
        standard_by_id=standard_by_id or {},
        alias_options_by_id=alias_options_by_id or {},
    )
    return {
        "productName": display_name or (product.product_name or ""),
        "brandName": _format_export_brand_name(plan_product),
        "aliasName": alias_name,
        "model": product.model or "",
        "packageSpec": product.package_spec or "",
        "unit": product.unit or "",
    }


def _segment_slot_customer(
    kind: str,
    load: Optional[PlanLoadRead],
    delivery: Optional[PlanDeliveryRead],
) -> str:
    if kind == "load" and load is not None:
        return load.customer_name or ""
    if kind == "delivery" and delivery is not None:
        return delivery.customer_name or ""
    return ""


def _build_archive_segment_row(
    row_no: int,
    plan_common: dict,
    kind: str,
    load: Optional[PlanLoadRead],
    delivery: Optional[PlanDeliveryRead],
    delivery_seq: Optional[int],
    product: Optional[PlanStopProductRead],
    *,
    plan_products_by_id: dict[str, PlPlanProduct],
    plan_products_by_product_id: dict[str, PlPlanProduct],
    standard_by_id: dict[str, str],
    alias_options_by_id: dict[str, list[str]],
) -> dict:
    """一段次×一个产品一行：只填本侧客户/地址/时间/合同与本侧量价。"""
    fallback_contract = str(plan_common.get("contractNo") or "")
    row = {
        **plan_common,
        "rowNo": row_no,
        "_stopKind": kind,
        "_deliverySeq": delivery_seq,
        "stopSegment": format_stop_segment_label(kind, delivery_seq),
        "loadCustomer": "",
        "loadAddress": "",
        "loadTime": "",
        "deliveryCustomer": "",
        "deliveryAddress": "",
        "deliveryTime": "",
        "contractNo": fallback_contract,
        **_empty_product_identity_fields(),
        "planQty": None,
        "actualQty": None,
        "unitPrice": None,
        "amount": None,
    }
    if kind == "load" and load is not None:
        customer_name = load.customer_name or ""
        row["loadCustomer"] = customer_name
        row["loadAddress"] = load.address or ""
        row["loadTime"] = _stop_time("load", load)
        row["contractNo"] = format_stop_contract_export_label(
            "load", load.contracts, customer_name
        ) or fallback_contract
    elif kind == "delivery" and delivery is not None:
        customer_name = delivery.customer_name or ""
        row["deliveryCustomer"] = customer_name
        row["deliveryAddress"] = delivery.address or ""
        row["deliveryTime"] = _stop_time("delivery", delivery)
        row["contractNo"] = format_stop_contract_export_label(
            "delivery", delivery.contracts, customer_name
        ) or fallback_contract
    if product is not None:
        plan_product = _lookup_plan_product(
            product, plan_products_by_id, plan_products_by_product_id
        )
        row.update(
            _product_identity_from_stop(
                product,
                plan_product=plan_product,
                standard_by_id=standard_by_id,
                alias_options_by_id=alias_options_by_id,
            )
        )
        row["planQty"] = product.plan_qty
        row["actualQty"] = _get_stop_archive_actual_qty(product, kind)
        row["unitPrice"] = _get_stop_archive_unit_price(product, kind)
        row["amount"] = _get_stop_archive_amount(product, kind)
    return row


def _append_legacy_plan_product_rows(
    rows: list[dict],
    row_no: int,
    plan: PlPlan,
    plan_common: dict,
    products: list[PlPlanProduct],
    *,
    standard_by_id: Optional[dict[str, str]] = None,
    alias_options_by_id: Optional[dict[str, list[str]]] = None,
) -> int:
    """无段表数据时回退计划产品级导出（兼容旧数据）。"""
    product_rows = products or [None]
    fallback_no = str(plan_common.get("contractNo") or "")
    if fallback_no:
        legacy_contract_no = fallback_no
    else:
        legacy_contract_no = _unique_contract_nos(
            format_stop_contract_export_label("load", None, plan.supplier_name),
            format_stop_contract_export_label(
                "delivery", None, plan.customer_name or plan.destination_name
            ),
        )
    for product in product_rows:
        row_no += 1
        row = {
            **plan_common,
            "rowNo": row_no,
            "_stopKind": "",
            "_deliverySeq": None,
            "stopSegment": "",
            "deliveryStopKind": "",
            **_empty_pair_side_fields(side="load"),
            **_empty_pair_side_fields(side="delivery"),
            **_empty_product_identity_fields(),
            "loadCustomer": plan.supplier_name or plan.customer_name or "",
            "loadAddress": "",
            "deliveryCustomer": plan.customer_name or "",
            "deliveryAddress": plan.destination_name or "",
            "deliveryTime": _format_date_value(plan.delivery_time),
            "contractNo": legacy_contract_no,
            # 兼容旧字段
            "stopKind": "",
            "stopCustomer": plan.customer_name or plan.supplier_name or "",
            "stopAddress": plan.destination_name or "",
            "stopTime": _format_date_value(plan.delivery_time),
            "planQty": None,
            "actualQty": None,
            "inboundQty": None,
            "outboundQty": None,
            "unitPrice": None,
            "amount": None,
        }
        if product is not None:
            display_name, alias_name = _resolve_export_product_display(
                product,
                None,
                standard_by_id=standard_by_id or {},
                alias_options_by_id=alias_options_by_id or {},
            )
            row.update(
                {
                    "productName": display_name or (product.product_name or ""),
                    "brandName": _format_export_brand_name(product),
                    "aliasName": alias_name,
                    "model": product.model or "",
                    "packageSpec": product.package_spec or "",
                    "unit": product.unit or "",
                    "loadPlanQty": product.quantity,
                    "loadActualQty": product.actual_qty,
                    "loadInboundQty": product.inbound_qty,
                    "loadOutboundQty": product.outbound_qty,
                    "loadUnitPrice": product.inbound_price or product.outbound_price,
                    "loadAmount": product.inbound_amount or product.outbound_amount,
                    "planQty": product.quantity,
                    "actualQty": product.actual_qty,
                    "inboundQty": product.inbound_qty,
                    "outboundQty": product.outbound_qty,
                    "unitPrice": product.inbound_price or product.outbound_price,
                    "amount": product.inbound_amount or product.outbound_amount,
                }
            )
        rows.append(row)
    return row_no


def build_plan_archive_export_rows(
    db: Session,
    tenant_no: str,
    plans: list[PlPlan],
    transports_by_id: dict[str, PlTransport],
    *,
    stop_kind: Optional[str] = None,
    stop_customer_keywords: Optional[list] = None,
) -> list[dict]:
    """构建归档导出数据行。

    默认按段次×产品展开：先装货产品行，再各送货段产品行。
    stop_kind 为 load / delivery 时只保留对应侧。
    stop_customer_keywords 非空时按该行所属侧客户过滤。
    无段表数据时回退计划产品级导出，stopSegment 为空。
    """
    if not plans:
        return []

    include_load = stop_kind != "delivery"
    include_delivery = stop_kind != "load"
    keywords = [str(item).strip() for item in (stop_customer_keywords or []) if str(item).strip()]

    def _keep_customer(name: Optional[str]) -> bool:
        if not keywords:
            return True
        return customer_name_matches_keywords(name, keywords)

    plan_ids = [plan.id for plan in plans]
    stops_by_plan = load_plan_stops_grouped(db, tenant_no, plan_ids)
    legacy_products_by_plan = _load_legacy_products_by_plan(db, tenant_no, plan_ids)
    contract_nos_by_plan = _load_contract_nos_by_plan(db, tenant_no, plan_ids)
    crm_product_ids: list[str] = []
    for products in legacy_products_by_plan.values():
        for product in products:
            if product.product_id:
                crm_product_ids.append(product.product_id)
    for load_read, delivery_reads in stops_by_plan.values():
        for stop in ([load_read] if load_read is not None else []) + list(delivery_reads or []):
            for stop_product in stop.products or []:
                if stop_product.product_id:
                    crm_product_ids.append(stop_product.product_id)
    standard_by_id, alias_options_by_id = load_crm_product_alias_maps(
        db,
        tenant_no=tenant_no,
        product_ids=crm_product_ids,
    )

    rows: list[dict] = []
    row_no = 0
    for plan in plans:
        transport = transports_by_id.get(plan.transport_id) if plan.transport_id else None
        plan_common = _plan_common_export_fields(
            plan,
            transport,
            contract_nos=contract_nos_by_plan.get(plan.id, []),
        )
        load_read, delivery_reads = stops_by_plan.get(plan.id, (None, []))
        plan_products = legacy_products_by_plan.get(plan.id, [])
        plan_products_by_id = {str(p.id): p for p in plan_products if p.id}
        plan_products_by_product_id: dict[str, PlPlanProduct] = {}
        for product in plan_products:
            pid = str(product.product_id or "").strip()
            if pid and pid not in plan_products_by_product_id:
                plan_products_by_product_id[pid] = product

        has_stops = load_read is not None or bool(delivery_reads)
        if not has_stops:
            if not include_load:
                continue
            legacy_customer = plan.customer_name or plan.supplier_name or ""
            if not _keep_customer(legacy_customer):
                continue
            row_no = _append_legacy_plan_product_rows(
                rows,
                row_no,
                plan,
                plan_common,
                plan_products,
                standard_by_id=standard_by_id,
                alias_options_by_id=alias_options_by_id,
            )
            continue

        for kind, slot_load, slot_delivery, seq, stop_product in iter_segment_product_slots(
            load_read, delivery_reads
        ):
            if kind == "load" and not include_load:
                continue
            if kind == "delivery" and not include_delivery:
                continue
            if not _keep_customer(_segment_slot_customer(kind, slot_load, slot_delivery)):
                continue
            row_no += 1
            rows.append(
                _build_archive_segment_row(
                    row_no,
                    plan_common,
                    kind,
                    slot_load,
                    slot_delivery,
                    seq,
                    stop_product,
                    plan_products_by_id=plan_products_by_id,
                    plan_products_by_product_id=plan_products_by_product_id,
                    standard_by_id=standard_by_id,
                    alias_options_by_id=alias_options_by_id,
                )
            )

    return rows


ARCHIVE_MERGED_SHEET_TITLE = "计划归档（合并）"

# 与列表 PL_PLAN_SPAN_PROPS 对应：整张计划纵向合并（含装货侧）。
_PLAN_LEVEL_MERGE_FIELDS = frozenset(
    {
        "rowNo",
        "planNo",
        "planDate",
        "archiveStatus",
        "followStatus",
        "planType",
        "erpEntered",
        "licensePlate",
        "freightType",
        "freightPrice",
        "freightAmount",
        "remark",
        "loadCustomer",
        "loadAddress",
        "loadTime",
    }
)
# 与列表 PL_DELIVERY_SPAN_PROPS 对应：同一送货段合并；仅一个送货段时连装货行一起合并。
_DELIVERY_LEVEL_MERGE_FIELDS = frozenset(
    {
        "deliveryCustomer",
        "deliveryAddress",
        "deliveryTime",
    }
)


def _iter_equal_spans(rows: list[dict], key_fn) -> list[tuple[int, int]]:
    """返回需要合并的闭区间（数据行下标，不含表头）。单行不合并。"""
    spans: list[tuple[int, int]] = []
    index = 0
    total = len(rows)
    while index < total:
        key = key_fn(rows[index])
        end = index + 1
        while end < total and key_fn(rows[end]) == key:
            end += 1
        if end - index > 1:
            spans.append((index, end - 1))
        index = end
    return spans


_PLAN_LIST_PLAN_MERGE_FIELDS = frozenset(
    {
        "planNo",
        "belongsCompany",
        "followStatus",
        "planDate",
        "deliveryTimes",
        "planType",
        "licensePlate",
        "personnelSummary",
        "followUserName",
        "archiveStatus",
        "erpEntered",
        "hazardCertReady",
        "loadCustomer",
        "loadAddressTime",
        "loadDibang",
    }
)
_PLAN_LIST_DELIVERY_MERGE_FIELDS = frozenset(
    {
        "deliveryCustomer",
        "deliveryAddressTime",
        "deliveryDibang",
    }
)
_PLAN_LIST_LOAD_COPY_FIELDS = ("loadCustomer", "loadAddressTime", "loadDibang")


def _export_plan_group_key(row: dict) -> str:
    return str(row.get("planId") or row.get("id") or "")


def prepare_archive_list_display_rows(
    rows: list[dict],
    *,
    contract_field: str = "contractNo",
    load_fields: tuple[str, ...] = ("loadCustomer", "loadAddress", "loadTime"),
    delivery_fields: Optional[frozenset] = None,
    number_plans: bool = True,
    join_plan_fields: tuple[str, ...] = (),
) -> list[dict]:
    """按列表合并规则整理单元格取值。

    序号按计划计，一张计划一个号（归档导出）。
    只有一个送货段时，送货侧字段写到该计划首行，以便和装货行合并后仍能看见。
    多个送货段时，装货行的送货客户为「—」。
    """
    if delivery_fields is None:
        delivery_fields = _DELIVERY_LEVEL_MERGE_FIELDS
    prepared: list[dict] = []
    plan_index = 0
    cursor = 0
    while cursor < len(rows):
        plan_id = _export_plan_group_key(rows[cursor])
        end = cursor + 1
        while end < len(rows) and _export_plan_group_key(rows[end]) == plan_id:
            end += 1
        group = [dict(item) for item in rows[cursor:end]]
        plan_index += 1
        delivery_seqs: list[int] = []
        for item in group:
            if item.get("_stopKind") == "delivery" and item.get("_deliverySeq") is not None:
                seq = int(item["_deliverySeq"])
                if seq not in delivery_seqs:
                    delivery_seqs.append(seq)
        sole_seq = delivery_seqs[0] if len(delivery_seqs) == 1 else None
        for item in group:
            kind = item.get("_stopKind") or ""
            if kind == "load":
                merge_seq = sole_seq if sole_seq is not None else 0
            elif kind == "delivery":
                merge_seq = int(item.get("_deliverySeq") or 1)
            else:
                merge_seq = 1
            item["_mergeDeliverySeq"] = merge_seq
            item["_contractMergeKey"] = (
                f"{kind}|{merge_seq}|{item.get(contract_field) or ''}"
            )
            if number_plans:
                item["rowNo"] = plan_index
        if sole_seq is not None:
            delivery_row = next((item for item in group if item.get("_stopKind") == "delivery"), None)
            if delivery_row is not None:
                for field in delivery_fields:
                    group[0][field] = delivery_row.get(field) or ""
        else:
            for item in group:
                if item.get("_mergeDeliverySeq") != 0:
                    continue
                if not item.get("deliveryCustomer"):
                    item["deliveryCustomer"] = "—"
        load_row = next((item for item in group if item.get("_stopKind") == "load"), None)
        if load_row is not None:
            for field in load_fields:
                if not group[0].get(field):
                    group[0][field] = load_row.get(field) or ""
        for field in join_plan_fields:
            seen: list[str] = []
            for item in group:
                text = str(item.get(field) or "").strip()
                if text and text not in seen:
                    seen.append(text)
            if seen:
                group[0][field] = "\n".join(seen)
        prepared.extend(group)
        cursor = end
    return prepared


def append_archive_list_merge_sheet(
    wb,
    columns,
    rows: list[dict],
    resolver,
    *,
    sheet_title: Optional[str] = None,
    plan_fields: Optional[frozenset] = None,
    delivery_fields: Optional[frozenset] = None,
    contract_field: str = "contractNo",
    load_fields: tuple[str, ...] = ("loadCustomer", "loadAddress", "loadTime"),
    number_plans: bool = True,
    join_plan_fields: tuple[str, ...] = (),
) -> None:
    """追加按列表合并的 sheet。默认标题为「计划归档（合并）」。"""
    from openpyxl.styles import Alignment

    if delivery_fields is None:
        delivery_fields = _DELIVERY_LEVEL_MERGE_FIELDS
    if plan_fields is None:
        plan_fields = _PLAN_LEVEL_MERGE_FIELDS
    display_rows = prepare_archive_list_display_rows(
        list(rows),
        contract_field=contract_field,
        load_fields=load_fields,
        delivery_fields=delivery_fields,
        number_plans=number_plans,
        join_plan_fields=join_plan_fields,
    )
    sheet = wb.create_sheet((sheet_title or ARCHIVE_MERGED_SHEET_TITLE)[:31])
    sheet.append([column.title for column in columns])
    for row in display_rows:
        sheet.append(resolver.row_to_cells(row, columns))

    field_column = {column.field: index + 1 for index, column in enumerate(columns)}
    vertical = Alignment(vertical="center", wrap_text=True)

    def merge_fields(fields, spans: list[tuple[int, int]]) -> None:
        for field in fields:
            column_index = field_column.get(field)
            if not column_index:
                continue
            for start, end in spans:
                sheet.merge_cells(
                    start_row=start + 2,
                    start_column=column_index,
                    end_row=end + 2,
                    end_column=column_index,
                )
                sheet.cell(start + 2, column_index).alignment = vertical

    plan_key = _export_plan_group_key
    plan_spans = _iter_equal_spans(display_rows, plan_key)
    merged_plan_fields = set(plan_fields)
    merged_plan_fields.update(field for field in field_column if str(field).startswith("attach"))
    merge_fields(merged_plan_fields, plan_spans)
    merge_fields(
        delivery_fields,
        _iter_equal_spans(
            display_rows,
            lambda row: (_export_plan_group_key(row), row.get("_mergeDeliverySeq")),
        ),
    )
    if contract_field in field_column:
        merge_fields(
            [contract_field],
            _iter_equal_spans(
                display_rows,
                lambda row: (_export_plan_group_key(row), row.get("_contractMergeKey")),
            ),
        )


def export_plan_list_xlsx_response(
    db,
    *,
    tenant_no: str,
    sheet_title: str,
    columns,
    rows: list[dict],
    filename_stem: str,
):
    """运输计划 / 危化品证列表 Excel：明细页 + 按列表合并的第二页。"""
    from app.utils.excel_export import (
        DictLabelResolver,
        ExportValidationError,
        assert_export_row_count,
        workbook_to_streaming_response,
    )
    from openpyxl import Workbook

    assert_export_row_count(len(rows))
    if not columns:
        raise ExportValidationError("没有可导出的列")
    resolver = DictLabelResolver(db, columns, tenant_no=tenant_no)
    workbook = Workbook()
    detail = workbook.active
    detail.title = sheet_title[:31]
    detail.append([column.title for column in columns])
    for row in rows:
        detail.append(resolver.row_to_cells(row, columns))
    append_archive_list_merge_sheet(
        workbook,
        columns,
        rows,
        resolver,
        sheet_title=f"{sheet_title}（合并）",
        plan_fields=_PLAN_LIST_PLAN_MERGE_FIELDS,
        delivery_fields=_PLAN_LIST_DELIVERY_MERGE_FIELDS,
        contract_field="productContract",
        load_fields=_PLAN_LIST_LOAD_COPY_FIELDS,
        number_plans=False,
        join_plan_fields=("deliveryTimes",),
    )
    return workbook_to_streaming_response(workbook, filename_stem=filename_stem)


def export_plan_archive_xlsx_response(
    db,
    *,
    tenant_no: str,
    columns,
    rows: list[dict],
    filename_stem: str,
):
    """归档 Excel：第一页为段次明细，第二页为列表合并样式。"""
    from app.utils.excel_export import (
        DictLabelResolver,
        ExportValidationError,
        assert_export_row_count,
        workbook_to_streaming_response,
    )
    from openpyxl import Workbook

    assert_export_row_count(len(rows))
    if not columns:
        raise ExportValidationError("没有可导出的列")
    resolver = DictLabelResolver(db, columns, tenant_no=tenant_no)
    workbook = Workbook()
    detail = workbook.active
    detail.title = "计划归档"
    detail.append([column.title for column in columns])
    for row in rows:
        detail.append(resolver.row_to_cells(row, columns))
    append_archive_list_merge_sheet(workbook, columns, rows, resolver)
    return workbook_to_streaming_response(workbook, filename_stem=filename_stem)