"""运输计划司机免登录公共 API"""
from __future__ import annotations

import json
import os
from datetime import date, datetime
from decimal import Decimal
from typing import Optional

from fastapi import APIRouter, Depends, File, Form, HTTPException, Query, UploadFile
from sqlalchemy import and_, func, or_
from sqlalchemy.orm import Session

from app.core.storage import storage
from app.core.attachment_biz import resolve_upload_folder
from app.core.config import settings
from app.core.database import get_db
from app.core.response import error_response, success_response
from app.crud import oss as oss_svc
from app.models.crm_models import CrmProductBrand
from app.models.pl_models import (
    PlPlan,
    PlPlanDelivery,
    PlPlanLoad,
    PlPlanProduct,
    PlPlanTransport,
    PlTransport,
    PlTransportProductBrandQty,
    PlTransportProductFeedback,
)
from app.schemas.pl.io_order import BrandOption, BrandQtyItem
from app.schemas.pl.resource_snapshot import parse_resource_snapshot
from app.schemas.pl.transport import (
    PublicTransportDriverStopFeedback,
    PublicTransportFeedback,
    PublicTransportHistoryPageRead,
    PublicTransportHistoryProductRead,
    PublicTransportHistoryRecordRead,
    PublicTransportHistoryStopProductRead,
    PublicTransportHistoryStopRead,
    PublicTransportPageRead,
    PublicTransportPersonnelRead,
    PublicTransportPlanProductRead,
    PublicTransportStopProductRead,
    PublicTransportStopRead,
)
from app.services.pl_dibang_bridge_service import plan_has_load_stop
from app.services.pl_feedback_brand_qty import (
    persist_transport_product_feedback,
    require_brand_qtys_if_needed,
)
from app.services.pl_transport_stop_feedback_service import (
    PublicStopProductRow,
    load_driver_stop_segments,
    save_driver_stop_feedback,
)
from app.services.pl_product_display import (
    load_crm_product_alias_maps,
    resolve_product_display_names,
)
from app.utils.excel_export import load_dict_label_maps

router = APIRouter(prefix="/public/pl/transport", tags=["运输计划-司机公共"])

CRM_PRODUCT_UNIT = "crm_product_unit"


def _resolve_unit_label(unit_map: dict[str, str], unit_code: Optional[str]) -> str:
    code = (unit_code or "").strip()
    if not code:
        return "吨"
    return unit_map.get(code, code)


def _build_stop_product_reads(
    *,
    stop_products: list[PublicStopProductRow],
    plan_products_by_id: dict[str, PlPlanProduct],
    unit_map: dict[str, str],
    brand_options_by_product: dict[str, list[BrandOption]],
    standard_by_id: dict[str, str],
    alias_options_by_id: dict[str, list[str]],
) -> list[PublicTransportStopProductRead]:
    reads: list[PublicTransportStopProductRead] = []
    for row in stop_products:
        plan_prod = plan_products_by_id.get(row.plan_product_id)
        product_id = (row.product_id or (plan_prod.product_id if plan_prod else "") or "").strip()
        display_name, alias_name = resolve_product_display_names(
            saved_product_name=row.product_name,
            product_id=product_id,
            standard_by_id=standard_by_id,
            alias_options_by_id=alias_options_by_id,
        )
        brand_qtys = None
        if row.brand_qtys:
            brand_qtys = [
                BrandQtyItem(
                    brand_id=str(item.get("brandId") or item.get("brand_id") or ""),
                    brand_name=item.get("brandName") or item.get("brand_name"),
                    qty=item.get("qty") or 0,
                )
                for item in row.brand_qtys
                if isinstance(item, dict)
            ] or None
        reads.append(
            PublicTransportStopProductRead(
                stop_product_id=row.stop_product_id,
                plan_product_id=row.plan_product_id,
                product_name=display_name,
                alias_name=alias_name,
                model=row.model,
                package_spec=row.package_spec,
                unit=_resolve_unit_label(unit_map, row.unit),
                quantity=row.plan_qty,
                remark=row.remark,
                brand_mode=plan_prod.brand_mode if plan_prod else None,
                brand_id=plan_prod.brand_id if plan_prod else None,
                brand_name=plan_prod.brand_name if plan_prod else None,
                brand_options=brand_options_by_product.get(product_id) or None,
                actual_qty=row.actual_qty,
                brand_qtys=brand_qtys,
            )
        )
    return reads


