"""按样本缴费方案 / 应缴批次 / 转账笔 CRUD（payment_model_version=2）"""

from __future__ import annotations

import json
from datetime import datetime
from decimal import Decimal
from typing import Any, Dict, List, Optional, Tuple

from sqlalchemy import and_, exists, func, or_
from sqlalchemy.orm import Session

from app.core.utils import generate_uuid, parse_datetime
from app.crud.collection_protocol import urls_to_attachment_list
from app.models.models import (
    BizCellSampleType,
    BizCollectionProtocol,
    BizPresignTransfer,
    BizProtocolCollectionInfo,
    BizProtocolPartyCustomer,
    BizProtocolPaymentSchedule,
    BizProtocolPaymentTransfer,
    BizProtocolSample,
    BizProtocolSamplePayment,
    SysUser,
)
from app.services.payment_chase import (
    chase_period_money,
    is_chase_candidate,
    parse_due_date_ymd,
)
from app.services.protocol_transfer_status import (
    can_confirm_receipt,
    can_edit_transfer,
    can_submit_receipt,
    can_withdraw_receipt,
)
from app.services.sample_payment_fgd_convert import plan_fq_to_fgd_merge
from app.services.sample_payment_period_summary import summarize_period
from app.services.sample_payment_schedule_validate import schedule_dues_match_contract
from app.services.sample_payment_progress import (
    compute_sample_payment_progress,
    is_schedule_effectively_cleared,
)


def _fmt_ymd8(v: Any) -> str:
    s = str(v or "").strip()
    if len(s) == 8 and s.isdigit():
        return f"{s[:4]}-{s[4:6]}-{s[6:8]}"
    return s


def _build_periods_array(
    schedules: List[BizProtocolPaymentSchedule],
    transfers: List[BizProtocolPaymentTransfer],
) -> List[Optional[Dict[str, Any]]]:
    """固定长度 6；无对应 schedule_no 的槽位为 None。"""
    by_sch: Dict[str, List[BizProtocolPaymentTransfer]] = {}
    for t in transfers:
        by_sch.setdefault(t.schedule_id or "", []).append(t)
    by_no: Dict[int, BizProtocolPaymentSchedule] = {}
    for s in schedules:
        if (s.schedule_status or "") == "void":
            continue
        no = int(s.schedule_no or 0)
        if 1 <= no <= 6:
            by_no[no] = s
    periods: List[Optional[Dict[str, Any]]] = []
    for no in range(1, 7):
        s = by_no.get(no)
        if not s:
            periods.append(None)
            continue
        trs = by_sch.get(s.id, [])
        summary = summarize_period(
            due_amount=s.due_amount,
            transfers=[
                {
                    "transferAmount": t.transfer_amount,
                    "transferType": t.transfer_type or "",
                    "transferTime": t.transfer_time.strftime("%Y-%m-%d %H:%M:%S")
                    if t.transfer_time
                    else "",
                    "payStatus": t.pay_status or "",
                }
                for t in trs
            ],
        )
        periods.append(
            {
                "scheduleId": s.id,
                "scheduleNo": no,
                "dueAmount": float(s.due_amount) if s.due_amount is not None else None,
                "dueDate": _fmt_ymd8(s.due_date),
                "displayPaidAmount": float(summary["displayPaidAmount"]),
                "arrearsAmount": float(summary["arrearsAmount"]),
                "payDate": summary.get("payDate") or "",
                "payTypeSummary": summary.get("payTypeSummary") or "",
                "financeAudit": summary.get("financeAudit") or "dfj",
            }
        )
    return periods


def _dec(v: Any) -> Optional[Decimal]:
    if v is None or v == "":
        return None
    return Decimal(str(v))


def _now() -> datetime:
    return datetime.now()


def _get_sample_payment_or_raise(
    db: Session, *, sample_payment_id: str, tenant_no: str
) -> BizProtocolSamplePayment:
    obj = (
        db.query(BizProtocolSamplePayment)
        .filter(
            BizProtocolSamplePayment.id == sample_payment_id,
            BizProtocolSamplePayment.tenant_no == tenant_no,
            BizProtocolSamplePayment.del_flag == 0,
        )
        .first()
    )
    if not obj:
        raise ValueError("样本缴费方案不存在")
    return obj


def _lock_sample_payment_graph(
    db: Session,
    *,
    sample_payment_id: str,
    tenant_no: str,
) -> Tuple[
    BizProtocolSamplePayment,
    List[BizProtocolPaymentSchedule],
    List[BizProtocolPaymentTransfer],
]:
    """按方案→批次→转账顺序加行锁，供普通方案保存做最终一致性校验。"""
    sp = (
        db.query(BizProtocolSamplePayment)
        .filter(
            BizProtocolSamplePayment.id == sample_payment_id,
            BizProtocolSamplePayment.tenant_no == tenant_no,
            BizProtocolSamplePayment.del_flag == 0,
        )
        .populate_existing()
        .with_for_update()
        .first()
    )
    if not sp:
        raise ValueError("样本缴费方案不存在")
    schedules = (
        db.query(BizProtocolPaymentSchedule)
        .filter(
            BizProtocolPaymentSchedule.sample_payment_id == sample_payment_id,
            BizProtocolPaymentSchedule.tenant_no == tenant_no,
            BizProtocolPaymentSchedule.del_flag == 0,
        )
        .order_by(BizProtocolPaymentSchedule.schedule_no.asc())
        .populate_existing()
        .with_for_update()
        .all()
    )
    schedule_ids = [row.id for row in schedules]
    transfers: List[BizProtocolPaymentTransfer] = []
    if schedule_ids:
        transfers = (
            db.query(BizProtocolPaymentTransfer)
            .filter(
                BizProtocolPaymentTransfer.schedule_id.in_(schedule_ids),
                BizProtocolPaymentTransfer.tenant_no == tenant_no,
                BizProtocolPaymentTransfer.del_flag == 0,
            )
            .order_by(BizProtocolPaymentTransfer.id.asc())
            .populate_existing()
            .with_for_update()
            .all()
        )
    return sp, schedules, transfers


def _locked_schedule_ids(
    schedules: List[BizProtocolPaymentSchedule],
    transfers: List[BizProtocolPaymentTransfer],
) -> set:
    locked = {
        row.id
        for row in schedules
        if (row.schedule_status or "").strip() != "open"
    }
    locked.update(
        row.schedule_id
        for row in transfers
        if (row.pay_status or "").strip() != "dfj"
    )
    return locked


def _assert_locked_schedule_structure(
    schedules: List[BizProtocolPaymentSchedule],
    transfers: List[BizProtocolPaymentTransfer],
    payload: List[Dict[str, Any]],
) -> None:
    locked_ids = _locked_schedule_ids(schedules, transfers)
    if not locked_ids:
        return
    current_nos = {int(row.schedule_no or 0) for row in schedules}
    submitted_no_list = [
        _schedule_no_of(raw, idx + 1)
        for idx, raw in enumerate(payload or [])
        if isinstance(raw, dict)
    ]
    if len(submitted_no_list) != len(set(submitted_no_list)):
        raise ValueError("应缴批次期号重复")
    submitted_nos = set(submitted_no_list)
    locked_nos = {
        int(row.schedule_no or 0) for row in schedules if row.id in locked_ids
    }
    if submitted_nos != current_nos or not locked_nos.issubset(submitted_nos):
        raise ValueError("存在锁定批次，不能省略、删除、重编号或重建")
    by_id = {row.id: int(row.schedule_no or 0) for row in schedules}
    for idx, raw in enumerate(payload or []):
        if not isinstance(raw, dict):
            continue
        schedule_id = str(raw.get("id") or raw.get("scheduleId") or "").strip()
        if schedule_id in locked_ids and _schedule_no_of(raw, idx + 1) != by_id[schedule_id]:
            raise ValueError("存在锁定批次，不能省略、删除、重编号或重建")


def _get_schedule_or_raise(
    db: Session, *, schedule_id: str, tenant_no: str
) -> BizProtocolPaymentSchedule:
    obj = (
        db.query(BizProtocolPaymentSchedule)
        .filter(
            BizProtocolPaymentSchedule.id == schedule_id,
            BizProtocolPaymentSchedule.tenant_no == tenant_no,
            BizProtocolPaymentSchedule.del_flag == 0,
        )
        .first()
    )
    if not obj:
        raise ValueError("应缴批次不存在")
    return obj


def _get_transfer_or_raise(
    db: Session, *, transfer_id: str, tenant_no: str
) -> BizProtocolPaymentTransfer:
    obj = (
        db.query(BizProtocolPaymentTransfer)
        .filter(
            BizProtocolPaymentTransfer.id == transfer_id,
            BizProtocolPaymentTransfer.tenant_no == tenant_no,
            BizProtocolPaymentTransfer.del_flag == 0,
        )
        .first()
    )
    if not obj:
        raise ValueError("转账笔不存在")
    return obj


