zkxw/backend/app/api/collection_protocol.py

"""细胞存储 — 采集协议单 / 审核 / 财务确认 / 分期预警 API"""
from datetime import datetime, timedelta
from typing import Any, Dict, List, Optional

from fastapi import APIRouter, Depends, Query
from pydantic import BaseModel, ConfigDict, Field
from sqlalchemy.orm import Session

from sqlalchemy import and_ as sa_and, func as sa_func

from app.core.database import get_db
from app.core.menu_guard import require_admin_or_super_admin
from app.core.response import error_response, success_response
from app.core.utils import parse_datetime
from app.crud import collection_protocol as cp_svc
from app.crud import customer as customer_crud
from app.models.models import (
    BizCollectionProtocol,
    BizCustomer,
    BizProtocolPartyCustomer,
    BizProtocolSample,
    BizProtocolStorageCert,
    SysUser,
)

router = APIRouter(prefix="/web/admin", tags=["细胞存储"])


def _get_tenant_no(db: Session, user: dict) -> str:
    user_id = user.get("user_id")
    if not user_id:
        raise PermissionError("用户身份信息缺失，无法确定租户")
    sys_user = db.query(SysUser).filter(SysUser.id == user_id).first()
    if not sys_user or not sys_user.tenant_no:
        raise PermissionError("用户租户信息缺失")
    return sys_user.tenant_no


def _get_current_user_id(user: dict) -> str:
    user_id = user.get("user_id")
    if not user_id:
        raise PermissionError("用户身份信息缺失")
    return str(user_id)


def _protocol_accessible(
    db: Session, protocol_id: str, tenant_no: str, user: dict
) -> bool:
    """与列表接口一致：按租户 + 角色数据权限判断是否可访问该协议单。"""
    from app.core.data_scope import apply_data_scope

    q = db.query(BizCollectionProtocol).filter(
        BizCollectionProtocol.id == protocol_id,
        BizCollectionProtocol.del_flag == 0,
        BizCollectionProtocol.tenant_no == tenant_no,
    )
    q = apply_data_scope(q, BizCollectionProtocol, user, db, tenant_no)
    return q.first() is not None


_CAMEL_TO_SNAKE_DATETIME = {
    "newbornDeliveryTime": "newborn_delivery_time",
    "sampleCollectTime": "sample_collect_time",
    "maternalBloodCollectTime": "maternal_blood_collect_time",
}


def _parse_datetime_fields(d: dict, camel_keys: list) -> None:
    for camel in camel_keys:
        val = d.get(camel)
        if val is not None and isinstance(val, str):
            snake = _CAMEL_TO_SNAKE_DATETIME.get(camel, camel)
            parsed = parse_datetime(val)
            if parsed:
                d.pop(camel, None)
                d[snake] = parsed
            else:
                d.pop(camel, None)
                d[snake] = None


def _ensure_customer_for_mother(db: Session, party_customer: dict, tenant_no: str, user_id: str) -> dict:
    """If mother info exists but no customerId, create a customer record and link it."""
    if not party_customer:
        return party_customer
    customer_id = party_customer.get("customer_id") or party_customer.get("customerId")
    mother_name = (party_customer.get("mother_name") or party_customer.get("motherName") or "").strip()
    if customer_id or not mother_name:
        return party_customer
    # Build customer fields from mother info
    mother_phone = (party_customer.get("mother_phone") or party_customer.get("motherPhone") or "").strip() or None
    mother_id_card = (party_customer.get("mother_id_card") or party_customer.get("motherIdCard") or "").strip() or None

    # Check if customer with this id_card already exists
    if mother_id_card and customer_crud.id_card_taken(db, mother_id_card, tenant_no):
        existing = db.query(BizCustomer).filter(
            sa_and(
                BizCustomer.id_card_no == mother_id_card,
                BizCustomer.tenant_no == tenant_no,
                BizCustomer.del_flag == 0,
            )
        ).first()
        if existing:
            party_customer["customer_id"] = existing.id
            return party_customer

    # Create new customer
    try:
        obj = customer_crud.create_customer(
            db,
            customer_name=mother_name,
            sex="1",  # female (mother)
            id_card_no=mother_id_card,
            phone_no=mother_phone,
            tenant_no=tenant_no,
            user_id=user_id,
        )
        party_customer["customer_id"] = obj.id
    except ValueError:
        # If creation fails (e.g. duplicate), try to find existing
        pass
    return party_customer


# ---------------------------------------------------------------------------
# 采集协议单
# ---------------------------------------------------------------------------