def _get_transport_by_token(db: Session, token: str) -> PlTransport:
    transport = (
        db.query(PlTransport)
        .filter(
            PlTransport.driver_access_token == token,
            PlTransport.del_flag == 0,
        )
        .first()
    )
    if not transport:
        raise HTTPException(status_code=404, detail="链接无效或已失效")
    return transport


def _parse_feedback_images(raw: Optional[str]) -> list[str]:
    if not raw:
        return []
    try:
        parsed = json.loads(raw)
        if isinstance(parsed, list):
            return [str(item) for item in parsed if item]
    except (TypeError, json.JSONDecodeError):
        pass
    return [part.strip() for part in raw.split(",") if part.strip()]


def _format_plan_date(value) -> Optional[str]:
    if value is None:
        return None
    if isinstance(value, datetime):
        return value.strftime("%Y-%m-%d")
    if isinstance(value, date):
        return value.isoformat()
    return str(value)


def _normalize_main_plate(value: Optional[str]) -> str:
    return (value or "").strip()


def _parse_history_date(raw: Optional[str]) -> Optional[date]:
    text = (raw or "").strip()
    if not text:
        return None
    try:
        return date.fromisoformat(text)
    except ValueError:
        return None


def _as_date(value) -> Optional[date]:
    if value is None:
        return None
    if isinstance(value, datetime):
        return value.date()
    if isinstance(value, date):
        return value
    return None


def _history_matches_date(pickup_time, delivery_time, day: date) -> bool:
    return _as_date(pickup_time) == day or _as_date(delivery_time) == day


def _history_status_label(plan_voided: bool, plan_archived: bool) -> str:
    if plan_voided:
        return "已作废"
    if plan_archived:
        return "已归档"
    return "进行中"


def _build_history_stop_reads(
    db: Session,
    *,
    tenant_no: str,
    plan: PlPlan,
    transport: PlTransport,
) -> list[PublicTransportHistoryStopRead]:
    if not plan_has_load_stop(db, tenant_no, plan.id):
        return []

    plan_products = (
        db.query(PlPlanProduct)
        .filter(
            PlPlanProduct.plan_id == plan.id,
            PlPlanProduct.tenant_no == tenant_no,
            PlPlanProduct.del_flag == 0,
        )
        .all()
    )
    plan_products_by_id = {row.id: row for row in plan_products}
    crm_product_ids = {
        (row.product_id or "").strip() for row in plan_products if (row.product_id or "").strip()
    }
    standard_by_id, alias_options_by_id = load_crm_product_alias_maps(
        db, tenant_no=tenant_no, product_ids=crm_product_ids
    )
    unit_map = load_dict_label_maps(db, [CRM_PRODUCT_UNIT], tenant_no=tenant_no).get(
        CRM_PRODUCT_UNIT, {}
    )

    load_row = (
        db.query(PlPlanLoad)
        .filter(
            PlPlanLoad.plan_id == plan.id,
            PlPlanLoad.tenant_no == tenant_no,
            PlPlanLoad.del_flag == 0,
        )
        .first()
    )
    delivery_rows = (
        db.query(PlPlanDelivery)
        .filter(
            PlPlanDelivery.plan_id == plan.id,
            PlPlanDelivery.tenant_no == tenant_no,
            PlPlanDelivery.del_flag == 0,
        )
        .all()
    )
    delivery_time_by_id = {row.id: row.delivery_time for row in delivery_rows}
    load_time = load_row.load_time if load_row else None

    segments = load_driver_stop_segments(
        db,
        tenant_no=tenant_no,
        plan_id=plan.id,
        transport_id=transport.id,
    )

    reads: list[PublicTransportHistoryStopRead] = []
    for segment in segments:
        stop_time = load_time if segment.stop_type == "load" else delivery_time_by_id.get(segment.stop_id)
        stop_products: list[PublicTransportHistoryStopProductRead] = []
        for row in segment.products:
            plan_prod = plan_products_by_id.get(row.plan_product_id)
            product_id = (row.product_id or (plan_prod.product_id if plan_prod else "") or "").strip()
            display_name, _alias_name = resolve_product_display_names(
                saved_product_name=row.product_name,
                product_id=product_id,
                standard_by_id=standard_by_id,
                alias_options_by_id=alias_options_by_id,
            )
            stop_products.append(
                PublicTransportHistoryStopProductRead(
                    product_name=display_name or row.product_name or "—",
                    model=row.model,
                    package_spec=row.package_spec,
                    quantity=row.plan_qty,
                    unit=_resolve_unit_label(unit_map, row.unit),
                )
            )
        reads.append(
            PublicTransportHistoryStopRead(
                stop_type=segment.stop_type,
                seq=segment.seq,
                label=segment.label,
                customer_name=segment.customer_name,
                address=segment.address,
                stop_time=stop_time,
                products=stop_products,
            )
        )
    return reads