def _get_transfer_with_schedule_lock(
    db: Session,
    *,
    transfer_id: str,
    tenant_no: str,
    user_info: Optional[dict] = None,
) -> BizProtocolPaymentTransfer:
    """Authorize the complete parent chain, then lock schedule before transfer."""
    parent = (
        db.query(
            BizProtocolPaymentTransfer.schedule_id,
            BizProtocolPaymentTransfer.sample_payment_id,
            BizProtocolPaymentTransfer.collection_protocol_id,
        )
        .filter(
            BizProtocolPaymentTransfer.id == transfer_id,
            BizProtocolPaymentTransfer.tenant_no == tenant_no,
            BizProtocolPaymentTransfer.del_flag == 0,
        )
        .first()
    )
    if not parent:
        if user_info is not None:
            raise PermissionError("无权操作该协议")
        raise ValueError("转账笔不存在")
    schedule_id = parent.schedule_id
    schedule_query = (
        db.query(BizProtocolPaymentSchedule)
        .join(
            BizProtocolSamplePayment,
            and_(
                BizProtocolSamplePayment.id == parent.sample_payment_id,
                BizProtocolSamplePayment.id
                == BizProtocolPaymentSchedule.sample_payment_id,
                BizProtocolSamplePayment.collection_protocol_id
                == parent.collection_protocol_id,
                BizProtocolSamplePayment.tenant_no == tenant_no,
                BizProtocolSamplePayment.del_flag == 0,
            ),
        )
        .join(
            BizCollectionProtocol,
            and_(
                BizCollectionProtocol.id == parent.collection_protocol_id,
                BizCollectionProtocol.id
                == BizProtocolPaymentSchedule.collection_protocol_id,
                BizCollectionProtocol.tenant_no == tenant_no,
                BizCollectionProtocol.del_flag == 0,
            ),
        )
        .filter(
            BizProtocolPaymentSchedule.id == schedule_id,
            BizProtocolPaymentSchedule.sample_payment_id
            == parent.sample_payment_id,
            BizProtocolPaymentSchedule.collection_protocol_id
            == parent.collection_protocol_id,
            BizProtocolPaymentSchedule.tenant_no == tenant_no,
            BizProtocolPaymentSchedule.del_flag == 0,
        )
    )
    if user_info is not None:
        from app.core.data_scope import apply_data_scope

        schedule_query = apply_data_scope(
            schedule_query,
            BizCollectionProtocol,
            user_info,
            db,
            tenant_no,
        )
    schedule = schedule_query.populate_existing().with_for_update().first()
    if not schedule:
        if user_info is not None:
            raise PermissionError("无权操作该协议")
        raise ValueError("应缴批次不存在")
    transfer = (
        db.query(BizProtocolPaymentTransfer)
        .filter(
            BizProtocolPaymentTransfer.id == transfer_id,
            BizProtocolPaymentTransfer.schedule_id == schedule_id,
            BizProtocolPaymentTransfer.sample_payment_id
            == parent.sample_payment_id,
            BizProtocolPaymentTransfer.collection_protocol_id
            == parent.collection_protocol_id,
            BizProtocolPaymentTransfer.tenant_no == tenant_no,
            BizProtocolPaymentTransfer.del_flag == 0,
        )
        .populate_existing()
        .with_for_update()
        .first()
    )
    if not transfer:
        raise ValueError("转账笔不存在")
    return transfer


def has_blocking_transfer_for_sample_payment(
    db: Session, *, sample_payment_id: str, tenant_no: str
) -> bool:
    row = (
        db.query(BizProtocolPaymentTransfer.id)
        .filter(
            BizProtocolPaymentTransfer.sample_payment_id == sample_payment_id,
            BizProtocolPaymentTransfer.tenant_no == tenant_no,
            BizProtocolPaymentTransfer.del_flag == 0,
            BizProtocolPaymentTransfer.pay_status == "jfqrz",
        )
        .first()
    )
    return row is not None


def assert_sample_payment_structure_editable(
    db: Session, *, sample_payment_id: str, tenant_no: str
) -> None:
    """已废弃：付款确认中不再阻断协议保存/改方案。保留空实现以兼容旧调用。"""
    return


# 兼容旧调用名
assert_sample_payment_editable = assert_sample_payment_structure_editable


def find_active_sample_payment(
    db: Session,
    *,
    tenant_no: str,
    sample_payment_id: Optional[str] = None,
    collection_protocol_id: Optional[str] = None,
    sample_code: Optional[str] = None,
) -> Optional[BizProtocolSamplePayment]:
    if sample_payment_id:
        query = db.query(BizProtocolSamplePayment).filter(
            BizProtocolSamplePayment.id == sample_payment_id,
            BizProtocolSamplePayment.tenant_no == tenant_no,
            BizProtocolSamplePayment.del_flag == 0,
        )
        if collection_protocol_id:
            query = query.filter(
                BizProtocolSamplePayment.collection_protocol_id
                == collection_protocol_id
            )
        if sample_code:
            query = query.filter(
                BizProtocolSamplePayment.sample_code == sample_code.strip()
            )
        return query.first()
    code = (sample_code or "").strip()
    pid = (collection_protocol_id or "").strip()
    if not code or not pid:
        return None
    return (
        db.query(BizProtocolSamplePayment)
        .filter(
            BizProtocolSamplePayment.collection_protocol_id == pid,
            BizProtocolSamplePayment.tenant_no == tenant_no,
            BizProtocolSamplePayment.sample_code == code,
            BizProtocolSamplePayment.del_flag == 0,
        )
        .first()
    )


def sample_payment_has_yjf(
    db: Session, *, sample_payment_id: str, tenant_no: str
) -> bool:
    """样本缴费方案下是否存在已财务确认（yjf）转账。"""
    q = (
        db.query(BizProtocolPaymentTransfer.id)
        .filter(
            BizProtocolPaymentTransfer.sample_payment_id == sample_payment_id,
            BizProtocolPaymentTransfer.tenant_no == tenant_no,
            BizProtocolPaymentTransfer.del_flag == 0,
            BizProtocolPaymentTransfer.pay_status == "yjf",
        )
        .limit(1)
        .first()
    )
    return q is not None


def apply_fq_to_fgd_merge(
    db: Session,
    *,
    sample_payment_id: str,
    tenant_no: str,
    user_id: Optional[str],
    target_pay_mode: str = "fgd",
) -> Dict[str, Any]:
    """将分期方案并期为趸交/分改趸：更新目标期应缴、软删后续期及其 dfj 转账。"""
    sp = _get_sample_payment_or_raise(
        db, sample_payment_id=sample_payment_id, tenant_no=tenant_no
    )
    schedules = (
        db.query(BizProtocolPaymentSchedule)
        .filter(
            BizProtocolPaymentSchedule.sample_payment_id == sample_payment_id,
            BizProtocolPaymentSchedule.tenant_no == tenant_no,
            BizProtocolPaymentSchedule.del_flag == 0,
        )
        .order_by(BizProtocolPaymentSchedule.schedule_no.asc())
        .all()
    )
    sch_ids = [s.id for s in schedules]
    transfers = []
    if sch_ids:
        transfers = (
            db.query(BizProtocolPaymentTransfer)
            .filter(
                BizProtocolPaymentTransfer.schedule_id.in_(sch_ids),
                BizProtocolPaymentTransfer.tenant_no == tenant_no,
                BizProtocolPaymentTransfer.del_flag == 0,
            )
            .all()
        )
    sch_dicts = [
        {
            "id": s.id,
            "scheduleNo": s.schedule_no,
            "dueAmount": s.due_amount,
            "scheduleStatus": s.schedule_status or "open",
        }
        for s in schedules
    ]
    tr_dicts = [
        {
            "scheduleId": t.schedule_id,
            "payStatus": t.pay_status or "",
            "transferAmount": t.transfer_amount,
        }
        for t in transfers
    ]
    plan = plan_fq_to_fgd_merge(schedules=sch_dicts, transfers=tr_dicts)
    now = _now()
    target = next((s for s in schedules if s.id == plan["targetScheduleId"]), None)
    if target is None:
        raise ValueError("并期目标期次不存在")
    target.due_amount = plan["newDueAmount"]
    target.update_by = user_id
    target.update_time = now
    db.add(target)

    soft_ids = set(plan["softDeleteScheduleIds"] or [])
    for s in schedules:
        if s.id not in soft_ids:
            continue
        s.del_flag = 1
        s.update_by = user_id
        s.update_time = now
        db.add(s)
    if soft_ids:
        for t in transfers:
            if t.schedule_id in soft_ids and (t.pay_status or "") == "dfj":
                t.del_flag = 1
                t.update_by = user_id
                t.update_time = now
                db.add(t)

    mode = (target_pay_mode or "fgd").strip()
    if mode not in ("dj", "fgd"):
        mode = "fgd"
    sp.pay_mode = mode
    sp.installment_count = plan["newInstallmentCount"]
    sp.update_by = user_id
    sp.update_time = now
    db.add(sp)
    db.flush()
    return plan


def upsert_sample_payment(
    db: Session,
    *,
    collection_protocol_id: str,
    tenant_no: str,
    user_id: Optional[str],
    sample_code: str,
    pay_mode: str,
    contract_amount: Any = None,
    protocol_sample_id: Optional[str] = None,
    installment_count: Optional[int] = None,
    installment_interval_months: Any = None,
    installment_start_date: Optional[str] = None,
    installment_advance_days: Optional[int] = None,
    installment_ratios: Optional[str] = None,
    lump_sum_deadline: Optional[str] = None,
    remark: Optional[str] = None,
    sample_payment_id: Optional[str] = None,
) -> BizProtocolSamplePayment:
    code = (sample_code or "").strip()
    if not code:
        raise ValueError("样本编码不能为空")
    mode = (pay_mode or "").strip()
    if mode not in ("dj", "fq", "djfq", "fgd"):
        raise ValueError("缴费模式无效")

    obj: Optional[BizProtocolSamplePayment] = None
    if sample_payment_id:
        obj = find_active_sample_payment(
            db,
            sample_payment_id=sample_payment_id,
            collection_protocol_id=collection_protocol_id,
            sample_code=code,
            tenant_no=tenant_no,
        )
        if obj is None:
            raise ValueError("样本缴费方案不存在或不属于当前协议样本")
    else:
        obj = (
            db.query(BizProtocolSamplePayment)
            .filter(
                BizProtocolSamplePayment.collection_protocol_id == collection_protocol_id,
                BizProtocolSamplePayment.tenant_no == tenant_no,
                BizProtocolSamplePayment.sample_code == code,
                BizProtocolSamplePayment.del_flag == 0,
            )
            .first()
        )

    now = _now()
    if obj:
        obj.protocol_sample_id = (protocol_sample_id or "").strip() or None
        obj.sample_code = code
        obj.pay_mode = mode
        obj.contract_amount = _dec(contract_amount)
        obj.installment_count = installment_count
        obj.installment_interval_months = _dec(installment_interval_months)
        obj.installment_start_date = (installment_start_date or "").strip() or None
        obj.installment_advance_days = installment_advance_days
        obj.installment_ratios = (installment_ratios or "").strip() or None
        obj.lump_sum_deadline = (lump_sum_deadline or "").strip() or None
        if remark is not None:
            obj.remark = (remark or "").strip() or None
        obj.update_by = user_id
        obj.update_time = now
        db.add(obj)
        db.flush()
        return obj

    obj = BizProtocolSamplePayment(
        id=generate_uuid(),
        collection_protocol_id=collection_protocol_id,
        protocol_sample_id=(protocol_sample_id or "").strip() or None,
        sample_code=code,
        pay_mode=mode,
        contract_amount=_dec(contract_amount),
        installment_count=installment_count,
        installment_interval_months=_dec(installment_interval_months),
        installment_start_date=(installment_start_date or "").strip() or None,
        installment_advance_days=installment_advance_days,
        installment_ratios=(installment_ratios or "").strip() or None,
        lump_sum_deadline=(lump_sum_deadline or "").strip() or None,
        tenant_no=tenant_no,
        order_num=0,
        remark=(remark or "").strip() or None,
        create_by=user_id,
        create_dept_id="",
        create_time=now,
        update_by=user_id,
        update_time=now,
        del_flag=0,
    )
    db.add(obj)
    db.flush()
    return obj