@router.get("/collection-protocols")
async def list_collection_protocols(
    page: int = Query(1, ge=1),
    pageSize: int = Query(10, ge=1, le=100, alias="pageSize"),
    keyword: Optional[str] = None,
    protocolStatus: Optional[str] = Query(None, alias="protocolStatus"),
    createTimeStart: Optional[str] = Query(None, alias="createTimeStart"),
    createTimeEnd: Optional[str] = Query(None, alias="createTimeEnd"),
    sampleCollectTimeStart: Optional[str] = Query(None, alias="sampleCollectTimeStart"),
    sampleCollectTimeEnd: Optional[str] = Query(None, alias="sampleCollectTimeEnd"),
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    items, total = cp_svc.list_collection_protocols(
        db,
        page=page,
        page_size=pageSize,
        keyword=keyword,
        protocol_status=protocolStatus,
        create_time_start=createTimeStart,
        create_time_end=createTimeEnd,
        sample_collect_time_start=sampleCollectTimeStart,
        sample_collect_time_end=sampleCollectTimeEnd,
        tenant_no=tenant_no,
        user_info=user,
    )
    tp = cp_svc.total_pages(total, pageSize)
    return success_response({"list": items, "total": total, "page": page, "pageSize": pageSize, "totalPages": tp})


@router.get("/collection-protocols/{protocol_id}")
async def get_collection_protocol_detail(
    protocol_id: str,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    if not _protocol_accessible(db, protocol_id, tenant_no, user):
        return error_response(404, "协议单不存在或无权查看")
    bundle = cp_svc.get_protocol_detail_bundle(db, protocol_id, tenant_no)
    if not bundle:
        return error_response(404, "协议单不存在或无权查看")
    return success_response(bundle)


class ProtocolCreateBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    protocol_no: Optional[str] = Field(None, alias="protocolNo")
    protocol_no_id: Optional[str] = Field(None, alias="protocolNoId")
    protocol_status: str = Field("dsx", alias="protocolStatus")
    protocol_attachments: Optional[str] = Field(None, alias="protocolAttachments")
    consent_form_urls: Optional[str] = Field(None, alias="consentFormUrls")
    health_survey_form_urls: Optional[str] = Field(None, alias="healthSurveyFormUrls")
    register_date: Optional[str] = Field(None, alias="registerDate")
    collector_user_id: Optional[str] = Field(None, alias="collectorUserId")
    remark: Optional[str] = None
    party_customer: Optional[dict] = Field(None, alias="partyCustomer")
    collection_info: Optional[dict] = Field(None, alias="collectionInfo")
    samples: Optional[list] = Field(None, alias="samples")
    payment: Optional[dict] = Field(None, alias="payment")
    payment_details: Optional[list] = Field(None, alias="paymentDetails")
    attachments: Optional[list] = Field(None, alias="attachments")
    consent_attachments: Optional[list] = Field(None, alias="consentAttachments")
    health_survey_attachments: Optional[list] = Field(None, alias="healthSurveyAttachments")
    storage_cert: Optional[dict] = Field(None, alias="storageCert")


class ProtocolUpdateBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    protocol_no: Optional[str] = Field(None, alias="protocolNo")
    protocol_status: Optional[str] = Field(None, alias="protocolStatus")
    protocol_attachments: Optional[str] = Field(None, alias="protocolAttachments")
    consent_form_urls: Optional[str] = Field(None, alias="consentFormUrls")
    health_survey_form_urls: Optional[str] = Field(None, alias="healthSurveyFormUrls")
    register_date: Optional[str] = Field(None, alias="registerDate")
    effective_time: Optional[str] = Field(None, alias="effectiveTime")
    effective_desc: Optional[str] = Field(None, alias="effectiveDesc")
    expire_time: Optional[str] = Field(None, alias="expireTime")
    expire_desc: Optional[str] = Field(None, alias="expireDesc")
    void_time: Optional[str] = Field(None, alias="voidTime")
    void_desc: Optional[str] = Field(None, alias="voidDesc")
    void_type: Optional[str] = Field(None, alias="voidType")
    to_research_time: Optional[str] = Field(None, alias="toResearchTime")
    to_research_desc: Optional[str] = Field(None, alias="toResearchDesc")
    collector_user_id: Optional[str] = Field(None, alias="collectorUserId")
    remark: Optional[str] = None
    party_customer: Optional[dict] = Field(None, alias="partyCustomer")
    collection_info: Optional[dict] = Field(None, alias="collectionInfo")
    samples: Optional[list] = Field(None, alias="samples")
    payment: Optional[dict] = Field(None, alias="payment")
    payment_details: Optional[list] = Field(None, alias="paymentDetails")
    attachments: Optional[list] = Field(None, alias="attachments")
    consent_attachments: Optional[list] = Field(None, alias="consentAttachments")
    health_survey_attachments: Optional[list] = Field(None, alias="healthSurveyAttachments")
    storage_cert: Optional[dict] = Field(None, alias="storageCert")


def _resolve_protocol_attachments(
    protocol_attachments: Optional[str],
    attachments: Optional[list],
) -> Optional[str]:
    from_urls = cp_svc.attachments_to_urls(attachments)
    if from_urls:
        return from_urls
    return protocol_attachments


def _resolve_consent_form_urls(
    consent_form_urls: Optional[str],
    consent_attachments: Optional[list],
) -> Optional[str]:
    from_urls = cp_svc.attachments_to_urls(consent_attachments)
    if from_urls:
        return from_urls
    return consent_form_urls


def _resolve_health_survey_form_urls(
    health_survey_form_urls: Optional[str],
    health_survey_attachments: Optional[list],
) -> Optional[str]:
    from_urls = cp_svc.attachments_to_urls(health_survey_attachments)
    if from_urls:
        return from_urls
    return health_survey_form_urls


def _persist_protocol_sub_resources(
    db: Session,
    protocol_id: str,
    tenant_no: str,
    user_id: str,
    *,
    party_customer: Optional[dict],
    collection_info: Optional[dict],
    samples: Optional[list],
    payment: Optional[dict],
    payment_details: Optional[list],
    storage_cert: Optional[dict],
) -> None:
    if party_customer:
        _parse_datetime_fields(party_customer, ["newbornDeliveryTime"])
        party_customer = _ensure_customer_for_mother(db, party_customer, tenant_no, user_id)
        cp_svc.upsert_party_customer(db, protocol_id, tenant_no, user_id, **party_customer)
    if collection_info:
        _parse_datetime_fields(collection_info, ["sampleCollectTime", "maternalBloodCollectTime"])
        cp_svc.upsert_collection_info(db, protocol_id, tenant_no, user_id, **collection_info)
    if samples is not None:
        cp_svc.save_samples(db, protocol_id, tenant_no, user_id, samples)
    pay = None
    if payment:
        pay = cp_svc.upsert_payment(db, protocol_id, tenant_no, user_id, **payment)
    if payment_details is not None:
        if not pay and payment:
            pay = cp_svc.upsert_payment(db, protocol_id, tenant_no, user_id, **payment)
        if pay:
            aligned_details = cp_svc.align_fq_payment_details_payload(pay, payment_details)
            cp_svc.save_payment_details(db, pay.id, tenant_no, user_id, aligned_details)
    if storage_cert:
        cp_svc.upsert_storage_cert(db, protocol_id, tenant_no, user_id, **storage_cert)


@router.post("/collection-protocols")
async def create_collection_protocol(
    body: ProtocolCreateBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    user_id = _get_current_user_id(user)
    try:
        protocol_attachments = _resolve_protocol_attachments(
            body.protocol_attachments,
            body.attachments,
        )
        consent_form_urls = _resolve_consent_form_urls(
            body.consent_form_urls,
            body.consent_attachments,
        )
        health_survey_form_urls = _resolve_health_survey_form_urls(
            body.health_survey_form_urls,
            body.health_survey_attachments,
        )
        collector = (body.collector_user_id or "").strip()
        if not collector:
            collector = user_id
        obj = cp_svc.create_collection_protocol(
            db,
            protocol_no=body.protocol_no or "",
            protocol_no_id=body.protocol_no_id,
            protocol_status=body.protocol_status,
            protocol_attachments=protocol_attachments,
            consent_form_urls=consent_form_urls,
            health_survey_form_urls=health_survey_form_urls,
            register_date=body.register_date,
            collector_user_id=collector,
            remark=body.remark,
            tenant_no=tenant_no,
            user_id=user_id,
        )
        protocol_id = obj.id
        _persist_protocol_sub_resources(
            db,
            protocol_id,
            tenant_no,
            user_id,
            party_customer=body.party_customer,
            collection_info=body.collection_info,
            samples=body.samples,
            payment=body.payment,
            payment_details=body.payment_details,
            storage_cert=body.storage_cert,
        )
        return success_response(cp_svc._protocol_to_dict(obj), message="创建成功")
    except ValueError as e:
        return error_response(400, str(e))


@router.put("/collection-protocols/{protocol_id}")
async def update_collection_protocol(
    protocol_id: str,
    body: ProtocolUpdateBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    user_id = _get_current_user_id(user)
    if not _protocol_accessible(db, protocol_id, tenant_no, user):
        return error_response(404, "协议单不存在或无权操作")
    try:
        payload = body.model_dump(exclude_unset=True, by_alias=False)
        sub_keys = {
            "party_customer", "collection_info", "samples",
            "payment", "payment_details", "attachments",
            "consent_attachments", "health_survey_attachments", "storage_cert",
        }
        main_payload = {k: v for k, v in payload.items() if k not in sub_keys}
        if body.attachments is not None:
            resolved = _resolve_protocol_attachments(
                main_payload.get("protocol_attachments"),
                body.attachments,
            )
            if resolved is not None:
                main_payload["protocol_attachments"] = resolved
        if body.consent_attachments is not None:
            resolved = _resolve_consent_form_urls(
                main_payload.get("consent_form_urls"),
                body.consent_attachments,
            )
            if resolved is not None:
                main_payload["consent_form_urls"] = resolved
        if body.health_survey_attachments is not None:
            resolved = _resolve_health_survey_form_urls(
                main_payload.get("health_survey_form_urls"),
                body.health_survey_attachments,
            )
            if resolved is not None:
                main_payload["health_survey_form_urls"] = resolved
        obj = cp_svc.update_collection_protocol(
            db,
            protocol_id,
            tenant_no=tenant_no,
            user_id=user_id,
            **{k: v for k, v in main_payload.items() if v is not None},
        )
        _persist_protocol_sub_resources(
            db,
            protocol_id,
            tenant_no,
            user_id,
            party_customer=body.party_customer,
            collection_info=body.collection_info,
            samples=body.samples,
            payment=body.payment,
            payment_details=body.payment_details,
            storage_cert=body.storage_cert,
        )
        return success_response(cp_svc._protocol_to_dict(obj), message="更新成功")
    except ValueError as e:
        return error_response(400, str(e))


@router.delete("/collection-protocols/{protocol_id}")
async def delete_collection_protocol(
    protocol_id: str,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    user_id = _get_current_user_id(user)
    if not _protocol_accessible(db, protocol_id, tenant_no, user):
        return error_response(404, "协议单不存在或无权操作")
    try:
        cp_svc.soft_delete_collection_protocol(
            db,
            protocol_id,
            tenant_no=tenant_no,
            user_id=user_id,
        )
        return success_response(None, message="删除成功")
    except ValueError as e:
        return error_response(400, str(e))


# ---------------------------------------------------------------------------
# 审核
# ---------------------------------------------------------------------------


@router.get("/collection-protocol-audits")
async def list_collection_protocol_audits(
    page: int = Query(1, ge=1),
    pageSize: int = Query(10, ge=1, le=100, alias="pageSize"),
    keyword: Optional[str] = None,
    auditStatus: Optional[str] = Query(None, alias="auditStatus"),
    collectionProtocolId: Optional[str] = Query(None, alias="collectionProtocolId"),
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    items, total = cp_svc.list_audits(
        db,
        page=page,
        page_size=pageSize,
        keyword=keyword,
        audit_status=auditStatus,
        collection_protocol_id=collectionProtocolId,
        tenant_no=tenant_no,
        user_info=user,
    )
    tp = cp_svc.total_pages(total, pageSize)
    return success_response({"list": items, "total": total, "page": page, "pageSize": pageSize, "totalPages": tp})


class AuditCreateBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    audit_status: str = Field(..., alias="auditStatus")
    audit_remark: Optional[str] = Field(None, alias="auditRemark")


@router.post("/collection-protocols/{protocol_id}/audit")
async def submit_collection_protocol_audit(
    protocol_id: str,
    body: AuditCreateBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    try:
        cp_svc.create_audit(
            db,
            collection_protocol_id=protocol_id,
            audit_status=body.audit_status,
            audit_remark=body.audit_remark,
            tenant_no=tenant_no,
            user_id=user.get("user_id"),
        )
        p = db.query(BizCollectionProtocol).filter(BizCollectionProtocol.id == protocol_id).first()
        pn = (p.protocol_no if p else "") or ""
        return success_response({"protocolNo": pn}, message="审核已提交")
    except ValueError as e:
        return error_response(400, str(e))


# ---------------------------------------------------------------------------
# 收款确认
# ---------------------------------------------------------------------------


@router.get("/protocol-payment-details")
async def list_payment_details(
    page: int = Query(1, ge=1),
    pageSize: int = Query(10, ge=1, le=100, alias="pageSize"),
    payStatus: str = Query("dfj", alias="payStatus"),
    keyword: str = Query("", alias="keyword"),
    transferType: str = Query("", alias="transferType"),
    installmentDueDateStart: Optional[str] = Query(None, alias="installmentDueDateStart"),
    installmentDueDateEnd: Optional[str] = Query(None, alias="installmentDueDateEnd"),
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    items, total = cp_svc.list_payment_details_page(
        db,
        page=page,
        page_size=pageSize,
        pay_status=payStatus,
        keyword=keyword or None,
        transfer_type=transferType or None,
        installment_due_date_start=installmentDueDateStart,
        installment_due_date_end=installmentDueDateEnd,
        tenant_no=tenant_no,
        user_info=user,
    )
    tp = cp_svc.total_pages(total, pageSize)
    return success_response({"list": items, "total": total, "page": page, "pageSize": pageSize, "totalPages": tp})


class BatchDetailIdsBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    detail_ids: List[str] = Field(..., alias="detailIds", min_length=1)


class PaymentDetailDraftBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    transfer_type: Optional[str] = Field(None, alias="transferType")
    transfer_amount: Optional[float] = Field(None, alias="transferAmount")
    transfer_time: Optional[str] = Field(None, alias="transferTime")
    transfer_attachments: Optional[str] = Field(None, alias="transferAttachments")
    remark: Optional[str] = None


def _draft_fields_from_body(body: PaymentDetailDraftBody) -> dict:
    return body.model_dump(exclude_unset=True)


@router.put("/protocol-payment-details/{detail_id}")
async def put_payment_detail_draft(
    detail_id: str,
    body: PaymentDetailDraftBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    fields = _draft_fields_from_body(body)
    if not fields:
        return error_response(400, "请提供需要保存的字段")
    try:
        cp_svc.update_payment_detail_draft(
            db,
            detail_id=detail_id,
            tenant_no=tenant_no,
            user_id=user.get("user_id"),
            draft_fields=fields,
        )
        return success_response(None, message="保存成功")
    except ValueError as e:
        return error_response(400, str(e))


class RefundFinanceSubmitBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    refund_amount: float = Field(..., alias="refundAmount", gt=0)
    refund_remark: Optional[str] = Field(None, alias="refundRemark")
    refund_attachments: Optional[str] = Field(None, alias="refundAttachments")


class BatchRefundFinanceSubmitBody(RefundFinanceSubmitBody):
    model_config = ConfigDict(populate_by_name=True)

    detail_ids: List[str] = Field(..., alias="detailIds", min_length=1)


@router.post("/protocol-payment-details/{detail_id}/submit-receipt-finance")
async def post_submit_receipt_finance(
    detail_id: str,
    body: PaymentDetailDraftBody = PaymentDetailDraftBody(),
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    fields = _draft_fields_from_body(body)
    try:
        cp_svc.submit_receipt_finance(
            db,
            detail_id=detail_id,
            tenant_no=tenant_no,
            user_id=user.get("user_id"),
            draft_fields=fields or None,
        )
        return success_response(None, message="提交成功")
    except ValueError as e:
        return error_response(400, str(e))


@router.post("/protocol-payment-details/submit-receipt-finance-batch")
async def post_submit_receipt_finance_batch(
    body: BatchDetailIdsBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    try:
        count = cp_svc.batch_submit_receipt_finance(
            db,
            detail_ids=body.detail_ids,
            tenant_no=tenant_no,
            user_id=user.get("user_id"),
        )
        return success_response({"count": count}, message=f"已成功提交 {count} 条")
    except ValueError as e:
        return error_response(400, str(e))


@router.post("/protocol-payment-details/{detail_id}/submit-refund-finance")
async def post_submit_refund_finance(
    detail_id: str,
    body: RefundFinanceSubmitBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    try:
        cp_svc.submit_refund_finance(
            db,
            detail_id=detail_id,
            tenant_no=tenant_no,
            user_id=user.get("user_id"),
            refund_amount=body.refund_amount,
            refund_remark=body.refund_remark,
            refund_attachments=body.refund_attachments,
        )
        return success_response(None, message="提交成功")
    except ValueError as e:
        return error_response(400, str(e))


@router.post("/protocol-payment-details/submit-refund-finance-batch")
async def post_submit_refund_finance_batch(
    body: BatchRefundFinanceSubmitBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    try:
        count = cp_svc.batch_submit_refund_finance(
            db,
            detail_ids=body.detail_ids,
            tenant_no=tenant_no,
            user_id=user.get("user_id"),
            refund_amount=body.refund_amount,
            refund_remark=body.refund_remark,
            refund_attachments=body.refund_attachments,
        )
        return success_response({"count": count}, message=f"已成功提交 {count} 条")
    except ValueError as e:
        return error_response(400, str(e))


@router.get("/protocol-payment-details/receipt-confirm")
async def list_receipt_confirm(
    page: int = Query(1, ge=1),
    pageSize: int = Query(10, ge=1, le=100, alias="pageSize"),
    keyword: Optional[str] = None,
    installmentDueDateStart: Optional[str] = Query(None, alias="installmentDueDateStart"),
    installmentDueDateEnd: Optional[str] = Query(None, alias="installmentDueDateEnd"),
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    items, total = cp_svc.list_receipt_confirm_details(
        db,
        page=page,
        page_size=pageSize,
        keyword=keyword or None,
        installment_due_date_start=installmentDueDateStart,
        installment_due_date_end=installmentDueDateEnd,
        tenant_no=tenant_no,
        user_info=user,
    )
    tp = cp_svc.total_pages(total, pageSize)
    return success_response({"list": items, "total": total, "page": page, "pageSize": pageSize, "totalPages": tp})


@router.get("/protocol-payment-details/receipt-confirmed")
async def list_receipt_confirmed(
    page: int = Query(1, ge=1),
    pageSize: int = Query(10, ge=1, le=100, alias="pageSize"),
    keyword: Optional[str] = None,
    installmentDueDateStart: Optional[str] = Query(None, alias="installmentDueDateStart"),
    installmentDueDateEnd: Optional[str] = Query(None, alias="installmentDueDateEnd"),
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    items, total = cp_svc.list_receipt_confirmed_details(
        db,
        page=page,
        page_size=pageSize,
        keyword=keyword or None,
        installment_due_date_start=installmentDueDateStart,
        installment_due_date_end=installmentDueDateEnd,
        tenant_no=tenant_no,
        user_info=user,
    )
    tp = cp_svc.total_pages(total, pageSize)
    return success_response({"list": items, "total": total, "page": page, "pageSize": pageSize, "totalPages": tp})


class FinanceConfirmBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    finance_confirm_attachments: Optional[str] = Field(None, alias="financeConfirmAttachments")
    finance_remark: Optional[str] = Field(None, alias="financeRemark")


class RefundFinanceConfirmBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    refund_finance_confirm_attachments: Optional[str] = Field(
        None, alias="refundFinanceConfirmAttachments"
    )
    refund_finance_remark: Optional[str] = Field(None, alias="refundFinanceRemark")


@router.post("/protocol-payment-details/{detail_id}/receipt-confirm")
async def post_receipt_confirm(
    detail_id: str,
    body: FinanceConfirmBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    try:
        cp_svc.confirm_receipt(
            db,
            detail_id=detail_id,
            tenant_no=tenant_no,
            user_id=user.get("user_id"),
            finance_confirm_attachments=body.finance_confirm_attachments,
            finance_remark=body.finance_remark,
        )
        return success_response(None, message="确认成功")
    except ValueError as e:
        return error_response(400, str(e))


@router.post("/protocol-payment-details/{detail_id}/receipt-reject")
async def post_receipt_reject(
    detail_id: str,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    try:
        cp_svc.reject_receipt(
            db,
            detail_id=detail_id,
            tenant_no=tenant_no,
            user_id=user.get("user_id"),
        )
        return success_response(None, message="退回成功")
    except ValueError as e:
        return error_response(400, str(e))


# ---------------------------------------------------------------------------
# 退费确认
# ---------------------------------------------------------------------------


@router.get("/protocol-payment-details/refund-confirm")
async def list_refund_confirm(
    page: int = Query(1, ge=1),
    pageSize: int = Query(10, ge=1, le=100, alias="pageSize"),
    keyword: Optional[str] = None,
    installmentDueDateStart: Optional[str] = Query(None, alias="installmentDueDateStart"),
    installmentDueDateEnd: Optional[str] = Query(None, alias="installmentDueDateEnd"),
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    items, total = cp_svc.list_refund_confirm_details(
        db,
        page=page,
        page_size=pageSize,
        keyword=keyword or None,
        installment_due_date_start=installmentDueDateStart,
        installment_due_date_end=installmentDueDateEnd,
        tenant_no=tenant_no,
        user_info=user,
    )
    tp = cp_svc.total_pages(total, pageSize)
    return success_response({"list": items, "total": total, "page": page, "pageSize": pageSize, "totalPages": tp})


@router.get("/protocol-payment-details/refund-confirmed")
async def list_refund_confirmed(
    page: int = Query(1, ge=1),
    pageSize: int = Query(10, ge=1, le=100, alias="pageSize"),
    keyword: Optional[str] = None,
    installmentDueDateStart: Optional[str] = Query(None, alias="installmentDueDateStart"),
    installmentDueDateEnd: Optional[str] = Query(None, alias="installmentDueDateEnd"),
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    items, total = cp_svc.list_refund_confirmed_details(
        db,
        page=page,
        page_size=pageSize,
        keyword=keyword or None,
        installment_due_date_start=installmentDueDateStart,
        installment_due_date_end=installmentDueDateEnd,
        tenant_no=tenant_no,
        user_info=user,
    )
    tp = cp_svc.total_pages(total, pageSize)
    return success_response({"list": items, "total": total, "page": page, "pageSize": pageSize, "totalPages": tp})


@router.post("/protocol-payment-details/{detail_id}/refund-confirm")
async def post_refund_confirm(
    detail_id: str,
    body: RefundFinanceConfirmBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    try:
        cp_svc.confirm_refund(
            db,
            detail_id=detail_id,
            tenant_no=tenant_no,
            user_id=user.get("user_id"),
            refund_finance_confirm_attachments=body.refund_finance_confirm_attachments,
            refund_finance_remark=body.refund_finance_remark,
        )
        return success_response(None, message="确认成功")
    except ValueError as e:
        return error_response(400, str(e))


@router.post("/protocol-payment-details/{detail_id}/refund-reject")
async def post_refund_reject(
    detail_id: str,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    try:
        cp_svc.reject_refund(
            db,
            detail_id=detail_id,
            tenant_no=tenant_no,
            user_id=user.get("user_id"),
        )
        return success_response(None, message="退回成功")
    except ValueError as e:
        return error_response(400, str(e))


# ---------------------------------------------------------------------------
# 储存证明管理 / 满月待办
# ---------------------------------------------------------------------------


@router.get("/storage-certs")
async def list_storage_certs(
    page: int = Query(1, ge=1),
    pageSize: int = Query(10, ge=1, le=100, alias="pageSize"),
    keyword: Optional[str] = None,
    makeStatus: Optional[str] = Query(None, alias="makeStatus"),
    storageInDateStart: Optional[str] = Query(None, alias="storageInDateStart"),
    storageInDateEnd: Optional[str] = Query(None, alias="storageInDateEnd"),
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    page_items, total = cp_svc.list_storage_certs(
        db,
        tenant_no=tenant_no,
        keyword=keyword,
        make_status=makeStatus,
        storage_in_date_start=storageInDateStart,
        storage_in_date_end=storageInDateEnd,
        page=page,
        page_size=pageSize,
        user_info=user,
    )
    page_safe = max(1, page)
    page_size_safe = min(max(1, pageSize), 100)
    tp = cp_svc.total_pages(total, page_size_safe)
    return success_response(
        {"list": page_items, "total": total, "page": page_safe, "pageSize": page_size_safe, "totalPages": tp}
    )


@router.get("/fullmoon-todos")
async def list_fullmoon_todos(
    page: int = Query(1, ge=1),
    pageSize: int = Query(10, ge=1, le=100, alias="pageSize"),
    keyword: Optional[str] = None,
    todoStatus: Optional[str] = Query(None, alias="todoStatus"),
    fullmoonDateStart: Optional[str] = Query(None, alias="fullmoonDateStart"),
    fullmoonDateEnd: Optional[str] = Query(None, alias="fullmoonDateEnd"),
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    party_join = sa_and(
        BizProtocolPartyCustomer.collection_protocol_id == BizCollectionProtocol.id,
        BizProtocolPartyCustomer.del_flag == 0,
        BizProtocolPartyCustomer.tenant_no == tenant_no,
    )
    q = (
        db.query(BizCollectionProtocol, BizProtocolPartyCustomer)
        .outerjoin(BizProtocolPartyCustomer, party_join)
        .filter(
            BizCollectionProtocol.del_flag == 0,
            BizCollectionProtocol.tenant_no == tenant_no,
            BizCollectionProtocol.protocol_status == "sxz",
        )
    )
    kw = (keyword or "").strip()
    if kw:
        like = f"%{kw}%"
        q = q.filter(BizProtocolPartyCustomer.mother_name.like(like))

    from app.core.data_scope import apply_data_scope
    q = apply_data_scope(q, BizCollectionProtocol, user, db, tenant_no)

    rows = q.order_by(BizCollectionProtocol.create_time.desc()).all()

    protocol_ids = [r.id for r, _ in rows]
    ft_map: Dict[str, Any] = {}
    if protocol_ids:
        from app.models.models import BizProtocolFullmoonTodo
        ft_rows = (
            db.query(BizProtocolFullmoonTodo)
            .filter(
                BizProtocolFullmoonTodo.collection_protocol_id.in_(protocol_ids),
                BizProtocolFullmoonTodo.tenant_no == tenant_no,
                BizProtocolFullmoonTodo.del_flag == 0,
            )
            .all()
        )
        for ft in ft_rows:
            ft_map[ft.collection_protocol_id] = ft

    now = datetime.now()
    _empty_ft: Dict[str, Any] = {
        "todoStatus": "0",
        "handleDate": "",
        "handleRemark": "",
        "insuranceAttachments": "",
        "insuranceCompanyId": "",
        "insuranceCompanyName": "",
        "insuranceType": "",
        "insurancePolicyNo": "",
        "insuranceEffectiveDate": "",
        "insuranceExpiryDate": "",
        "insuranceSubscribed": "0",
        "insuranceFee": None,
    }
    items: List[Dict[str, Any]] = []
    for proto, pc in rows:
        dt = pc.newborn_delivery_time if pc else None
        fullmoon_date_str = ""
        is_fullmoon_passed = False
        if dt:
            fullmoon_date = dt + timedelta(days=30)
            fullmoon_date_str = fullmoon_date.strftime("%Y-%m-%d")
            is_fullmoon_passed = fullmoon_date <= now
        ft = ft_map.get(proto.id)
        ts = (ft.todo_status or "0") if ft else "0"
        if todoStatus and todoStatus.strip() and ts != todoStatus.strip():
            continue
        fm_start = (fullmoonDateStart or "").strip()[:10]
        fm_end = (fullmoonDateEnd or "").strip()[:10]
        if fm_start or fm_end:
            if not fullmoon_date_str:
                continue
            if fm_start and fullmoon_date_str < fm_start:
                continue
            if fm_end and fullmoon_date_str > fm_end:
                continue
        ft_dict = cp_svc._fullmoon_todo_to_dict(ft) if ft else dict(_empty_ft)
        items.append(
            {
                "protocolId": proto.id,
                "id": proto.id,
                "protocolNo": proto.protocol_no or "",
                "protocolStatus": proto.protocol_status or "",
                "motherName": (pc.mother_name if pc else "") or "",
                "motherPhone": (pc.mother_phone if pc else "") or "",
                "newbornName": (pc.newborn_name if pc else "") or "",
                "newbornDeliveryTime": cp_svc._fmt_dt(dt) if dt else "",
                "fullmoonDate": fullmoon_date_str,
                "isFullmoonPassed": is_fullmoon_passed,
                **ft_dict,
            }
        )

    total = len(items)
    page_safe = max(1, page)
    page_size_safe = min(max(1, pageSize), 100)
    start = (page_safe - 1) * page_size_safe
    page_items = items[start : start + page_size_safe]
    tp = cp_svc.total_pages(total, page_size_safe)
    return success_response(
        {"list": page_items, "total": total, "page": page_safe, "pageSize": page_size_safe, "totalPages": tp}
    )


class FullmoonTodoInsuranceBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    insurance_company_id: Optional[str] = Field(None, alias="insuranceCompanyId")
    insurance_company_name: Optional[str] = Field(None, alias="insuranceCompanyName")
    insurance_type: Optional[str] = Field(None, alias="insuranceType")
    insurance_policy_no: Optional[str] = Field(None, alias="insurancePolicyNo")
    insurance_effective_date: Optional[str] = Field(None, alias="insuranceEffectiveDate")
    insurance_expiry_date: Optional[str] = Field(None, alias="insuranceExpiryDate")
    insurance_subscribed: Optional[str] = Field(None, alias="insuranceSubscribed")
    insurance_fee: Optional[float] = Field(None, alias="insuranceFee")
    insurance_attachments: Optional[str] = Field(None, alias="insuranceAttachments")
    todo_status: Optional[str] = Field(None, alias="todoStatus")
    handle_date: Optional[str] = Field(None, alias="handleDate")
    handle_remark: Optional[str] = Field(None, alias="handleRemark")


@router.put("/fullmoon-todos/{protocol_id}/insurance")
async def update_fullmoon_todo_insurance(
    protocol_id: str,
    body: FullmoonTodoInsuranceBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    user_id = _get_current_user_id(user)
    try:
        payload = body.model_dump(exclude_unset=True, by_alias=False)
        ft = cp_svc.upsert_fullmoon_todo(
            db,
            protocol_id,
            tenant_no,
            user_id,
            **payload,
        )
        return success_response(cp_svc._fullmoon_todo_to_dict(ft), message="更新成功")
    except ValueError as e:
        return error_response(400, str(e))


class InvoiceRequestCreateBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    payment_detail_ids: List[str] = Field(..., alias="paymentDetailIds", min_length=1)
    invoice_title: Optional[str] = Field(None, alias="invoiceTitle")
    tax_no: Optional[str] = Field(None, alias="taxNo")
    company_address: Optional[str] = Field(None, alias="companyAddress")
    company_phone: Optional[str] = Field(None, alias="companyPhone")
    bank_name: Optional[str] = Field(None, alias="bankName")
    bank_account: Optional[str] = Field(None, alias="bankAccount")
    apply_remark: Optional[str] = Field(None, alias="applyRemark")


class InvoiceRequestCompleteBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    invoice_attachments: str = Field(..., alias="invoiceAttachments")
    finance_remark: Optional[str] = Field(None, alias="financeRemark")


@router.get("/collection-protocols/{protocol_id}/invoice-eligible-payments")
async def get_invoice_eligible_payments(
    protocol_id: str,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    items = cp_svc.list_invoice_eligible_payment_details(
        db, collection_protocol_id=protocol_id, tenant_no=tenant_no
    )
    return success_response({"list": items, "total": len(items)})


@router.get("/collection-protocols/{protocol_id}/invoice-requests")
async def get_protocol_invoice_requests(
    protocol_id: str,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    items = cp_svc.list_invoice_requests_by_protocol(
        db, collection_protocol_id=protocol_id, tenant_no=tenant_no
    )
    return success_response({"list": items, "total": len(items)})


@router.post("/collection-protocols/{protocol_id}/invoice-requests")
async def post_protocol_invoice_request(
    protocol_id: str,
    body: InvoiceRequestCreateBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    try:
        row = cp_svc.create_invoice_request(
            db,
            collection_protocol_id=protocol_id,
            payment_detail_ids=body.payment_detail_ids,
            tenant_no=tenant_no,
            user_info=user,
            invoice_title=body.invoice_title,
            tax_no=body.tax_no,
            company_address=body.company_address,
            company_phone=body.company_phone,
            bank_name=body.bank_name,
            bank_account=body.bank_account,
            apply_remark=body.apply_remark,
        )
    except ValueError as e:
        return error_response(400, str(e))
    return success_response(row, message="提交成功")


@router.get("/protocol-invoice-requests")
async def list_protocol_invoice_requests_api(
    status: str = Query(..., description="dkp|ykp"),
    page: int = Query(1, ge=1),
    pageSize: int = Query(10, ge=1, le=100),
    keyword: Optional[str] = Query(None),
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    items, total = cp_svc.list_protocol_invoice_requests(
        db,
        status=status,
        page=page,
        page_size=pageSize,
        keyword=keyword,
        tenant_no=tenant_no,
        user_info=user,
    )
    return success_response({"list": items, "total": total, "page": page, "pageSize": pageSize})


@router.get("/protocol-invoice-requests/pending-count")
async def protocol_invoice_pending_count(
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    count = cp_svc.count_pending_protocol_invoice_requests(
        db, tenant_no=tenant_no, user_info=user
    )
    return success_response({"count": count})


@router.put("/protocol-invoice-requests/{request_id}/complete")
async def complete_protocol_invoice_request(
    request_id: str,
    body: InvoiceRequestCompleteBody,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    tenant_no = _get_tenant_no(db, user)
    try:
        row = cp_svc.complete_invoice_request(
            db,
            request_id=request_id,
            tenant_no=tenant_no,
            invoice_attachments=body.invoice_attachments,
            finance_remark=body.finance_remark,
            user_info=user,
        )
    except ValueError as e:
        return error_response(400, str(e))
    return success_response(row, message="已完成开票")