def _build_driver_url(token: str) -> str:
    origin = (settings.PUBLIC_WEB_ORIGIN or "").rstrip("/")
    return f"{origin}/#/public/pl/transport/{token}"


def _resolve_driver_link_flags(
    plan: Optional[PlPlan], transport: PlTransport
) -> tuple[bool, bool]:
    """返回 (作废, 归档)。"""
    voided = (
        (plan is not None and plan.follow_status == "cancelled")
        or transport.transport_status == "cancelled"
    )
    archived = bool(plan is not None and plan.archive_status == "archived")
    return voided, archived


def _resolve_other_personnel(transport: PlTransport, plan: Optional[PlPlan]) -> list[PublicTransportPersonnelRead]:
    raw = transport.resource_snapshot or (plan.resource_snapshot if plan else None)
    snapshot = parse_resource_snapshot(raw)
    if not snapshot or not snapshot.personnel_list:
        return []

    selected_driver_id = (snapshot.selected_driver_id or transport.driver_id or "").strip()
    driver_name = (transport.driver_name or "").strip()
    rows: list[PublicTransportPersonnelRead] = []
    for person in snapshot.personnel_list:
        personnel_id = (person.personnel_id or "").strip()
        personnel_name = (person.personnel_name or "").strip()
        is_primary_driver = person.role == "driver" and (
            person.is_default == 1
            or (selected_driver_id and personnel_id == selected_driver_id)
            or (driver_name and personnel_name == driver_name)
        )
        if is_primary_driver:
            continue
        rows.append(
            PublicTransportPersonnelRead(
                personnel_name=personnel_name or "—",
                phone_no=person.phone_no,
                role=person.role,
            )
        )
    return rows