def _schedule_no_of(raw: Dict[str, Any], fallback: int) -> int:
    v = raw.get("schedule_no")
    if v is None:
        v = raw.get("scheduleNo")
    if v is None:
        return fallback
    try:
        return int(v)
    except (TypeError, ValueError):
        return fallback


def _apply_transfer_editable_fields(
    t: BizProtocolPaymentTransfer, raw: Dict[str, Any]
) -> None:
    """更新转账可编辑字段；不改 pay_status。"""
    if "transfer_type" in raw or "transferType" in raw:
        v = raw.get("transfer_type", raw.get("transferType"))
        t.transfer_type = (str(v) if v is not None else "").strip() or None
    if "transfer_amount" in raw or "transferAmount" in raw:
        amt = _dec(raw.get("transfer_amount", raw.get("transferAmount")))
        if amt is not None and amt < 0:
            raise ValueError("转账金额无效")
        t.transfer_amount = amt
    if "transfer_time" in raw or "transferTime" in raw:
        v = raw.get("transfer_time", raw.get("transferTime"))
        if v in (None, ""):
            t.transfer_time = None
        elif isinstance(v, datetime):
            t.transfer_time = v
        else:
            t.transfer_time = parse_datetime(str(v))
    if "transfer_attachments" in raw or "transferAttachments" in raw:
        v = raw.get("transfer_attachments", raw.get("transferAttachments"))
        t.transfer_attachments = (str(v) if v is not None else "").strip() or None
    if "remark" in raw:
        t.remark = (raw.get("remark") or "").strip() or None


def _sync_transfers_for_schedule(
    db: Session,
    *,
    sch: BizProtocolPaymentSchedule,
    tenant_no: str,
    user_id: Optional[str],
    transfers: List[Dict[str, Any]],
) -> None:
    now = _now()
    existing = (
        db.query(BizProtocolPaymentTransfer)
        .filter(
            BizProtocolPaymentTransfer.schedule_id == sch.id,
            BizProtocolPaymentTransfer.tenant_no == tenant_no,
            BizProtocolPaymentTransfer.del_flag == 0,
        )
        .order_by(BizProtocolPaymentTransfer.id.asc())
        .populate_existing()
        .with_for_update()
        .all()
    )
    by_id = {t.id: t for t in existing}
    keep_ids: set = set()
    for raw in transfers or []:
        if not isinstance(raw, dict):
            continue
        tid = (raw.get("id") or "").strip()
        if tid and tid in by_id:
            t = by_id[tid]
            keep_ids.add(tid)
            if (t.pay_status or "").strip() != "dfj":
                # 非草稿转账由专用状态流转接口维护，普通方案保存整行只读。
                continue
            _apply_transfer_editable_fields(t, raw)
            t.update_by = user_id
            t.update_time = now
            db.add(t)
            continue
        if tid:
            raise ValueError("转账笔不存在或不属于当前批次")
        # 新增转账笔（始终以待缴费入库；提交财务走独立接口）
        add_transfer(
            db,
            schedule_id=sch.id,
            tenant_no=tenant_no,
            user_id=user_id,
            transfer_amount=raw.get("transfer_amount", raw.get("transferAmount")),
            transfer_time=raw.get("transfer_time", raw.get("transferTime")),
            transfer_type=raw.get("transfer_type", raw.get("transferType")),
            transfer_attachments=raw.get(
                "transfer_attachments", raw.get("transferAttachments")
            ),
            remark=raw.get("remark"),
            commit=False,
        )
    for tid, t in by_id.items():
        if tid in keep_ids:
            continue
        if (t.pay_status or "").strip() != "dfj":
            continue
        t.del_flag = 1
        t.update_by = user_id
        t.update_time = now
        db.add(t)


def replace_schedules(
    db: Session,
    *,
    sample_payment_id: str,
    tenant_no: str,
    user_id: Optional[str],
    schedules: List[Dict[str, Any]],
) -> List[BizProtocolPaymentSchedule]:
    """仅在全部批次为 open、全部转账为 dfj 时重建批次。"""
    sp, old_schedules, transfers = _lock_sample_payment_graph(
        db,
        sample_payment_id=sample_payment_id,
        tenant_no=tenant_no,
    )
    if _locked_schedule_ids(old_schedules, transfers):
        raise ValueError("存在锁定批次，不能省略、删除、重编号或重建")
    now = _now()
    if old_schedules:
        for t in transfers:
            t.del_flag = 1
            t.update_by = user_id
            t.update_time = now
            db.add(t)
        for s in old_schedules:
            s.del_flag = 1
            s.update_by = user_id
            s.update_time = now
            db.add(s)

    created: List[BizProtocolPaymentSchedule] = []
    for idx, raw in enumerate(schedules or []):
        due_date = (raw.get("due_date") or raw.get("dueDate") or "").strip() or None
        schedule_no = _schedule_no_of(raw, idx + 1)
        obj = BizProtocolPaymentSchedule(
            id=generate_uuid(),
            sample_payment_id=sp.id,
            collection_protocol_id=sp.collection_protocol_id,
            sample_code=sp.sample_code,
            schedule_no=schedule_no,
            due_amount=_dec(raw.get("due_amount") if "due_amount" in raw else raw.get("dueAmount")),
            due_date=due_date,
            schedule_status="open",
            tenant_no=tenant_no,
            order_num=idx,
            remark=(raw.get("remark") or "").strip() or None,
            create_by=user_id,
            create_dept_id="",
            create_time=now,
            update_by=user_id,
            update_time=now,
            del_flag=0,
        )
        db.add(obj)
        created.append(obj)
    db.flush()

    return created


def sync_schedules_and_transfers(
    db: Session,
    *,
    sample_payment_id: str,
    tenant_no: str,
    user_id: Optional[str],
    schedules: List[Dict[str, Any]],
) -> List[BizProtocolPaymentSchedule]:
    """
    同步应缴批次与转账笔：
    - 有非 open 批次或非 dfj 转账：结构固定，状态与非草稿转账只读保留
    - 全部为 open + dfj：允许重建批次，旧草稿转账随旧批次软删
    """
    _, old_schedules, locked_transfers = _lock_sample_payment_graph(
        db,
        sample_payment_id=sample_payment_id,
        tenant_no=tenant_no,
    )
    now = _now()
    by_no = {int(s.schedule_no or 0): s for s in old_schedules}
    payload = list(schedules or [])
    _assert_locked_schedule_structure(old_schedules, locked_transfers, payload)
    new_nos: List[int] = []
    for idx, raw in enumerate(payload):
        if not isinstance(raw, dict):
            continue
        new_nos.append(_schedule_no_of(raw, idx + 1))
    old_nos = set(by_no.keys())
    new_nos_set = set(new_nos)
    structure_changed = old_nos != new_nos_set

    if structure_changed:
        created = replace_schedules(
            db,
            sample_payment_id=sample_payment_id,
            tenant_no=tenant_no,
            user_id=user_id,
            schedules=payload,
        )
        for i, sch_raw in enumerate(payload):
            if i >= len(created) or not isinstance(sch_raw, dict):
                continue
            _sync_transfers_for_schedule(
                db,
                sch=created[i],
                tenant_no=tenant_no,
                user_id=user_id,
                transfers=sch_raw.get("transfers") or [],
            )
        return created

    result: List[BizProtocolPaymentSchedule] = []
    for idx, raw in enumerate(payload):
        if not isinstance(raw, dict):
            continue
        sno = _schedule_no_of(raw, idx + 1)
        sch = by_no.get(sno)
        if not sch:
            raise ValueError("应缴批次数据不一致，请刷新后重试")
        due_date = (raw.get("due_date") or raw.get("dueDate") or "").strip() or None
        sch.due_amount = _dec(
            raw.get("due_amount") if "due_amount" in raw else raw.get("dueAmount")
        )
        sch.due_date = due_date
        sch.order_num = idx
        if "remark" in raw:
            sch.remark = (raw.get("remark") or "").strip() or None
        sch.update_by = user_id
        sch.update_time = now
        db.add(sch)
        _sync_transfers_for_schedule(
            db,
            sch=sch,
            tenant_no=tenant_no,
            user_id=user_id,
            transfers=raw.get("transfers") or [],
        )
        result.append(sch)
    db.flush()
    return result