def _build_public_page(db: Session, transport: PlTransport) -> PublicTransportPageRead:
    link = (
        db.query(PlPlanTransport)
        .filter(
            PlPlanTransport.transport_id == transport.id,
            PlPlanTransport.del_flag == 0,
        )
        .order_by(PlPlanTransport.create_time.desc())
        .first()
    )
    plan = None
    products: list[PlPlanProduct] = []
    if link:
        plan = (
            db.query(PlPlan)
            .filter(PlPlan.id == link.plan_id, PlPlan.del_flag == 0)
            .first()
        )
        if plan:
            products = (
                db.query(PlPlanProduct)
                .filter(PlPlanProduct.plan_id == plan.id, PlPlanProduct.del_flag == 0)
                .order_by(PlPlanProduct.order_num.asc(), PlPlanProduct.create_time.asc())
                .all()
            )

    crm_product_ids = {(p.product_id or "").strip() for p in products if (p.product_id or "").strip()}
    brand_options_by_product: dict[str, list[BrandOption]] = {}
    if crm_product_ids:
        brand_rows = (
            db.query(CrmProductBrand)
            .filter(
                CrmProductBrand.product_id.in_(list(crm_product_ids)),
                CrmProductBrand.tenant_no == transport.tenant_no,
                CrmProductBrand.status == "on",
                CrmProductBrand.del_flag == 0,
            )
            .order_by(CrmProductBrand.order_num.asc(), CrmProductBrand.create_time.asc())
            .all()
        )
        for row in brand_rows:
            brand_options_by_product.setdefault(row.product_id, []).append(
                BrandOption(brand_id=row.id, brand_name=row.brand_name or "")
            )

    feedback_by_plan_product: dict[str, PlTransportProductFeedback] = {}
    brand_qtys_by_plan_product: dict[str, list[BrandQtyItem]] = {}
    feedback_rows = (
        db.query(PlTransportProductFeedback)
        .filter(
            PlTransportProductFeedback.transport_id == transport.id,
            PlTransportProductFeedback.tenant_no == transport.tenant_no,
            PlTransportProductFeedback.del_flag == 0,
        )
        .order_by(PlTransportProductFeedback.order_num.asc())
        .all()
    )
    for fb in feedback_rows:
        feedback_by_plan_product[fb.plan_product_id] = fb

    if feedback_rows:
        feedback_ids = [fb.id for fb in feedback_rows]
        brand_qty_rows = (
            db.query(PlTransportProductBrandQty)
            .filter(
                PlTransportProductBrandQty.transport_id == transport.id,
                PlTransportProductBrandQty.tenant_no == transport.tenant_no,
                PlTransportProductBrandQty.del_flag == 0,
                PlTransportProductBrandQty.feedback_id.in_(feedback_ids),
            )
            .order_by(PlTransportProductBrandQty.order_num.asc())
            .all()
        )
        for row in brand_qty_rows:
            brand_qtys_by_plan_product.setdefault(row.plan_product_id, []).append(
                BrandQtyItem(
                    brand_id=row.brand_id or "",
                    brand_name=row.brand_name,
                    qty=row.qty or 0,
                )
            )

    standard_by_id, alias_options_by_id = load_crm_product_alias_maps(
        db, tenant_no=transport.tenant_no, product_ids=crm_product_ids
    )

    product_reads = []
    unit_map = load_dict_label_maps(
        db, [CRM_PRODUCT_UNIT], tenant_no=transport.tenant_no
    ).get(CRM_PRODUCT_UNIT, {})
    for prod in products:
        product_id = (prod.product_id or "").strip()
        options = brand_options_by_product.get(product_id) or None
        fb = feedback_by_plan_product.get(prod.id)
        brand_qtys = brand_qtys_by_plan_product.get(prod.id) or None
        display_name, alias_name = resolve_product_display_names(
            saved_product_name=prod.product_name,
            product_id=product_id,
            standard_by_id=standard_by_id,
            alias_options_by_id=alias_options_by_id,
        )
        product_reads.append(
            PublicTransportPlanProductRead(
                plan_product_id=prod.id,
                product_name=display_name,
                alias_name=alias_name,
                model=prod.model,
                package_spec=prod.package_spec,
                unit=_resolve_unit_label(unit_map, prod.unit),
                quantity=prod.quantity or prod.inbound_estimate_qty or prod.outbound_estimate_qty,
                remark=(prod.remark or "").strip() or None,
                brand_mode=prod.brand_mode,
                brand_id=prod.brand_id,
                brand_name=prod.brand_name,
                brand_options=options,
                actual_qty=fb.actual_qty if fb else None,
                brand_qtys=brand_qtys,
            )
        )

    other_personnel = _resolve_other_personnel(transport, plan)
    plan_voided, plan_archived = _resolve_driver_link_flags(plan, transport)

    stop_reads: list[PublicTransportStopRead] = []
    if plan and plan_has_load_stop(db, transport.tenant_no, plan.id):
        plan_products_by_id = {p.id: p for p in products}
        stop_reads = [
            PublicTransportStopRead(
                stop_type=segment.stop_type,
                stop_id=segment.stop_id,
                seq=segment.seq,
                label=segment.label,
                customer_name=segment.customer_name,
                address=segment.address,
                contact=segment.contact,
                notes=segment.notes,
                lng=segment.lng,
                lat=segment.lat,
                business_type=segment.business_type,
                plan_qty=segment.plan_qty,
                products=_build_stop_product_reads(
                    stop_products=segment.products,
                    plan_products_by_id=plan_products_by_id,
                    unit_map=unit_map,
                    brand_options_by_product=brand_options_by_product,
                    standard_by_id=standard_by_id,
                    alias_options_by_id=alias_options_by_id,
                ),
                attachment_urls=segment.attachment_urls,
                remark=segment.remark,
                feedback_time=segment.feedback_time,
            )
            for segment in load_driver_stop_segments(
                db,
                tenant_no=transport.tenant_no,
                plan_id=plan.id,
                transport_id=transport.id,
            )
        ]

    return PublicTransportPageRead(
        plan_no=plan.plan_no if plan else transport.transport_no,
        plan_date=_format_plan_date(plan.plan_date if plan else None),
        plan_type=plan.plan_type if plan else "",
        pickup_address=plan.pickup_address if plan else transport.start_point,
        pickup_lng=plan.pickup_lng if plan else None,
        pickup_lat=plan.pickup_lat if plan else None,
        pickup_time=plan.pickup_time if plan else None,
        pickup_contact=plan.pickup_contact if plan else None,
        pickup_notes=plan.pickup_notes if plan else None,
        destination_name=plan.destination_name if plan else None,
        destination_address=(
            (plan.destination_address or plan.destination_name) if plan else transport.end_point
        ),
        destination_lng=plan.destination_lng if plan else None,
        destination_lat=plan.destination_lat if plan else None,
        delivery_time=plan.delivery_time if plan else None,
        delivery_contact=plan.delivery_contact if plan else None,
        destination_notes=plan.destination_notes if plan else None,
        license_plate=transport.license_plate,
        driver_name=transport.driver_name,
        driver_phone=transport.driver_phone,
        other_personnel=other_personnel,
        products=product_reads,
        stops=stop_reads,
        feedback_remark=transport.feedback_remark,
        feedback_images=_parse_feedback_images(transport.feedback_images),
        feedback_qty=transport.feedback_qty,
        feedback_time=transport.feedback_time,
        plan_voided=plan_voided,
        plan_archived=plan_archived,
    )