def add_transfer(
    db: Session,
    *,
    schedule_id: str,
    tenant_no: str,
    user_id: Optional[str],
    transfer_amount: Any = None,
    transfer_time: Any = None,
    transfer_type: Optional[str] = None,
    transfer_attachments: Optional[str] = None,
    remark: Optional[str] = None,
    create_dept_id: str = "",
    commit: bool = True,
) -> BizProtocolPaymentTransfer:
    sch = _get_schedule_or_raise(db, schedule_id=schedule_id, tenant_no=tenant_no)
    now = _now()
    tt = None
    if transfer_time not in (None, ""):
        tt = (
            transfer_time
            if isinstance(transfer_time, datetime)
            else parse_datetime(str(transfer_time))
        )
    obj = BizProtocolPaymentTransfer(
        id=generate_uuid(),
        schedule_id=sch.id,
        sample_payment_id=sch.sample_payment_id,
        collection_protocol_id=sch.collection_protocol_id,
        sample_code=sch.sample_code,
        transfer_amount=_dec(transfer_amount),
        transfer_time=tt,
        transfer_type=(transfer_type or "").strip() or None,
        transfer_attachments=(transfer_attachments or "").strip() or None,
        pay_status="dfj",
        tenant_no=tenant_no,
        order_num=0,
        remark=(remark or "").strip() or None,
        create_by=user_id,
        create_dept_id=(create_dept_id or "").strip(),
        create_time=now,
        update_by=user_id,
        update_time=now,
        del_flag=0,
    )
    db.add(obj)
    if commit:
        db.commit()
        db.refresh(obj)
    else:
        db.flush()
    return obj


def update_transfer_draft(
    db: Session,
    *,
    transfer_id: str,
    tenant_no: str,
    user_id: Optional[str],
    fields: Dict[str, Any],
    locked_transfer: Optional[BizProtocolPaymentTransfer] = None,
) -> BizProtocolPaymentTransfer:
    t = locked_transfer or _get_transfer_or_raise(
        db, transfer_id=transfer_id, tenant_no=tenant_no
    )
    if t.id != transfer_id or t.tenant_no != tenant_no or t.del_flag != 0:
        raise ValueError("转账笔不存在")
    if not can_edit_transfer(t.pay_status):
        raise ValueError("财务已确认收款的转账笔不可编辑")
    _apply_transfer_editable_fields(t, fields)
    t.update_by = user_id
    t.update_time = _now()
    db.add(t)
    db.commit()
    db.refresh(t)
    return t


def _validate_transfer_submit_ready(t: BizProtocolPaymentTransfer) -> None:
    if not (t.transfer_type or "").strip():
        raise ValueError("请选择转账方式")
    if t.transfer_amount is None or Decimal(str(t.transfer_amount)) <= 0:
        raise ValueError("请填写转账金额")


def submit_receipt_finance(
    db: Session,
    *,
    transfer_id: str,
    tenant_no: str,
    user_id: Optional[str],
    draft_fields: Optional[Dict[str, Any]] = None,
    locked_transfer: Optional[BizProtocolPaymentTransfer] = None,
) -> BizProtocolPaymentTransfer:
    t = locked_transfer or _get_transfer_or_raise(
        db, transfer_id=transfer_id, tenant_no=tenant_no
    )
    if t.id != transfer_id or t.tenant_no != tenant_no or t.del_flag != 0:
        raise ValueError("转账笔不存在")
    if draft_fields:
        if t.pay_status != "dfj":
            raise ValueError("仅已付款状态可编辑转账笔")
        # 就地改草稿字段（不单独 commit）
        if "transfer_type" in draft_fields or "transferType" in draft_fields:
            v = draft_fields.get("transfer_type", draft_fields.get("transferType"))
            t.transfer_type = (str(v) if v is not None else "").strip() or None
        if "transfer_amount" in draft_fields or "transferAmount" in draft_fields:
            t.transfer_amount = _dec(
                draft_fields.get("transfer_amount", draft_fields.get("transferAmount"))
            )
        if "transfer_time" in draft_fields or "transferTime" in draft_fields:
            v = draft_fields.get("transfer_time", draft_fields.get("transferTime"))
            if v in (None, ""):
                t.transfer_time = None
            elif isinstance(v, datetime):
                t.transfer_time = v
            else:
                t.transfer_time = parse_datetime(str(v))
        if "transfer_attachments" in draft_fields or "transferAttachments" in draft_fields:
            v = draft_fields.get(
                "transfer_attachments", draft_fields.get("transferAttachments")
            )
            t.transfer_attachments = (str(v) if v is not None else "").strip() or None
    if not can_submit_receipt(t.pay_status):
        raise ValueError("仅已付款状态可提交财务确认")
    _validate_transfer_submit_ready(t)
    t.pay_status = "jfqrz"
    t.update_by = user_id
    t.update_time = _now()
    db.add(t)
    db.commit()
    db.refresh(t)
    return t


def confirm_receipt(
    db: Session,
    *,
    transfer_id: str,
    tenant_no: str,
    user_id: Optional[str],
    finance_confirm_attachments: Optional[str] = None,
    finance_remark: Optional[str] = None,
    locked_transfer: Optional[BizProtocolPaymentTransfer] = None,
) -> BizProtocolPaymentTransfer:
    t = locked_transfer or _get_transfer_with_schedule_lock(
        db, transfer_id=transfer_id, tenant_no=tenant_no
    )
    if t.id != transfer_id or t.tenant_no != tenant_no or t.del_flag != 0:
        raise ValueError("转账笔不存在")
    if t.pay_status == "yjf":
        raise ValueError("该转账笔已确认收款")
    if not can_confirm_receipt(t.pay_status):
        raise ValueError("当前状态不可确认收款")
    t.pay_status = "yjf"
    if finance_confirm_attachments is not None:
        t.finance_confirm_attachments = finance_confirm_attachments.strip() or None
    if finance_remark is not None:
        t.finance_remark = finance_remark.strip() or None
    t.update_by = user_id
    t.update_time = _now()
    db.add(t)
    # 批次已在 _get_transfer_with_schedule_lock 中加锁，此处不再二次 for_update
    schedule = (
        db.query(BizProtocolPaymentSchedule)
        .filter(
            BizProtocolPaymentSchedule.id == t.schedule_id,
            BizProtocolPaymentSchedule.tenant_no == tenant_no,
            BizProtocolPaymentSchedule.del_flag == 0,
        )
        .first()
    )
    _sync_schedule_cleared_after_confirm(
        db,
        schedule=schedule,
        tenant_no=tenant_no,
        user_id=user_id,
    )
    db.commit()
    db.refresh(t)
    return t


def _sync_schedule_cleared_after_confirm(
    db: Session,
    *,
    schedule: Optional[BizProtocolPaymentSchedule],
    tenant_no: str,
    user_id: Optional[str],
) -> None:
    """财务确认后：实缴覆盖应缴则回写 schedule_status=cleared（调用方须已持有批次锁）。"""
    if not schedule:
        return
    status = (schedule.schedule_status or "").strip()
    if status in ("cleared", "void"):
        return
    confirmed = (
        db.query(func.coalesce(func.sum(BizProtocolPaymentTransfer.transfer_amount), 0))
        .filter(
            BizProtocolPaymentTransfer.schedule_id == schedule.id,
            BizProtocolPaymentTransfer.tenant_no == tenant_no,
            BizProtocolPaymentTransfer.del_flag == 0,
            BizProtocolPaymentTransfer.pay_status == "yjf",
        )
        .scalar()
        or Decimal("0")
    )
    due = Decimal(str(schedule.due_amount or 0))
    if Decimal(str(confirmed)) < due:
        return
    schedule.schedule_status = "cleared"
    schedule.update_by = user_id
    schedule.update_time = _now()
    db.add(schedule)


def reject_receipt(
    db: Session,
    *,
    transfer_id: str,
    tenant_no: str,
    user_id: Optional[str],
    locked_transfer: Optional[BizProtocolPaymentTransfer] = None,
) -> BizProtocolPaymentTransfer:
    t = locked_transfer or _get_transfer_with_schedule_lock(
        db, transfer_id=transfer_id, tenant_no=tenant_no
    )
    if t.id != transfer_id or t.tenant_no != tenant_no or t.del_flag != 0:
        raise ValueError("转账笔不存在")
    if t.pay_status != "jfqrz":
        raise ValueError("当前状态不可退回")
    t.pay_status = "dfj"
    t.update_by = user_id
    t.update_time = _now()
    db.add(t)
    db.commit()
    db.refresh(t)
    return t


def withdraw_receipt(
    db: Session,
    *,
    transfer_id: str,
    tenant_no: str,
    user_id: Optional[str],
    locked_transfer: Optional[BizProtocolPaymentTransfer] = None,
) -> BizProtocolPaymentTransfer:
    """业务撤回：jfqrz → dfj，保留 finance_remark / finance_confirm_attachments。"""
    t = locked_transfer or _get_transfer_with_schedule_lock(
        db, transfer_id=transfer_id, tenant_no=tenant_no
    )
    if t.id != transfer_id or t.tenant_no != tenant_no or t.del_flag != 0:
        raise ValueError("转账笔不存在")
    if not can_withdraw_receipt(t.pay_status):
        raise ValueError("仅付款确认中可撤回")
    t.pay_status = "dfj"
    t.update_by = user_id
    t.update_time = _now()
    db.add(t)
    db.commit()
    db.refresh(t)
    return t


def soft_delete_payment_transfer(
    db: Session,
    *,
    transfer_id: str,
    tenant_no: str,
    user_id: Optional[str],
) -> None:
    t = _get_transfer_or_raise(db, transfer_id=transfer_id, tenant_no=tenant_no)
    if t.pay_status != "dfj":
        raise ValueError("仅已付款状态转账笔可删除")
    t.del_flag = 1
    t.update_by = user_id
    t.update_time = _now()
    db.add(t)
    db.commit()


def _money_value(value: Any, as_string: bool = False) -> Any:
    if value is None:
        return None
    amount = Decimal(str(value)).quantize(Decimal('0.01'))
    return format(amount, 'f') if as_string else float(amount)