@router.get("/{token}")
def get_public_transport(token: str, db: Session = Depends(get_db)):
    transport = _get_transport_by_token(db, token)
    page = _build_public_page(db, transport)
    return success_response(page.model_dump(by_alias=True))


@router.get("/{token}/history")
def get_public_transport_history(
    token: str,
    date: str = Query(..., description="筛选日 YYYY-MM-DD"),
    db: Session = Depends(get_db),
):
    transport = _get_transport_by_token(db, token)
    day = _parse_history_date(date)
    if day is None:
        return error_response(400, "日期格式无效，请使用 YYYY-MM-DD")

    plate = _normalize_main_plate(transport.license_plate)
    if not plate:
        page = PublicTransportHistoryPageRead(
            license_plate=None, date=day.isoformat(), records=[]
        )
        return success_response(page.model_dump(by_alias=True))

    rows = (
        db.query(PlPlan, PlTransport)
        .join(
            PlPlanTransport,
            and_(
                PlPlanTransport.plan_id == PlPlan.id,
                PlPlanTransport.del_flag == 0,
            ),
        )
        .join(
            PlTransport,
            and_(
                PlTransport.id == PlPlanTransport.transport_id,
                PlTransport.del_flag == 0,
            ),
        )
        .filter(
            PlPlan.tenant_no == transport.tenant_no,
            PlPlan.del_flag == 0,
            PlPlan.transport_status == "arranged",
            PlTransport.tenant_no == transport.tenant_no,
            PlTransport.license_plate == plate,
            or_(
                and_(PlPlan.pickup_time.isnot(None), func.date(PlPlan.pickup_time) == day),
                and_(PlPlan.delivery_time.isnot(None), func.date(PlPlan.delivery_time) == day),
            ),
        )
        .order_by(
            PlPlan.pickup_time.desc(),
            PlPlan.plan_date.desc(),
            PlPlan.create_time.desc(),
        )
        .all()
    )

    seen_plan: set[str] = set()
    plan_rows: list[tuple[PlPlan, PlTransport]] = []
    for plan, tr in rows:
        if plan.id in seen_plan:
            continue
        seen_plan.add(plan.id)
        plan_rows.append((plan, tr))

    products_by_plan: dict[str, list[PublicTransportHistoryProductRead]] = {}
    if plan_rows:
        plan_ids = [plan.id for plan, _ in plan_rows]
        product_rows = (
            db.query(PlPlanProduct)
            .filter(
                PlPlanProduct.plan_id.in_(plan_ids),
                PlPlanProduct.del_flag == 0,
            )
            .order_by(PlPlanProduct.order_num.asc(), PlPlanProduct.create_time.asc())
            .all()
        )
        crm_product_ids = {
            (p.product_id or "").strip() for p in product_rows if (p.product_id or "").strip()
        }
        standard_by_id, alias_options_by_id = load_crm_product_alias_maps(
            db, tenant_no=transport.tenant_no, product_ids=crm_product_ids
        )
        unit_map = load_dict_label_maps(
            db, [CRM_PRODUCT_UNIT], tenant_no=transport.tenant_no
        ).get(CRM_PRODUCT_UNIT, {})
        for prod in product_rows:
            product_id = (prod.product_id or "").strip()
            display_name, _alias_name = resolve_product_display_names(
                saved_product_name=prod.product_name,
                product_id=product_id,
                standard_by_id=standard_by_id,
                alias_options_by_id=alias_options_by_id,
            )
            products_by_plan.setdefault(prod.plan_id, []).append(
                PublicTransportHistoryProductRead(
                    product_name=display_name or prod.product_name or "—",
                    model=prod.model,
                    package_spec=prod.package_spec,
                    quantity=prod.quantity or prod.inbound_estimate_qty or prod.outbound_estimate_qty,
                    unit=_resolve_unit_label(unit_map, prod.unit),
                )
            )

    records: list[PublicTransportHistoryRecordRead] = []
    for plan, tr in plan_rows:
        voided, archived = _resolve_driver_link_flags(plan, tr)
        tok = (tr.driver_access_token or "").strip()
        records.append(
            PublicTransportHistoryRecordRead(
                plan_id=plan.id,
                plan_no=plan.plan_no or "",
                transport_id=tr.id,
                driver_access_token=tok or None,
                driver_url=_build_driver_url(tok) if tok else None,
                license_plate=tr.license_plate or plate,
                pickup_time=plan.pickup_time,
                delivery_time=plan.delivery_time,
                pickup_address=plan.pickup_address,
                destination_address=plan.destination_address or plan.destination_name,
                products=products_by_plan.get(plan.id) or [],
                stops=_build_history_stop_reads(
                    db, tenant_no=transport.tenant_no, plan=plan, transport=tr
                ),
                plan_voided=voided,
                plan_archived=archived,
                status_label=_history_status_label(voided, archived),
            )
        )

    page = PublicTransportHistoryPageRead(
        license_plate=plate,
        date=day.isoformat(),
        records=records,
    )
    return success_response(page.model_dump(by_alias=True))


@router.post("/{token}/feedback")
def save_public_feedback(
    token: str,
    payload: PublicTransportFeedback,
    db: Session = Depends(get_db),
):
    transport = _get_transport_by_token(db, token)
    page = _build_public_page(db, transport)
    if page.plan_voided:
        return error_response(400, "运输计划已作废，无法提交回执")
    if page.plan_archived:
        return error_response(400, "运输计划已归档，无法提交回执")

    if payload.feedback_images is not None:
        transport.feedback_images = json.dumps(payload.feedback_images)

    if payload.feedback_remark is not None:
        transport.feedback_remark = payload.feedback_remark

    if payload.products:
        link = (
            db.query(PlPlanTransport)
            .filter(
                PlPlanTransport.transport_id == transport.id,
                PlPlanTransport.del_flag == 0,
            )
            .order_by(PlPlanTransport.create_time.desc())
            .first()
        )
        if not link or not link.plan_id:
            return error_response(400, "未找到关联计划，无法保存产品回传")
        products_payload = [
            {
                "planProductId": item.plan_product_id,
                "actualQty": item.actual_qty,
                "brandQtys": [b.model_dump(by_alias=True) for b in (item.brand_qtys or [])],
            }
            for item in payload.products
        ]
        try:
            persist_transport_product_feedback(
                db,
                tenant_no=transport.tenant_no,
                transport=transport,
                plan_id=link.plan_id,
                products=products_payload,
                user_id=None,
                enforce_brand=True,
            )
        except ValueError as exc:
            return error_response(400, str(exc))
    elif payload.feedback_qty is not None:
        transport.feedback_qty = payload.feedback_qty

    transport.feedback_time = datetime.now()
    db.commit()
    return success_response({"success": True, "message": "保存成功"})