def _transfer_to_dict(
    db: Session,
    t: BizProtocolPaymentTransfer,
    tenant_no: str,
    money_as_string: bool = False,
) -> Dict[str, Any]:
    return {
        "id": t.id,
        "scheduleId": t.schedule_id,
        "samplePaymentId": t.sample_payment_id,
        "collectionProtocolId": t.collection_protocol_id,
        "sampleCode": t.sample_code or "",
        "transferAmount": _money_value(t.transfer_amount, money_as_string),
        "transferTime": t.transfer_time.strftime("%Y-%m-%d %H:%M:%S") if t.transfer_time else "",
        "transferType": t.transfer_type or "",
        "transferAttachments": t.transfer_attachments or "",
        "attachments": urls_to_attachment_list(t.transfer_attachments, db, tenant_no),
        "payStatus": t.pay_status or "",
        "financeConfirmAttachments": t.finance_confirm_attachments or "",
        "financeConfirmAttachmentFiles": urls_to_attachment_list(
            t.finance_confirm_attachments, db, tenant_no
        ),
        "financeRemark": t.finance_remark or "",
        "remark": t.remark or "",
        "source": "formal",
        "createTime": t.create_time.strftime("%Y-%m-%d %H:%M:%S") if t.create_time else "",
        "updateTime": t.update_time.strftime("%Y-%m-%d %H:%M:%S") if t.update_time else "",
    }


def _schedule_to_dict(
    db: Session,
    s: BizProtocolPaymentSchedule,
    transfers: List[BizProtocolPaymentTransfer],
    tenant_no: str,
    money_as_string: bool = False,
) -> Dict[str, Any]:
    # 展示口径：已缴仅计 yjf（与 summarize_period / chase_period_money 一致）
    paid, arrears = chase_period_money(
        due_amount=s.due_amount,
        transfers=[
            {
                "transferAmount": t.transfer_amount,
                "transferType": t.transfer_type or "",
                "transferTime": t.transfer_time.strftime("%Y-%m-%d %H:%M:%S")
                if t.transfer_time
                else "",
                "payStatus": t.pay_status or "",
            }
            for t in transfers
        ],
    )
    schedule_status = s.schedule_status or ""
    if schedule_status != "void" and is_schedule_effectively_cleared(
        {"scheduleStatus": schedule_status, "dueAmount": s.due_amount},
        confirmed_paid=Decimal(str(paid or 0)),
    ):
        schedule_status = "cleared"
    return {
        "id": s.id,
        "samplePaymentId": s.sample_payment_id,
        "collectionProtocolId": s.collection_protocol_id,
        "sampleCode": s.sample_code or "",
        "scheduleNo": s.schedule_no,
        "dueAmount": _money_value(s.due_amount, money_as_string),
        "dueDate": s.due_date or "",
        "scheduleStatus": schedule_status,
        "paidAmount": _money_value(paid, money_as_string),
        "arrearsAmount": _money_value(arrears, money_as_string),
        "remark": s.remark or "",
        "transfers": [
            _transfer_to_dict(db, t, tenant_no, money_as_string) for t in transfers
        ],
    }


def _sample_payment_to_dict(
    db: Session,
    p: BizProtocolSamplePayment,
    schedules: List[BizProtocolPaymentSchedule],
    transfers_by_schedule: Dict[str, List[BizProtocolPaymentTransfer]],
    tenant_no: str,
    money_as_string: bool = False,
) -> Dict[str, Any]:
    return {
        "id": p.id,
        "collectionProtocolId": p.collection_protocol_id,
        "protocolSampleId": p.protocol_sample_id or "",
        "sampleCode": p.sample_code or "",
        "payMode": p.pay_mode or "",
        "contractAmount": _money_value(p.contract_amount, money_as_string),
        "installmentCount": p.installment_count,
        "installmentIntervalMonths": float(p.installment_interval_months)
        if p.installment_interval_months is not None
        else None,
        "installmentStartDate": p.installment_start_date or "",
        "installmentAdvanceDays": p.installment_advance_days,
        "installmentRatios": p.installment_ratios or "",
        "lumpSumDeadline": p.lump_sum_deadline or "",
        "remark": p.remark or "",
        "schedules": [
            _schedule_to_dict(
                db, s, transfers_by_schedule.get(s.id, []), tenant_no, money_as_string
            )
            for s in schedules
        ],
    }


def _normalize_installment_ratios(v: Any) -> Optional[str]:
    if v is None or v == "":
        return None
    if isinstance(v, (list, dict)):
        def normalize_decimal(value: Any) -> Any:
            if isinstance(value, Decimal):
                return format(value.quantize(Decimal("0.01")), "f")
            if isinstance(value, list):
                return [normalize_decimal(item) for item in value]
            if isinstance(value, dict):
                return {
                    key: normalize_decimal(item)
                    for key, item in value.items()
                }
            return value

        return json.dumps(normalize_decimal(v), ensure_ascii=False)
    return str(v).strip() or None


def _soft_delete_sample_payment(
    db: Session,
    *,
    sp: BizProtocolSamplePayment,
    tenant_no: str,
    user_id: Optional[str],
) -> None:
    now = _now()
    schedules = (
        db.query(BizProtocolPaymentSchedule)
        .filter(
            BizProtocolPaymentSchedule.sample_payment_id == sp.id,
            BizProtocolPaymentSchedule.tenant_no == tenant_no,
            BizProtocolPaymentSchedule.del_flag == 0,
        )
        .all()
    )
    sids = [s.id for s in schedules]
    if sids:
        transfers = (
            db.query(BizProtocolPaymentTransfer)
            .filter(
                BizProtocolPaymentTransfer.schedule_id.in_(sids),
                BizProtocolPaymentTransfer.tenant_no == tenant_no,
                BizProtocolPaymentTransfer.del_flag == 0,
            )
            .all()
        )
        for t in transfers:
            # 方案删除时一并软删待缴费/确认中；已确认笔保留挂接供追溯
            if t.pay_status in ("dfj", "jfqrz"):
                t.del_flag = 1
                t.update_by = user_id
                t.update_time = now
                db.add(t)
    for s in schedules:
        s.del_flag = 1
        s.update_by = user_id
        s.update_time = now
        db.add(s)
    sp.del_flag = 1
    sp.update_by = user_id
    sp.update_time = now
    db.add(sp)


def save_sample_payments_for_protocol(
    db: Session,
    *,
    collection_protocol_id: str,
    tenant_no: str,
    user_id: Optional[str],
    sample_payments: List[Dict[str, Any]],
) -> None:
    """按样本保存缴费方案；锁定批次/转账所在方案禁止结构性变更。"""
    existing = (
        db.query(BizProtocolSamplePayment)
        .filter(
            BizProtocolSamplePayment.collection_protocol_id == collection_protocol_id,
            BizProtocolSamplePayment.tenant_no == tenant_no,
            BizProtocolSamplePayment.del_flag == 0,
        )
        .order_by(BizProtocolSamplePayment.id.asc())
        .populate_existing()
        .with_for_update()
        .all()
    )
    payload_rows = [raw for raw in (sample_payments or []) if isinstance(raw, dict)]
    payload_by_id = {
        str(raw.get("id") or raw.get("samplePaymentId") or "").strip(): raw
        for raw in payload_rows
        if str(raw.get("id") or raw.get("samplePaymentId") or "").strip()
    }
    payload_by_code = {
        str(raw.get("sample_code") or raw.get("sampleCode") or "").strip(): raw
        for raw in payload_rows
        if str(raw.get("sample_code") or raw.get("sampleCode") or "").strip()
    }
    for current in existing:
        _, schedules, transfers = _lock_sample_payment_graph(
            db,
            sample_payment_id=current.id,
            tenant_no=tenant_no,
        )
        if not _locked_schedule_ids(schedules, transfers):
            continue
        raw = payload_by_id.get(current.id) or payload_by_code.get(current.sample_code)
        if raw is None:
            raise ValueError("存在锁定缴费方案，不能省略或删除")
        submitted_mode = str(raw.get("pay_mode") or raw.get("payMode") or "").strip()
        if submitted_mode and submitted_mode != (current.pay_mode or "").strip():
            raise ValueError("存在锁定缴费方案，不能变更缴费模式或重建")
        _assert_locked_schedule_structure(
            schedules,
            transfers,
            list(raw.get("schedules") or []),
        )

    keep_ids: set = set()
    for raw in payload_rows:
        if not isinstance(raw, dict):
            continue
        sample_code = (raw.get("sample_code") or raw.get("sampleCode") or "").strip()
        if not sample_code:
            raise ValueError("样本缴费方案缺少样本编码")
        pay_mode = (raw.get("pay_mode") or raw.get("payMode") or "").strip()
        sp_id = (raw.get("id") or raw.get("samplePaymentId") or "").strip() or None
        ratios = raw.get("installment_ratios")
        if ratios is None:
            ratios = raw.get("installmentRatios")
        prev = find_active_sample_payment(
            db,
            tenant_no=tenant_no,
            sample_payment_id=sp_id,
            collection_protocol_id=collection_protocol_id,
            sample_code=sample_code,
        )
        prev_mode = (prev.pay_mode or "").strip() if prev else ""
        sp = upsert_sample_payment(
            db,
            collection_protocol_id=collection_protocol_id,
            tenant_no=tenant_no,
            user_id=user_id,
            sample_code=sample_code,
            pay_mode=pay_mode,
            contract_amount=raw.get("contract_amount", raw.get("contractAmount")),
            protocol_sample_id=raw.get("protocol_sample_id") or raw.get("protocolSampleId"),
            installment_count=raw.get("installment_count", raw.get("installmentCount")),
            installment_interval_months=raw.get(
                "installment_interval_months", raw.get("installmentIntervalMonths")
            ),
            installment_start_date=raw.get(
                "installment_start_date", raw.get("installmentStartDate")
            ),
            installment_advance_days=raw.get(
                "installment_advance_days", raw.get("installmentAdvanceDays")
            ),
            installment_ratios=_normalize_installment_ratios(ratios),
            lump_sum_deadline=raw.get("lump_sum_deadline", raw.get("lumpSumDeadline")),
            remark=raw.get("remark"),
            sample_payment_id=sp_id,
        )
        keep_ids.add(sp.id)
        if (
            prev_mode == "fq"
            and pay_mode in ("fgd", "dj")
            and sample_payment_has_yjf(
                db, sample_payment_id=sp.id, tenant_no=tenant_no
            )
        ):
            apply_fq_to_fgd_merge(
                db,
                sample_payment_id=sp.id,
                tenant_no=tenant_no,
                user_id=user_id,
                target_pay_mode=pay_mode,
            )
            continue
        schedules_payload = raw.get("schedules") or []
        require_fields = pay_mode in ("fq", "fgd", "djfq")
        ok, mismatch_msg = schedule_dues_match_contract(
            contract_amount=raw.get("contract_amount", raw.get("contractAmount")),
            schedules=schedules_payload,
            sample_code=sample_code,
            require_schedule_fields=require_fields,
        )
        if not ok:
            raise ValueError(mismatch_msg or "各期应缴合计与合同金额不一致")
        sync_schedules_and_transfers(
            db,
            sample_payment_id=sp.id,
            tenant_no=tenant_no,
            user_id=user_id,
            schedules=schedules_payload,
        )
    for sp in existing:
        if sp.id not in keep_ids:
            _soft_delete_sample_payment(
                db, sp=sp, tenant_no=tenant_no, user_id=user_id
            )
    db.commit()