@router.post("/{token}/driver-feedback")
def save_public_driver_stop_feedback(
    token: str,
    payload: PublicTransportDriverStopFeedback,
    db: Session = Depends(get_db),
):
    transport = _get_transport_by_token(db, token)
    page = _build_public_page(db, transport)
    if page.plan_voided:
        return error_response(400, "运输计划已作废，无法提交回执")
    if page.plan_archived:
        return error_response(400, "运输计划已归档，无法提交回执")

    link = (
        db.query(PlPlanTransport)
        .filter(
            PlPlanTransport.transport_id == transport.id,
            PlPlanTransport.del_flag == 0,
        )
        .order_by(PlPlanTransport.create_time.desc())
        .first()
    )
    if not link or not link.plan_id:
        return error_response(400, "未找到关联计划，无法保存段附件")

    stop_type = (payload.stop_type or "").strip()
    stop_id = (payload.stop_id or "").strip()
    if stop_type not in ("load", "delivery") or not stop_id:
        return error_response(400, "停靠段参数无效")

    allowed = {
        (segment.stop_type, segment.stop_id)
        for segment in load_driver_stop_segments(
            db,
            tenant_no=transport.tenant_no,
            plan_id=link.plan_id,
            transport_id=transport.id,
        )
    }
    if (stop_type, stop_id) not in allowed:
        return error_response(400, "停靠段不存在或不可回传")

    segment = next(
        (
            row
            for row in load_driver_stop_segments(
                db,
                tenant_no=transport.tenant_no,
                plan_id=link.plan_id,
                transport_id=transport.id,
            )
            if row.stop_type == stop_type and row.stop_id == stop_id
        ),
        None,
    )
    if not segment:
        return error_response(400, "停靠段不存在或不可回传")

    products_payload: Optional[list[dict]] = None
    if payload.products is not None:
        allowed_products = {row.stop_product_id: row for row in segment.products}
        plan_products = (
            db.query(PlPlanProduct)
            .filter(
                PlPlanProduct.plan_id == link.plan_id,
                PlPlanProduct.tenant_no == transport.tenant_no,
                PlPlanProduct.del_flag == 0,
            )
            .all()
        )
        plan_products_by_id = {row.id: row for row in plan_products}
        products_payload = []
        for item in payload.products:
            stop_product_id = (item.stop_product_id or "").strip()
            stop_row = allowed_products.get(stop_product_id)
            if not stop_row:
                return error_response(400, "产品不属于当前停靠段")
            actual_qty = Decimal(str(item.actual_qty or 0))
            brand_qtys = [
                b.model_dump(by_alias=True) for b in (item.brand_qtys or [])
            ]
            plan_product = plan_products_by_id.get(stop_row.plan_product_id)
            try:
                require_brand_qtys_if_needed(
                    brand_mode=plan_product.brand_mode if plan_product else None,
                    required_brand_id=plan_product.brand_id if plan_product else None,
                    actual_qty=actual_qty,
                    rows=brand_qtys,
                    enforce=True,
                )
            except ValueError as exc:
                return error_response(400, str(exc))
            row_payload: dict = {
                "stopProductId": stop_product_id,
                "actualQty": float(actual_qty),
            }
            if brand_qtys:
                row_payload["brandQtys"] = brand_qtys
            products_payload.append(row_payload)

    save_driver_stop_feedback(
        db,
        tenant_no=transport.tenant_no,
        transport_id=transport.id,
        plan_id=link.plan_id,
        stop_type=stop_type,
        stop_id=stop_id,
        attachment_urls=payload.attachment_urls or [],
        products=products_payload,
        remark=payload.remark,
    )
    db.commit()
    return success_response({"success": True, "message": "保存成功"})