def list_deposit_transfers_for_protocol(
    db: Session,
    *,
    source_presign_order_id: Optional[str],
    tenant_no: str,
    money_as_string: bool = False,
) -> List[Dict[str, Any]]:
    """正式协议意向金列表：始终读预签订单 biz_presign_transfer，保证财务审批两边一致。"""
    pid = (source_presign_order_id or "").strip()
    if not pid:
        return []
    from app.crud.presign_order import list_transfers

    result = list_transfers(db, presign_order_id=pid, tenant_no=tenant_no)
    if money_as_string and result:
        rows = (
            db.query(BizPresignTransfer)
            .filter(
                BizPresignTransfer.id.in_([item.get('id') for item in result]),
                BizPresignTransfer.tenant_no == tenant_no,
                BizPresignTransfer.del_flag == 0,
            )
            .all()
        )
        amount_by_id = {str(row.id): _money_value(row.transfer_amount, True) for row in rows}
        for item in result:
            item['transferAmount'] = amount_by_id.get(str(item.get('id') or ''))
    return result


def get_presign_deposit_hint(
    db: Session,
    *,
    source_presign_order_id: Optional[str],
    tenant_no: str,
    money_as_string: bool = False,
) -> Optional[Dict[str, Any]]:
    pid = (source_presign_order_id or "").strip()
    if not pid:
        return None
    rows = (
        db.query(BizPresignTransfer)
        .filter(
            BizPresignTransfer.presign_order_id == pid,
            BizPresignTransfer.tenant_no == tenant_no,
            BizPresignTransfer.del_flag == 0,
            BizPresignTransfer.pay_status == "yjf",
        )
        .all()
    )
    total = Decimal("0")
    for r in rows:
        if r.transfer_amount is not None:
            total += Decimal(str(r.transfer_amount))
    return {
        "presignOrderId": pid,
        "confirmedDepositAmount": _money_value(total, money_as_string),
        "confirmedTransferCount": len(rows),
    }


def get_sample_payments_bundle(
    db: Session,
    collection_protocol_id: str,
    tenant_no: str,
    money_as_string: bool = False,
) -> List[Dict[str, Any]]:
    payments = (
        db.query(BizProtocolSamplePayment)
        .filter(
            BizProtocolSamplePayment.collection_protocol_id == collection_protocol_id,
            BizProtocolSamplePayment.tenant_no == tenant_no,
            BizProtocolSamplePayment.del_flag == 0,
        )
        .order_by(
            BizProtocolSamplePayment.order_num.asc(),
            BizProtocolSamplePayment.create_time.asc(),
        )
        .all()
    )
    if not payments:
        return []
    pids = [p.id for p in payments]
    schedules = (
        db.query(BizProtocolPaymentSchedule)
        .filter(
            BizProtocolPaymentSchedule.sample_payment_id.in_(pids),
            BizProtocolPaymentSchedule.tenant_no == tenant_no,
            BizProtocolPaymentSchedule.del_flag == 0,
        )
        .order_by(
            BizProtocolPaymentSchedule.order_num.asc(),
            BizProtocolPaymentSchedule.schedule_no.asc(),
        )
        .all()
    )
    sids = [s.id for s in schedules]
    transfers: List[BizProtocolPaymentTransfer] = []
    if sids:
        transfers = (
            db.query(BizProtocolPaymentTransfer)
            .filter(
                BizProtocolPaymentTransfer.schedule_id.in_(sids),
                BizProtocolPaymentTransfer.tenant_no == tenant_no,
                BizProtocolPaymentTransfer.del_flag == 0,
            )
            .order_by(BizProtocolPaymentTransfer.create_time.asc())
            .all()
        )
    by_schedule: Dict[str, List[BizProtocolPaymentTransfer]] = {}
    for t in transfers:
        by_schedule.setdefault(t.schedule_id, []).append(t)
    schedules_by_payment: Dict[str, List[BizProtocolPaymentSchedule]] = {}
    for s in schedules:
        schedules_by_payment.setdefault(s.sample_payment_id, []).append(s)
    return [
        _sample_payment_to_dict(
            db,
            p,
            schedules_by_payment.get(p.id, []),
            by_schedule,
            tenant_no,
            money_as_string,
        )
        for p in payments
    ]


def list_transfers_for_finance(
    db: Session,
    *,
    pay_status: str,
    tenant_no: str,
    keyword: Optional[str] = None,
    page: int = 1,
    page_size: int = 10,
    user_info=None,
    due_date_start: Optional[str] = None,
    due_date_end: Optional[str] = None,
) -> Tuple[List[Dict[str, Any]], int]:
    if not tenant_no:
        return [], 0
    st = (pay_status or "").strip()
    q = (
        db.query(
            BizProtocolPaymentTransfer,
            BizCollectionProtocol,
            BizProtocolPartyCustomer,
            BizProtocolPaymentSchedule,
            BizProtocolSamplePayment,
        )
        .join(
            BizCollectionProtocol,
            and_(
                BizCollectionProtocol.id
                == BizProtocolPaymentTransfer.collection_protocol_id,
                BizCollectionProtocol.del_flag == 0,
            ),
        )
        .outerjoin(
            BizProtocolPartyCustomer,
            and_(
                BizProtocolPartyCustomer.collection_protocol_id
                == BizProtocolPaymentTransfer.collection_protocol_id,
                BizProtocolPartyCustomer.tenant_no == tenant_no,
                BizProtocolPartyCustomer.del_flag == 0,
            ),
        )
        .outerjoin(
            BizProtocolPaymentSchedule,
            and_(
                BizProtocolPaymentSchedule.id == BizProtocolPaymentTransfer.schedule_id,
                BizProtocolPaymentSchedule.del_flag == 0,
            ),
        )
        .outerjoin(
            BizProtocolSamplePayment,
            and_(
                BizProtocolSamplePayment.id
                == BizProtocolPaymentTransfer.sample_payment_id,
                BizProtocolSamplePayment.del_flag == 0,
            ),
        )
        .filter(
            BizProtocolPaymentTransfer.tenant_no == tenant_no,
            BizProtocolPaymentTransfer.del_flag == 0,
            BizProtocolPaymentTransfer.pay_status == st,
        )
    )
    kw = (keyword or "").strip()
    if kw:
        like = f"%{kw}%"
        q = q.filter(
            or_(
                BizCollectionProtocol.protocol_no.like(like),
                BizProtocolPaymentTransfer.sample_code.like(like),
                BizProtocolPartyCustomer.mother_name.like(like),
                BizProtocolPartyCustomer.mother_id_card.like(like),
                BizProtocolPartyCustomer.newborn_name.like(like),
                BizProtocolPartyCustomer.newborn_id_card.like(like),
            )
        )
    ds = (due_date_start or "").strip().replace("-", "")[:8]
    de = (due_date_end or "").strip().replace("-", "")[:8]
    if ds:
        q = q.filter(BizProtocolPaymentSchedule.due_date >= ds)
    if de:
        q = q.filter(BizProtocolPaymentSchedule.due_date <= de)
    if user_info:
        from app.core.data_scope import apply_data_scope

        q = apply_data_scope(
            q, BizProtocolPaymentTransfer, user_info, db, tenant_no
        )
    total = q.order_by(None).with_entities(func.count(BizProtocolPaymentTransfer.id)).scalar() or 0
    page = max(1, page)
    page_size = min(max(1, page_size), 100)
    rows = (
        q.order_by(BizProtocolPaymentTransfer.create_time.desc())
        .offset((page - 1) * page_size)
        .limit(page_size)
        .all()
    )
    out: List[Dict[str, Any]] = []
    for t, proto, party, sch, sp in rows:
        item = _transfer_to_dict(db, t, tenant_no)
        item["protocolNo"] = (proto.protocol_no if proto else "") or ""
        item["protocolStatus"] = (proto.protocol_status if proto else "") or ""
        item["voidType"] = (proto.void_type if proto else "") or ""
        item["motherName"] = (party.mother_name if party else "") or ""
        item["motherIdCard"] = (party.mother_id_card if party else "") or ""
        item["newbornName"] = (party.newborn_name if party else "") or ""
        item["newbornIdCard"] = (party.newborn_id_card if party else "") or ""
        item["installmentNo"] = sch.schedule_no if sch else None
        item["installmentDueDate"] = (sch.due_date if sch else "") or ""
        item["dueAmount"] = (
            float(sch.due_amount) if sch and sch.due_amount is not None else None
        )
        item["payMode"] = (sp.pay_mode if sp else "") or ""
        out.append(item)
    return out, int(total)


def _filter_and_page_progress(
    rows: List[Dict[str, Any]],
    progress_status: Optional[str],
    page: int,
    page_size: int,
) -> Tuple[List[Dict[str, Any]], int]:
    """先按 progressStatus 过滤，再分页切片（禁止先 LIMIT 再筛进度）。"""
    filtered = rows
    ps = (progress_status or "").strip()
    if ps:
        filtered = [r for r in rows if (r.get("progressStatus") or "") == ps]
    total = len(filtered)
    page = max(1, page)
    page_size = min(max(1, page_size), 100)
    start = (page - 1) * page_size
    return filtered[start : start + page_size], total


def _progress_to_json_fields(progress: Dict[str, Any]) -> Dict[str, Any]:
    paid = progress.get("paidAmount")
    due_remain = progress.get("dueRemainAmount")
    return {
        "progressStatus": progress.get("progressStatus") or "",
        "paidAmount": float(paid) if paid is not None else 0.0,
        "dueRemainAmount": float(due_remain) if due_remain is not None else 0.0,
        "clearedScheduleCount": progress.get("clearedScheduleCount") or 0,
        "activeScheduleCount": progress.get("activeScheduleCount") or 0,
        "canConfirm": bool(progress.get("canConfirm")),
    }


def _load_payment_children_batch(
    db: Session,
    sample_payment_ids: List[str],
    tenant_no: str,
) -> Tuple[
    Dict[str, List[BizProtocolPaymentSchedule]],
    Dict[str, List[BizProtocolPaymentTransfer]],
]:
    schedules_by_payment: Dict[str, List[BizProtocolPaymentSchedule]] = {}
    transfers_by_payment: Dict[str, List[BizProtocolPaymentTransfer]] = {}
    if not sample_payment_ids:
        return schedules_by_payment, transfers_by_payment
    schedules = (
        db.query(BizProtocolPaymentSchedule)
        .filter(
            BizProtocolPaymentSchedule.sample_payment_id.in_(sample_payment_ids),
            BizProtocolPaymentSchedule.tenant_no == tenant_no,
            BizProtocolPaymentSchedule.del_flag == 0,
        )
        .order_by(
            BizProtocolPaymentSchedule.order_num.asc(),
            BizProtocolPaymentSchedule.schedule_no.asc(),
        )
        .all()
    )
    sids = [s.id for s in schedules]
    transfers: List[BizProtocolPaymentTransfer] = []
    if sids:
        transfers = (
            db.query(BizProtocolPaymentTransfer)
            .filter(
                BizProtocolPaymentTransfer.schedule_id.in_(sids),
                BizProtocolPaymentTransfer.tenant_no == tenant_no,
                BizProtocolPaymentTransfer.del_flag == 0,
            )
            .order_by(BizProtocolPaymentTransfer.create_time.asc())
            .all()
        )
    for s in schedules:
        schedules_by_payment.setdefault(s.sample_payment_id, []).append(s)
    schedule_to_payment = {s.id: s.sample_payment_id for s in schedules}
    for t in transfers:
        pid = schedule_to_payment.get(t.schedule_id) or t.sample_payment_id
        if pid:
            transfers_by_payment.setdefault(pid, []).append(t)
    return schedules_by_payment, transfers_by_payment


def _compute_progress_for_payment(
    schedules: List[BizProtocolPaymentSchedule],
    transfers: List[BizProtocolPaymentTransfer],
) -> Dict[str, Any]:
    sch_dicts = [
        {
            "id": s.id,
            "scheduleStatus": s.schedule_status or "",
            "dueAmount": s.due_amount,
        }
        for s in schedules
    ]
    tr_dicts = [
        {
            "scheduleId": t.schedule_id,
            "payStatus": t.pay_status or "",
            "transferAmount": t.transfer_amount,
        }
        for t in transfers
    ]
    return compute_sample_payment_progress(schedules=sch_dicts, transfers=tr_dicts)


def _build_list_summary_row(
    sp: BizProtocolSamplePayment,
    proto: BizCollectionProtocol,
    party: Optional[BizProtocolPartyCustomer],
    progress: Dict[str, Any],
    *,
    schedules: Optional[List[BizProtocolPaymentSchedule]] = None,
    transfers: Optional[List[BizProtocolPaymentTransfer]] = None,
    sample_meta: Optional[Dict[str, Any]] = None,
) -> Dict[str, Any]:
    sch_list = schedules or []
    tr_list = transfers or []
    meta = sample_meta or {}
    active_dues = [
        s.due_amount
        for s in sch_list
        if (s.schedule_status or "") != "void" and s.due_amount is not None
    ]
    receivable = float(sum(active_dues, Decimal("0"))) if active_dues else 0.0
    discount = meta.get("discountAmount")
    row: Dict[str, Any] = {
        "id": sp.id,
        "collectionProtocolId": sp.collection_protocol_id,
        "protocolNo": (proto.protocol_no if proto else "") or "",
        "protocolStatus": (proto.protocol_status if proto else "") or "",
        "voidType": (proto.void_type if proto else "") or "",
        "motherName": (party.mother_name if party else "") or "",
        "motherPhone": (party.mother_phone if party else "") or "",
        "sampleCode": sp.sample_code or "",
        "payMode": sp.pay_mode or "",
        "contractAmount": float(sp.contract_amount)
        if sp.contract_amount is not None
        else None,
        "signDate": _fmt_ymd8(getattr(proto, "register_date", None) or ""),
        "storageYears": meta.get("storageYears"),
        "sampleTypeName": meta.get("sampleTypeName") or "",
        "discountAmount": discount,
        "receivableAmount": receivable,
        "remark": sp.remark or "",
        "periods": _build_periods_array(sch_list, tr_list),
    }
    row.update(_progress_to_json_fields(progress))
    return row


def list_sample_payments_page(
    db: Session,
    *,
    tenant_no: str,
    keyword: Optional[str] = None,
    pay_mode: Optional[str] = None,
    progress_status: Optional[str] = None,
    due_date_start: Optional[str] = None,
    due_date_end: Optional[str] = None,
    page: int = 1,
    page_size: int = 10,
    user_info=None,
) -> Tuple[List[Dict[str, Any]], int]:
    if not tenant_no:
        return [], 0
    q = (
        db.query(
            BizProtocolSamplePayment,
            BizCollectionProtocol,
            BizProtocolPartyCustomer,
        )
        .join(
            BizCollectionProtocol,
            and_(
                BizCollectionProtocol.id
                == BizProtocolSamplePayment.collection_protocol_id,
                BizCollectionProtocol.del_flag == 0,
            ),
        )
        .outerjoin(
            BizProtocolPartyCustomer,
            and_(
                BizProtocolPartyCustomer.collection_protocol_id
                == BizProtocolSamplePayment.collection_protocol_id,
                BizProtocolPartyCustomer.tenant_no == tenant_no,
                BizProtocolPartyCustomer.del_flag == 0,
            ),
        )
        .filter(
            BizProtocolSamplePayment.tenant_no == tenant_no,
            BizProtocolSamplePayment.del_flag == 0,
        )
    )
    kw = (keyword or "").strip()
    if kw:
        like = f"%{kw}%"
        q = q.filter(
            or_(
                BizCollectionProtocol.protocol_no.like(like),
                BizProtocolSamplePayment.sample_code.like(like),
                BizProtocolPartyCustomer.mother_name.like(like),
                BizProtocolPartyCustomer.mother_phone.like(like),
            )
        )
    mode = (pay_mode or "").strip()
    if mode:
        q = q.filter(BizProtocolSamplePayment.pay_mode == mode)
    ds = (due_date_start or "").strip().replace("-", "")[:8]
    de = (due_date_end or "").strip().replace("-", "")[:8]
    if ds or de:
        due_conditions = [
            BizProtocolPaymentSchedule.sample_payment_id
            == BizProtocolSamplePayment.id,
            BizProtocolPaymentSchedule.tenant_no == tenant_no,
            BizProtocolPaymentSchedule.del_flag == 0,
            BizProtocolPaymentSchedule.schedule_status != "void",
        ]
        if ds:
            due_conditions.append(BizProtocolPaymentSchedule.due_date >= ds)
        if de:
            due_conditions.append(BizProtocolPaymentSchedule.due_date <= de)
        q = q.filter(exists().where(and_(*due_conditions)))
    if user_info:
        from app.core.data_scope import apply_data_scope

        q = apply_data_scope(q, BizCollectionProtocol, user_info, db, tenant_no)
    candidates = q.order_by(BizProtocolSamplePayment.create_time.desc()).all()
    if not candidates:
        return [], 0
    pids = [sp.id for sp, _, _ in candidates]
    schedules_by_payment, transfers_by_payment = _load_payment_children_batch(
        db, pids, tenant_no
    )
    sample_codes = list({(sp.sample_code or "").strip() for sp, _, _ in candidates if sp.sample_code})
    protocol_ids = list({sp.collection_protocol_id for sp, _, _ in candidates})
    sample_meta_by_key: Dict[str, Dict[str, Any]] = {}
    if sample_codes and protocol_ids:
        s_rows = (
            db.query(BizProtocolSample)
            .filter(
                BizProtocolSample.collection_protocol_id.in_(protocol_ids),
                BizProtocolSample.tenant_no == tenant_no,
                BizProtocolSample.del_flag == 0,
                BizProtocolSample.sample_code.in_(sample_codes),
            )
            .all()
        )
        type_ids = list({s.sample_type_id for s in s_rows if s.sample_type_id})
        type_name_map: Dict[str, str] = {}
        if type_ids:
            for t in (
                db.query(BizCellSampleType)
                .filter(BizCellSampleType.id.in_(type_ids), BizCellSampleType.del_flag == 0)
                .all()
            ):
                type_name_map[t.id] = t.type_name or ""
        for s in s_rows:
            key = f"{s.collection_protocol_id}|{(s.sample_code or '').strip()}"
            orig = float(s.original_price) if s.original_price is not None else None
            price = float(s.price) if s.price is not None else None
            discount = None
            if orig is not None and price is not None and orig > price:
                discount = round(orig - price, 2)
            sample_meta_by_key[key] = {
                "storageYears": s.storage_years,
                "sampleTypeName": type_name_map.get(s.sample_type_id or "", ""),
                "discountAmount": discount,
            }
    rows: List[Dict[str, Any]] = []
    for sp, proto, party in candidates:
        schedules = schedules_by_payment.get(sp.id, [])
        transfers = transfers_by_payment.get(sp.id, [])
        progress = _compute_progress_for_payment(schedules, transfers)
        meta_key = f"{sp.collection_protocol_id}|{(sp.sample_code or '').strip()}"
        rows.append(
            _build_list_summary_row(
                sp,
                proto,
                party,
                progress,
                schedules=schedules,
                transfers=transfers,
                sample_meta=sample_meta_by_key.get(meta_key),
            )
        )
    return _filter_and_page_progress(rows, progress_status, page, page_size)