def _format_file_size(size_bytes: int) -> str:
    if size_bytes < 1024:
        return f"{size_bytes} B"
    if size_bytes < 1024 * 1024:
        return f"{size_bytes / 1024:.1f} KB"
    return f"{size_bytes / (1024 * 1024):.1f} MB"


@router.post("/{token}/attachments")
def upload_public_attachment(
    token: str,
    file: UploadFile = File(...),
    folder: Optional[str] = Form(""),
    db: Session = Depends(get_db),
):
    transport = _get_transport_by_token(db, token)
    page = _build_public_page(db, transport)
    if page.plan_voided:
        return error_response(400, "运输计划已作废，无法上传附件")
    if page.plan_archived:
        return error_response(400, "运输计划已归档，无法上传附件")
    if not file or not file.filename:
        return error_response(400, "请选择文件")

    try:
        effective_folder = resolve_upload_folder(folder=folder or "", biz_type="pl_transport_feedback")
        file_content = file.file.read()
        full_url = storage.upload_file(file_content, file.filename, effective_folder)
        base_url = settings.MINIO_BASE_URL.rstrip("/") if settings.MINIO_BASE_URL else ""
        if base_url and full_url.startswith(base_url + "/"):
            file_url = full_url[len(base_url) + 1 :]
        else:
            file_url = full_url

        record = oss_svc.create_oss(
            db,
            tenant_no=transport.tenant_no,
            url=file_url,
            original_name=file.filename,
            file_suffix=os.path.splitext(file.filename)[1].lstrip(".") if file.filename else "",
            file_size=len(file_content),
            file_type=file.content_type or "",
            biz_type="pl_transport_feedback",
            user_id=None,
            ext1=effective_folder or None,
        )
        db.commit()
        return success_response(
            {
                "id": record.id,
                "fileName": record.original_name,
                "fileUrl": record.url,
                "fileSize": record.file_size,
                "fileSizeDisplay": _format_file_size(record.file_size or 0),
                "fileType": record.file_type,
            }
        )
    except Exception as exc:
        db.rollback()
        return error_response(500, f"上传失败: {str(exc)}")