def get_sample_payment_detail(
    db: Session,
    *,
    sample_payment_id: str,
    tenant_no: str,
    user_info=None,
) -> Optional[Dict[str, Any]]:
    q = (
        db.query(
            BizProtocolSamplePayment,
            BizCollectionProtocol,
            BizProtocolPartyCustomer,
        )
        .join(
            BizCollectionProtocol,
            and_(
                BizCollectionProtocol.id
                == BizProtocolSamplePayment.collection_protocol_id,
                BizCollectionProtocol.del_flag == 0,
            ),
        )
        .outerjoin(
            BizProtocolPartyCustomer,
            and_(
                BizProtocolPartyCustomer.collection_protocol_id
                == BizProtocolSamplePayment.collection_protocol_id,
                BizProtocolPartyCustomer.tenant_no == tenant_no,
                BizProtocolPartyCustomer.del_flag == 0,
            ),
        )
        .filter(
            BizProtocolSamplePayment.id == sample_payment_id,
            BizProtocolSamplePayment.tenant_no == tenant_no,
            BizProtocolSamplePayment.del_flag == 0,
        )
    )
    if user_info:
        from app.core.data_scope import apply_data_scope

        q = apply_data_scope(q, BizCollectionProtocol, user_info, db, tenant_no)
    row = q.first()
    if not row:
        return None
    sp, proto, party = row
    schedules_by_payment, transfers_by_payment = _load_payment_children_batch(
        db, [sp.id], tenant_no
    )
    schedules = schedules_by_payment.get(sp.id, [])
    transfers = transfers_by_payment.get(sp.id, [])
    by_schedule: Dict[str, List[BizProtocolPaymentTransfer]] = {}
    for t in transfers:
        by_schedule.setdefault(t.schedule_id, []).append(t)
    detail = _sample_payment_to_dict(db, sp, schedules, by_schedule, tenant_no)
    detail["protocolNo"] = (proto.protocol_no if proto else "") or ""
    detail["protocolStatus"] = (proto.protocol_status if proto else "") or ""
    detail["voidType"] = (proto.void_type if proto else "") or ""
    detail["motherName"] = (party.mother_name if party else "") or ""
    detail["motherPhone"] = (party.mother_phone if party else "") or ""
    progress = _compute_progress_for_payment(schedules, transfers)
    detail.update(_progress_to_json_fields(progress))
    return detail


def list_payment_chase_page(
    db: Session,
    *,
    tenant_no: str,
    keyword: Optional[str] = None,
    chase_type: Optional[str] = None,
    pay_mode: Optional[str] = None,
    sales_user_id: Optional[str] = None,
    page: int = 1,
    page_size: int = 10,
    user_info=None,
    today: Optional[Any] = None,
) -> Tuple[List[Dict[str, Any]], int]:
    """催缴列表：一行 = 一个欠缴>0 且（逾期或未来30天内）的应缴期。"""
    from datetime import date as date_cls

    if not tenant_no:
        return [], 0
    today_d = today if isinstance(today, date_cls) else date_cls.today()

    q = (
        db.query(
            BizProtocolPaymentSchedule,
            BizProtocolSamplePayment,
            BizCollectionProtocol,
            BizProtocolPartyCustomer,
            BizProtocolCollectionInfo,
        )
        .join(
            BizProtocolSamplePayment,
            and_(
                BizProtocolSamplePayment.id
                == BizProtocolPaymentSchedule.sample_payment_id,
                BizProtocolSamplePayment.del_flag == 0,
            ),
        )
        .join(
            BizCollectionProtocol,
            and_(
                BizCollectionProtocol.id
                == BizProtocolPaymentSchedule.collection_protocol_id,
                BizCollectionProtocol.del_flag == 0,
            ),
        )
        .outerjoin(
            BizProtocolPartyCustomer,
            and_(
                BizProtocolPartyCustomer.collection_protocol_id
                == BizProtocolPaymentSchedule.collection_protocol_id,
                BizProtocolPartyCustomer.tenant_no == tenant_no,
                BizProtocolPartyCustomer.del_flag == 0,
            ),
        )
        .outerjoin(
            BizProtocolCollectionInfo,
            and_(
                BizProtocolCollectionInfo.collection_protocol_id
                == BizProtocolPaymentSchedule.collection_protocol_id,
                BizProtocolCollectionInfo.tenant_no == tenant_no,
                BizProtocolCollectionInfo.del_flag == 0,
            ),
        )
        .filter(
            BizProtocolPaymentSchedule.tenant_no == tenant_no,
            BizProtocolPaymentSchedule.del_flag == 0,
            BizProtocolPaymentSchedule.schedule_status != "void",
        )
    )
    kw = (keyword or "").strip()
    if kw:
        like = f"%{kw}%"
        q = q.filter(
            or_(
                BizCollectionProtocol.protocol_no.like(like),
                BizProtocolSamplePayment.sample_code.like(like),
                BizProtocolPartyCustomer.mother_name.like(like),
                BizProtocolPartyCustomer.mother_phone.like(like),
            )
        )
    mode = (pay_mode or "").strip()
    if mode:
        q = q.filter(BizProtocolSamplePayment.pay_mode == mode)
    sid = (sales_user_id or "").strip()
    if sid:
        q = q.filter(BizProtocolCollectionInfo.sales_user_id == sid)
    if user_info:
        from app.core.data_scope import apply_data_scope

        q = apply_data_scope(q, BizCollectionProtocol, user_info, db, tenant_no)

    candidates = q.all()
    if not candidates:
        return [], 0

    sch_ids = [sch.id for sch, _, _, _, _ in candidates]
    transfers = (
        db.query(BizProtocolPaymentTransfer)
        .filter(
            BizProtocolPaymentTransfer.schedule_id.in_(sch_ids),
            BizProtocolPaymentTransfer.tenant_no == tenant_no,
            BizProtocolPaymentTransfer.del_flag == 0,
        )
        .all()
    )
    by_sch: Dict[str, List[BizProtocolPaymentTransfer]] = {}
    for t in transfers:
        by_sch.setdefault(t.schedule_id, []).append(t)

    sales_ids = list(
        {
            (ci.sales_user_id or "").strip()
            for _, _, _, _, ci in candidates
            if ci and ci.sales_user_id
        }
    )
    sales_name_map: Dict[str, str] = {}
    if sales_ids:
        for u in db.query(SysUser.id, SysUser.nick_name).filter(SysUser.id.in_(sales_ids)).all():
            sales_name_map[u.id] = u.nick_name or ""

    ct = (chase_type or "").strip()
    rows: List[Dict[str, Any]] = []
    for sch, sp, proto, party, ci in candidates:
        due_d = parse_due_date_ymd(sch.due_date)
        if due_d is None:
            continue
        tr_maps = [
            {
                "transferAmount": t.transfer_amount,
                "transferType": t.transfer_type or "",
                "transferTime": t.transfer_time.strftime("%Y-%m-%d %H:%M:%S")
                if t.transfer_time
                else "",
                "payStatus": t.pay_status or "",
            }
            for t in by_sch.get(sch.id, [])
        ]
        paid, arr = chase_period_money(
            due_amount=sch.due_amount, transfers=tr_maps
        )
        if not is_chase_candidate(due_date=due_d, today=today_d, arrears=arr):
            continue
        overdue = due_d < today_d
        if ct == "overdue" and not overdue:
            continue
        if ct == "upcoming" and overdue:
            continue
        days_overdue = (today_d - due_d).days if overdue else 0
        days_until = (due_d - today_d).days if not overdue else 0
        rows.append(
            {
                "scheduleId": sch.id,
                "samplePaymentId": sp.id,
                "protocolId": proto.id if proto else sch.collection_protocol_id,
                "protocolNo": (proto.protocol_no if proto else "") or "",
                "motherName": (party.mother_name if party else "") or "",
                "motherPhone": (party.mother_phone if party else "") or "",
                "sampleCode": sp.sample_code or sch.sample_code or "",
                "salesUserId": (ci.sales_user_id if ci else "") or "",
                "salesUserName": sales_name_map.get(
                    (ci.sales_user_id if ci else "") or "", ""
                ),
                "payMode": sp.pay_mode or "",
                "scheduleNo": sch.schedule_no,
                "dueDate": _fmt_ymd8(sch.due_date),
                "dueAmount": float(sch.due_amount) if sch.due_amount is not None else None,
                "paidAmount": float(paid),
                "arrearsAmount": float(arr),
                "chaseStatus": "overdue" if overdue else "upcoming",
                "daysOverdue": days_overdue,
                "daysUntilDue": days_until,
                "protocolStatus": (proto.protocol_status if proto else "") or "",
                "voidType": (proto.void_type if proto else "") or "",
            }
        )

    rows.sort(
        key=lambda r: (
            0 if r["chaseStatus"] == "overdue" else 1,
            -int(r.get("daysOverdue") or 0),
            str(r.get("dueDate") or ""),
            str(r.get("protocolNo") or ""),
        )
    )
    total = len(rows)
    page = max(1, page)
    page_size = min(max(1, page_size), 100)
    start = (page - 1) * page_size
    return rows[start : start + page_size], total