zkxw/backend/app/api/qc.py

"""质量检测 — 第三方/实验室主数据、质检工单、质检任务 API"""
from typing import Any, Dict, Iterable, List, Optional

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

from datetime import datetime
from decimal import Decimal

from app.core.database import get_db
from app.core.menu_guard import (
    require_admin_or_super_admin,
    require_any_menu_code,
    require_menu_code,
    strip_row_fields,
    user_has_menu_perm,
)

MY_QC_MATERIAL_USAGE_VIEW_AMOUNT_PERM = "biz:myQcMaterialUsage:viewAmount"
QC_MATERIAL_VIEW_AMOUNT_PERM = "biz:qcMaterial:viewAmount"
QC_THIRD_PARTY_VIEW_AMOUNT_PERM = "biz:qcThirdPartyCompany:viewAmount"
QC_MATERIAL_AMOUNT_FIELD_NAMES = ("unitPrice", "amount", "remainingAmount", "unit_price")
QC_THIRD_PARTY_FEE_FIELD_NAMES = ("feeAmount", "thirdPartyFeeTotal")
from app.core.response import error_response, success_response
from app.core.utils import parse_datetime
from app.crud import qc_lab_test_item as lab_svc
from app.crud import qc_item_param as param_svc
from app.crud import qc_task_result as result_svc
from app.crud import qc_task as task_svc
from app.crud import qc_third_party_company as tpc_svc
from app.crud import qc_third_party_item as tpi_svc
from app.crud import qc_material as mat_svc
from app.crud import qc_material_stock_batch as batch_svc
from app.crud import qc_material_stock_check as stock_check_svc
from app.crud import qc_material_usage as mu_svc
from app.crud import qc_material_amount_auth as amount_auth_svc
from app.core.qc_material_amount_auth_constants import QC_MATERIAL_AMOUNT_AUTH_LIST_PERM
from app.crud import inbound_sample_special as inbound_sample_special_svc
from app.crud import qc_work_order as wo_svc
from app.crud.collection_protocol import total_pages
from app.api.sample_reception import _get_current_user_id, _get_tenant_no, _page_payload
from app.schemas.qc_work_order import QcWorkOrderCreateBody, QcWorkOrderUpdateBody
from app.schemas.qc_task import QcTaskCreateBody


router = APIRouter(prefix="/web/admin", tags=["质量检测"])

# 协议/捐赠查看等场景只读打开质检任务详情（参数、附件）
QC_TASK_READONLY_MENU_CODES = (
    "biz:qcTask:list",
    "biz:myQcTask:list",
    "biz:cellStorageProtocol:list",
    "biz:cellStorageProtocolAudit:list",
    "biz:researchDonation:list",
    "biz:researchDonationAudit:list",
    "biz:storageReleaseReview:list",
    "biz:qcWorkOrder:list",
)


# ---------- 第三方检测公司 ----------


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

    company_code: str = Field(..., alias="companyCode")
    company_name: str = Field(..., alias="companyName")
    contact_name: Optional[str] = Field(None, alias="contactName")
    contact_phone: Optional[str] = Field(None, alias="contactPhone")
    company_logo: Optional[str] = Field(None, alias="companyLogo")
    address: Optional[str] = None
    invoice_title: Optional[str] = Field(None, alias="invoiceTitle")
    tax_id: Optional[str] = Field(None, alias="taxId")
    bank_name: Optional[str] = Field(None, alias="bankName")
    bank_account: Optional[str] = Field(None, alias="bankAccount")
    status: str = "1"
    order_num: Optional[int] = Field(None, alias="orderNum")
    remark: Optional[str] = None


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

    company_code: Optional[str] = Field(None, alias="companyCode")
    company_name: Optional[str] = Field(None, alias="companyName")
    contact_name: Optional[str] = Field(None, alias="contactName")
    contact_phone: Optional[str] = Field(None, alias="contactPhone")
    company_logo: Optional[str] = Field(None, alias="companyLogo")
    address: Optional[str] = None
    invoice_title: Optional[str] = Field(None, alias="invoiceTitle")
    tax_id: Optional[str] = Field(None, alias="taxId")
    bank_name: Optional[str] = Field(None, alias="bankName")
    bank_account: Optional[str] = Field(None, alias="bankAccount")
    status: Optional[str] = None
    order_num: Optional[int] = Field(None, alias="orderNum")
    remark: Optional[str] = None


@router.get("/qc-third-party-companies")
async def list_qc_third_party_companies(
    page: int = Query(1, ge=1),
    pageSize: int = Query(10, ge=1, le=100),
    keyword: Optional[str] = None,
    status: Optional[str] = None,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcThirdPartyCompany:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        items, total = tpc_svc.list_companies(
            db, page=page, page_size=pageSize, keyword=keyword, status=status, tenant_no=tenant_no,
            user_info=user
        )
        return success_response(_page_payload(items, total, page, pageSize))
    except PermissionError as e:
        return error_response(403, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.get("/qc-third-party-companies/options")
async def list_qc_third_party_company_options(
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcWorkOrder:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        return success_response(tpc_svc.list_company_options(db, tenant_no))
    except PermissionError as e:
        return error_response(403, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.post("/qc-third-party-companies")
async def create_qc_third_party_company(
    body: ThirdPartyCompanyBody,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcThirdPartyCompany:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        obj = tpc_svc.create_company(
            db,
            company_code=body.company_code,
            company_name=body.company_name,
            contact_name=body.contact_name,
            contact_phone=body.contact_phone,
            company_logo=body.company_logo,
            address=body.address,
            invoice_title=body.invoice_title,
            tax_id=body.tax_id,
            bank_name=body.bank_name,
            bank_account=body.bank_account,
            status=body.status,
            tenant_no=tenant_no,
            order_num=body.order_num,
            remark=body.remark,
            user_id=_get_current_user_id(user),
        )
        return success_response(tpc_svc._row_to_dict(obj), message="创建成功")
    except PermissionError as e:
        return error_response(403, str(e))
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.put("/qc-third-party-companies/{company_id}")
async def update_qc_third_party_company(
    company_id: str,
    body: ThirdPartyCompanyUpdateBody,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcThirdPartyCompany:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        obj = tpc_svc.update_company(
            db,
            company_id,
            company_code=body.company_code,
            company_name=body.company_name,
            contact_name=body.contact_name,
            contact_phone=body.contact_phone,
            company_logo=body.company_logo,
            address=body.address,
            invoice_title=body.invoice_title,
            tax_id=body.tax_id,
            bank_name=body.bank_name,
            bank_account=body.bank_account,
            status=body.status,
            order_num=body.order_num,
            remark=body.remark,
            user_id=_get_current_user_id(user),
            tenant_no=tenant_no,
        )
        return success_response(tpc_svc._row_to_dict(obj), message="更新成功")
    except PermissionError as e:
        return error_response(403, str(e))
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.delete("/qc-third-party-companies/{company_id}")
async def delete_qc_third_party_company(
    company_id: str,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcThirdPartyCompany:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        tpc_svc.soft_delete_company(db, company_id, tenant_no=tenant_no)
        return success_response(None, message="删除成功")
    except PermissionError as e:
        return error_response(403, str(e))
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


# ---------- 第三方检测项目 ----------


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

    company_id: str = Field(..., alias="companyId")
    item_code: str = Field(..., alias="itemCode")
    item_name: str = Field(..., alias="itemName")
    fee_amount: float = Field(..., alias="feeAmount")
    status: str = "1"
    order_num: Optional[int] = Field(None, alias="orderNum")
    remark: Optional[str] = None


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

    company_id: Optional[str] = Field(None, alias="companyId")
    item_code: Optional[str] = Field(None, alias="itemCode")
    item_name: Optional[str] = Field(None, alias="itemName")
    fee_amount: Optional[float] = Field(None, alias="feeAmount")
    status: Optional[str] = None
    order_num: Optional[int] = Field(None, alias="orderNum")
    remark: Optional[str] = None


@router.get("/qc-third-party-items")
async def list_qc_third_party_items(
    page: int = Query(1, ge=1),
    pageSize: int = Query(10, ge=1, le=100),
    keyword: Optional[str] = None,
    status: Optional[str] = None,
    companyId: Optional[str] = None,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcThirdPartyCompany:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        items, total = tpi_svc.list_items(
            db,
            page=page,
            page_size=pageSize,
            keyword=keyword,
            status=status,
            company_id=companyId,
            tenant_no=tenant_no,
            user_info=user,
        )
        return success_response(_page_payload(items, total, page, pageSize))
    except PermissionError as e:
        return error_response(403, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.get("/qc-third-party-items/active")
async def list_qc_third_party_items_active(
    companyId: Optional[str] = None,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcWorkOrder:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        return success_response(tpi_svc.list_active_items(db, tenant_no, company_id=companyId, user_info=user))
    except PermissionError as e:
        return error_response(403, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.post("/qc-third-party-items")
async def create_qc_third_party_item(
    body: ThirdPartyItemBody,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcThirdPartyCompany:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        obj = tpi_svc.create_item(
            db,
            company_id=body.company_id,
            item_code=body.item_code,
            item_name=body.item_name,
            fee_amount=body.fee_amount,
            status=body.status,
            tenant_no=tenant_no,
            order_num=body.order_num,
            remark=body.remark,
            user_id=_get_current_user_id(user),
        )
        return success_response(tpi_svc._row_to_dict(obj, ""), message="创建成功")
    except PermissionError as e:
        return error_response(403, str(e))
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.put("/qc-third-party-items/{item_id}")
async def update_qc_third_party_item(
    item_id: str,
    body: ThirdPartyItemUpdateBody,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcThirdPartyCompany:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        obj = tpi_svc.update_item(
            db,
            item_id,
            company_id=body.company_id,
            item_code=body.item_code,
            item_name=body.item_name,
            fee_amount=body.fee_amount,
            status=body.status,
            order_num=body.order_num,
            remark=body.remark,
            user_id=_get_current_user_id(user),
            tenant_no=tenant_no,
        )
        return success_response(tpi_svc._row_to_dict(obj, ""), message="更新成功")
    except PermissionError as e:
        return error_response(403, str(e))
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.delete("/qc-third-party-items/{item_id}")
async def delete_qc_third_party_item(
    item_id: str,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcThirdPartyCompany:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        tpi_svc.soft_delete_item(db, item_id, tenant_no=tenant_no)
        return success_response(None, message="删除成功")
    except PermissionError as e:
        return error_response(403, str(e))
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


# ---------- 实验室自检项目 ----------


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

    item_code: str = Field(..., alias="itemCode")
    item_name: str = Field(..., alias="itemName")
    description: Optional[str] = None
    status: str = "1"
    order_num: Optional[int] = Field(None, alias="orderNum")
    remark: Optional[str] = None


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

    item_code: Optional[str] = Field(None, alias="itemCode")
    item_name: Optional[str] = Field(None, alias="itemName")
    description: Optional[str] = None
    status: Optional[str] = None
    order_num: Optional[int] = Field(None, alias="orderNum")
    remark: Optional[str] = None


# ---------- 检测项目参数模板 ----------


class ItemParamBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)
    params: List[Dict[str, Any]] = Field(default_factory=list, alias="params")


class TaskResultBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)
    results: List[Dict[str, Any]] = Field(default_factory=list, alias="results")


class TaskCompleteWithResultBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)
    conclusion: Optional[str] = Field(None, alias="conclusion")
    results: List[Dict[str, Any]] = Field(default_factory=list, alias="results")
    remark: Optional[str] = Field(None, alias="remark")
    third_party_attachments: Optional[str] = Field(None, alias="thirdPartyAttachments")
    material_usages: Optional[List[Dict[str, Any]]] = Field(None, alias="materialUsages")
    task_status: Optional[str] = Field(None, alias="taskStatus")


@router.get("/qc-lab-test-items")
async def list_qc_lab_test_items(
    page: int = Query(1, ge=1),
    pageSize: int = Query(10, ge=1, le=100),
    keyword: Optional[str] = None,
    status: Optional[str] = None,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcLabTestItem:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        items, total = lab_svc.list_lab_items(
            db, page=page, page_size=pageSize, keyword=keyword, status=status, tenant_no=tenant_no,
            user_info=user
        )
        return success_response(_page_payload(items, total, page, pageSize))
    except PermissionError as e:
        return error_response(403, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.get("/qc-lab-test-items/active")
async def list_qc_lab_test_items_active(
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcWorkOrder:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        return success_response(lab_svc.list_active_lab_items(db, tenant_no, user_info=user))
    except PermissionError as e:
        return error_response(403, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.post("/qc-lab-test-items")
async def create_qc_lab_test_item(
    body: LabTestItemBody,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcLabTestItem:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        obj = lab_svc.create_lab_item(
            db,
            item_code=body.item_code,
            item_name=body.item_name,
            description=body.description,
            status=body.status,
            tenant_no=tenant_no,
            order_num=body.order_num,
            remark=body.remark,
            user_id=_get_current_user_id(user),
        )
        return success_response(lab_svc._row_to_dict(obj), message="创建成功")
    except PermissionError as e:
        return error_response(403, str(e))
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.put("/qc-lab-test-items/{item_id}")
async def update_qc_lab_test_item(
    item_id: str,
    body: LabTestItemUpdateBody,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcLabTestItem:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        obj = lab_svc.update_lab_item(
            db,
            item_id,
            item_code=body.item_code,
            item_name=body.item_name,
            description=body.description,
            status=body.status,
            order_num=body.order_num,
            remark=body.remark,
            user_id=_get_current_user_id(user),
            tenant_no=tenant_no,
        )
        return success_response(lab_svc._row_to_dict(obj), message="更新成功")
    except PermissionError as e:
        return error_response(403, str(e))
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.delete("/qc-lab-test-items/{item_id}")
async def delete_qc_lab_test_item(
    item_id: str,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcLabTestItem:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        lab_svc.soft_delete_lab_item(db, item_id, tenant_no=tenant_no)
        return success_response(None, message="删除成功")
    except PermissionError as e:
        return error_response(403, str(e))
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


# ---------- 检测项目参数模板 ----------


@router.get("/qc-item-params")
async def list_item_params(
    itemSource: str = Query(...),
    itemId: str = Query(...),
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcLabTestItem:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        return success_response(param_svc.list_params_by_item(db, itemSource, itemId, tenant_no, user_info=user))
    except PermissionError as e:
        return error_response(403, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.put("/qc-item-params")
async def save_item_params(
    body: ItemParamBody,
    itemSource: str = Query(...),
    itemId: str = Query(...),
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcLabTestItem:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        return success_response(
            param_svc.save_params_for_item(db, itemSource, itemId, body.params, tenant_no, _get_current_user_id(user)),
            message="保存成功",
        )
    except PermissionError as e:
        return error_response(403, str(e))
    except Exception as e:
        return error_response(400, str(e))


# ---------- 质检工单 ----------


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

    id: Optional[str] = None
    batch_name: Optional[str] = Field(None, alias="batchName")
    assignee_user_ids: List[str] = Field(default_factory=list, alias="assigneeUserIds")
    has_lab: bool = Field(False, alias="hasLab")
    has_third_party: bool = Field(False, alias="hasThirdParty")
    lab_item_ids: List[str] = Field(default_factory=list, alias="labItemIds")
    third_party_item_ids: List[str] = Field(default_factory=list, alias="thirdPartyItemIds")


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

    batches: Optional[List[WorkOrderConfigureBatchItem]] = Field(None, alias="batches")
    has_lab: bool = Field(False, alias="hasLab")
    has_third_party: bool = Field(False, alias="hasThirdParty")
    lab_item_ids: List[str] = Field(default_factory=list, alias="labItemIds")
    third_party_item_ids: List[str] = Field(default_factory=list, alias="thirdPartyItemIds")
    lab_item_assignees: Dict[str, List[str]] = Field(default_factory=dict, alias="labItemAssignees")
    third_party_item_assignees: Dict[str, List[str]] = Field(
        default_factory=dict, alias="thirdPartyItemAssignees"
    )


@router.post("/qc-work-orders")
async def create_qc_work_order(
    body: QcWorkOrderCreateBody,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcWorkOrder:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        wo_type = (body.work_order_type or "inbound").strip()
        if wo_type == "temporary":
            wo = wo_svc.create_temp_qc_work_order(
                db,
                tenant_no=tenant_no,
                user_id=user.get("user_id"),
                create_dept_id=user.get("dept_id", ""),
                cell_product_id=body.cell_product_id or "",
                remark=body.remark or "",
            )
        else:
            wo = wo_svc.create_qc_work_order_manual(
                db,
                tenant_no=tenant_no,
                user_id=user.get("user_id"),
                create_dept_id=user.get("dept_id", ""),
                protocol_no=body.protocol_no or "",
                sample_code=body.sample_code or "",
                reception_source=body.reception_source or "cell_storage",
                qc_biz_type=body.qc_biz_type or "inbound",
                remark=body.remark or "",
            )
        db.commit()
        return success_response(wo_svc._wo_to_dict(wo), message="创建成功")
    except PermissionError as e:
        return error_response(403, str(e))
    except Exception as e:
        db.rollback()
        return error_response(400, str(e))


@router.get("/qc-work-orders")
async def list_qc_work_orders(
    page: int = Query(1, ge=1),
    pageSize: int = Query(10, ge=1, le=100),
    keyword: Optional[str] = None,
    workOrderStatus: Optional[str] = Query(None, description="工单状态，多个用英文逗号分隔"),
    workOrderType: Optional[str] = None,
    bizType: Optional[str] = Query(None, alias="bizType"),
    receptionSource: Optional[str] = Query(None, alias="receptionSource"),
    createTimeStart: Optional[str] = Query(None, alias="createTimeStart"),
    createTimeEnd: Optional[str] = Query(None, alias="createTimeEnd"),
    infusionTimeStart: Optional[str] = Query(None, alias="infusionTimeStart"),
    infusionTimeEnd: Optional[str] = Query(None, alias="infusionTimeEnd"),
    triggerSource: Optional[str] = Query(None, alias="triggerSource"),
    sampleTypeId: Optional[str] = Query(None, alias="sampleTypeId"),
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcWorkOrder:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        items, total = wo_svc.list_work_orders(
            db,
            page=page,
            page_size=pageSize,
            keyword=keyword,
            work_order_status=workOrderStatus,
            work_order_type=workOrderType,
            biz_type=bizType,
            reception_source=receptionSource,
            trigger_source=triggerSource,
            sample_type_id=sampleTypeId,
            create_time_start=createTimeStart,
            create_time_end=createTimeEnd,
            infusion_time_start=infusionTimeStart,
            infusion_time_end=infusionTimeEnd,
            tenant_no=tenant_no,
            user_info=user,
        )
        return success_response(_page_payload(items, total, page, pageSize))
    except PermissionError as e:
        return error_response(403, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.get("/qc-work-orders/tab-unfinished-counts")
async def qc_work_order_tab_unfinished_counts(
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcWorkOrder:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        counts = wo_svc.count_unfinished_work_orders_by_tab(
            db, tenant_no=tenant_no, user_info=user
        )
        return success_response(counts)
    except PermissionError as e:
        return error_response(403, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.get("/qc-work-orders/mine-tab-unfinished-counts")
async def qc_work_order_mine_tab_unfinished_counts(
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:myQcTask:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        counts = wo_svc.count_mine_unfinished_work_orders_by_tab(
            db,
            tenant_no=tenant_no,
            assignee_user_id=_get_current_user_id(user),
        )
        return success_response(counts)
    except PermissionError as e:
        return error_response(403, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.get("/qc-work-orders/by-sample")
async def list_qc_work_orders_by_sample(
    sampleCode: str = Query(..., alias="sampleCode"),
    receptionSource: str = Query(..., alias="receptionSource"),
    db: Session = Depends(get_db),
    user: dict = Depends(
        require_any_menu_code("biz:qcWorkOrder:list", "biz:myQcTask:list")
    ),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        items = wo_svc.list_work_orders_by_sample(
            db,
            sample_code=sampleCode,
            reception_source=receptionSource,
            tenant_no=tenant_no,
            user_info=user,
        )
        return success_response({"list": items})
    except PermissionError as e:
        return error_response(403, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.get("/qc-work-orders/{work_order_id}")
async def get_qc_work_order_detail(
    work_order_id: str,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcWorkOrder:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        data = wo_svc.get_work_order_detail(db, work_order_id, tenant_no)
        _maybe_strip_qc_third_party_fee_fields(db, user, data)
        return success_response(data)
    except PermissionError as e:
        return error_response(403, str(e))
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.get("/qc-work-orders/{work_order_id}/outbound-detail")
async def get_outbound_qc_detail(
    work_order_id: str,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcWorkOrder:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        data = wo_svc.get_outbound_qc_detail(db, work_order_id, tenant_no)
        _maybe_strip_qc_third_party_fee_fields(db, user, data)
        return success_response(data)
    except PermissionError as e:
        return error_response(403, str(e))
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.put("/qc-work-orders/{work_order_id}")
async def update_qc_work_order(
    work_order_id: str,
    body: QcWorkOrderUpdateBody,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcWorkOrder:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        wo = wo_svc.update_qc_work_order(
            db,
            work_order_id,
            tenant_no=tenant_no,
            user_id=_get_current_user_id(user),
            cell_product_id=body.cell_product_id,
            work_order_status=body.work_order_status,
            qc_conclusion=body.qc_conclusion,
            remark=body.remark,
        )
        db.commit()
        return success_response(wo_svc._wo_to_dict(wo), message="保存成功")
    except PermissionError as e:
        return error_response(403, str(e))
    except ValueError as e:
        db.rollback()
        return error_response(400, str(e))
    except Exception as e:
        db.rollback()
        return error_response(400, str(e))


@router.delete("/qc-work-orders/{work_order_id}")
async def delete_qc_work_order_api(
    work_order_id: str,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        wo_svc.delete_qc_work_order(db, work_order_id, tenant_no, user.get("user_id"))
        return success_response(None, message="删除成功")
    except ValueError as e:
        return error_response(400, str(e))


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

    reception_source: str = Field(..., alias="receptionSource")
    protocol_sample_id: str = Field(..., alias="protocolSampleId")
    is_special: bool = Field(..., alias="isSpecial")
    special_remark: Optional[str] = Field(None, alias="specialRemark")


@router.put("/inbound-samples/special-mark")
async def update_inbound_sample_special_mark(
    body: InboundSampleSpecialMarkBody,
    db: Session = Depends(get_db),
    user: dict = Depends(
        require_any_menu_code("biz:qcWorkOrder:list", "biz:myQcTask:list")
    ),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        source = (body.reception_source or "").strip()
        if source not in ("cell_storage", "research_donation"):
            return error_response(400, "仅支持细胞存储或科研捐赠样本")
        data = inbound_sample_special_svc.update_inbound_sample_special_mark(
            db,
            tenant_no=tenant_no,
            reception_source=source,
            protocol_sample_id=body.protocol_sample_id,
            is_special=body.is_special,
            special_remark=body.special_remark,
            user_id=user.get("user_id") or "",
        )
        db.commit()
        return success_response(data, message="保存成功")
    except ValueError as e:
        db.rollback()
        return error_response(400, str(e))
    except Exception as e:
        db.rollback()
        return error_response(400, str(e))


@router.post("/qc-work-orders/{work_order_id}/configure")
async def configure_qc_work_order(
    work_order_id: str,
    body: WorkOrderConfigureBody,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcWorkOrder:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        obj = wo_svc.configure_work_order(
            db,
            work_order_id,
            has_lab=body.has_lab,
            has_third_party=body.has_third_party,
            lab_item_ids=body.lab_item_ids,
            third_party_item_ids=body.third_party_item_ids,
            lab_item_assignees=body.lab_item_assignees,
            third_party_item_assignees=body.third_party_item_assignees,
            batches=[b.model_dump(by_alias=True) for b in body.batches] if body.batches is not None else None,
            tenant_no=tenant_no,
            user_id=_get_current_user_id(user),
            create_dept_id=user.get("dept_id", ""),
        )
        return success_response(wo_svc._wo_to_dict(obj), message="配置成功")
    except PermissionError as e:
        return error_response(403, str(e))
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


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

    work_order_ids: List[str] = Field(default_factory=list, alias="workOrderIds")


@router.post("/qc-work-orders/inspection-batches/batch")
async def batch_list_qc_work_order_inspection_batches(
    body: WorkOrderInspectionBatchesBatchBody,
    db: Session = Depends(get_db),
    user: dict = Depends(require_any_menu_code(*QC_TASK_READONLY_MENU_CODES)),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        from app.crud import qc_inspection_batch as batch_svc

        data = batch_svc.list_inspection_batches_by_work_order_ids(
            db, body.work_order_ids, tenant_no
        )
        return success_response(data)
    except PermissionError as e:
        return error_response(403, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.get("/qc-work-orders/{work_order_id}/inspection-batches")
async def list_qc_work_order_inspection_batches(
    work_order_id: str,
    db: Session = Depends(get_db),
    user: dict = Depends(require_any_menu_code(*QC_TASK_READONLY_MENU_CODES)),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        from app.crud import qc_inspection_batch as batch_svc

        wo = wo_svc.get_work_order(db, work_order_id, tenant_no=tenant_no)
        if not wo:
            return error_response(404, "工单不存在")
        return success_response(batch_svc.list_inspection_batches(db, work_order_id, tenant_no))
    except PermissionError as e:
        return error_response(403, str(e))
    except Exception as e:
        return error_response(400, str(e))


# ---------- 质检任务 ----------


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

    third_party_attachments: str = Field("", alias="thirdPartyAttachments")


@router.post("/qc-tasks")
async def create_qc_task(
    body: QcTaskCreateBody,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcTask:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        task = task_svc.create_qc_task_manual(
            db,
            tenant_no=tenant_no,
            user_id=user.get("user_id"),
            create_dept_id=user.get("dept_id", ""),
            task_type=body.task_type,
            item_code=body.item_code,
            item_name=body.item_name,
            company_id=body.company_id,
            company_name=body.company_name,
            fee_amount=body.fee_amount,
            sample_code=body.sample_code or "",
            work_order_id=body.work_order_id or "",
            remark=body.remark or "",
        )
        db.commit()
        return success_response(task_svc._task_to_dict(task), message="创建成功")
    except PermissionError as e:
        return error_response(403, str(e))
    except Exception as e:
        db.rollback()
        return error_response(400, str(e))


@router.get("/qc-tasks/mine")
async def list_my_qc_tasks(
    page: int = Query(1, ge=1),
    pageSize: int = Query(10, ge=1, le=100),
    keyword: Optional[str] = None,
    taskType: Optional[str] = None,
    taskStatus: Optional[str] = None,
    qcBizType: Optional[str] = None,
    receptionSource: Optional[str] = Query(None, alias="receptionSource"),
    bizType: Optional[str] = Query(None, alias="bizType"),
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:myQcTask:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        items, total = task_svc.list_mine_tasks(
            db,
            assignee_user_id=_get_current_user_id(user),
            page=page,
            page_size=pageSize,
            keyword=keyword,
            task_type=taskType,
            task_status=taskStatus,
            qc_biz_type=qcBizType,
            reception_source=receptionSource,
            biz_type=bizType,
            tenant_no=tenant_no,
        )
        return success_response(_page_payload(items, total, page, pageSize))
    except PermissionError as e:
        return error_response(403, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.get("/qc-tasks")
async def list_qc_tasks(
    page: int = Query(1, ge=1),
    pageSize: int = Query(10, ge=1, le=100),
    keyword: Optional[str] = None,
    taskType: Optional[str] = None,
    taskStatus: Optional[str] = None,
    workOrderId: Optional[str] = None,
    qcBizType: Optional[str] = None,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcTask:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        items, total = task_svc.list_tasks(
            db,
            page=page,
            page_size=pageSize,
            keyword=keyword,
            task_type=taskType,
            task_status=taskStatus,
            work_order_id=workOrderId,
            qc_biz_type=qcBizType,
            tenant_no=tenant_no,
            user_info=user,
        )
        return success_response(_page_payload(items, total, page, pageSize))
    except PermissionError as e:
        return error_response(403, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.get("/qc-tasks/{task_id}")
async def get_qc_task_detail(
    task_id: str,
    db: Session = Depends(get_db),
    user: dict = Depends(require_any_menu_code(*QC_TASK_READONLY_MENU_CODES)),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        data = task_svc.get_task_detail(db, task_id, tenant_no)
        return success_response(data)
    except PermissionError as e:
        return error_response(403, str(e))
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.post("/qc-tasks/{task_id}/start")
async def start_qc_task(
    task_id: str,
    operateScope: Optional[str] = Query(None, alias="operateScope"),
    db: Session = Depends(get_db),
    user: dict = Depends(require_any_menu_code("biz:qcTask:list", "biz:myQcTask:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        obj = task_svc.start_task(db, task_id, tenant_no=tenant_no, user_id=_get_current_user_id(user))
        return success_response(task_svc._task_to_dict(obj), message="已开始")
    except PermissionError as e:
        return error_response(403, str(e))
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.post("/qc-tasks/{task_id}/complete")
async def complete_qc_task(
    task_id: str,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcTask:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        obj = task_svc.complete_task(
            db, task_id, tenant_no=tenant_no, user_id=_get_current_user_id(user)
        )
        return success_response(task_svc._task_to_dict(obj), message="已完成")
    except PermissionError as e:
        return error_response(403, str(e))
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.get("/qc-tasks/{task_id}/results")
async def get_task_results(
    task_id: str,
    db: Session = Depends(get_db),
    user: dict = Depends(require_any_menu_code(*QC_TASK_READONLY_MENU_CODES)),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        return success_response(result_svc.list_results_by_task(db, task_id, tenant_no, user_info=user))
    except PermissionError as e:
        return error_response(403, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.get("/qc-material-requisition-options")
async def list_qc_material_requisition_options(
    keyword: Optional[str] = None,
    limit: int = Query(50, ge=1, le=100),
    db: Session = Depends(get_db),
    user: dict = Depends(require_any_menu_code("biz:qcTask:list", "biz:myQcTask:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        items = mu_svc.list_requisition_options(
            db,
            tenant_no,
            keyword=keyword,
            limit=limit,
            user_info=user,
        )
        return success_response(items)
    except PermissionError as e:
        return error_response(403, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.get("/qc-tasks/{task_id}/material-usages")
async def get_task_material_usages(
    task_id: str,
    db: Session = Depends(get_db),
    user: dict = Depends(require_any_menu_code(*QC_TASK_READONLY_MENU_CODES)),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        t = task_svc.get_task(db, task_id, tenant_no=tenant_no)
        if not t:
            return error_response(404, "任务不存在")
        return success_response(
            mu_svc.list_usages_by_task(db, task_id, tenant_no, user_info=user)
        )
    except PermissionError as e:
        return error_response(403, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.post("/qc-tasks/{task_id}/complete-with-result")
async def complete_task_with_result(
    task_id: str,
    body: TaskCompleteWithResultBody,
    operateScope: Optional[str] = Query(None, alias="operateScope"),
    db: Session = Depends(get_db),
    user: dict = Depends(require_any_menu_code("biz:qcTask:list", "biz:myQcTask:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        user_id = _get_current_user_id(user)
        t = task_svc.get_task(db, task_id, tenant_no=tenant_no)
        if not t:
            return error_response(404, "任务不存在")
        was_done = (t.task_status or "").strip() == "ywc"
        if body.results:
            result_svc.save_results_for_task(
                db, task_id, body.results, tenant_no, user_id, commit=False,
            )
        if body.third_party_attachments is not None:
            task_svc.update_task_attachments(
                db, task_id, attachments=body.third_party_attachments,
                tenant_no=tenant_no, user_id=user_id, commit=False,
            )
        obj = task_svc.apply_task_result(
            db,
            task_id,
            tenant_no=tenant_no,
            user_id=user_id,
            conclusion=body.conclusion,
            remark=body.remark,
            material_usages=body.material_usages,
            task_status=body.task_status,
            commit=False,
        )
        db.commit()
        db.refresh(obj)
        if (obj.task_status or "").strip() == "ywc":
            wo_svc.try_complete_work_order(db, obj.work_order_id, tenant_no)
        elif was_done:
            wo_svc.try_reopen_work_order(db, obj.work_order_id, tenant_no)
        return success_response(
            task_svc._task_to_dict(obj, work_order_no="", db=db, tenant_no=tenant_no),
            message="已保存",
        )
    except HTTPException as e:
        db.rollback()
        detail = e.detail
        msg = detail if isinstance(detail, str) else str(detail)
        return error_response(e.status_code, msg)
    except PermissionError as e:
        db.rollback()
        return error_response(403, str(e))
    except ValueError as e:
        db.rollback()
        return error_response(400, str(e))
    except Exception as e:
        db.rollback()
        return error_response(400, str(e))


@router.put("/qc-tasks/{task_id}/attachments")
async def update_qc_task_attachments(
    task_id: str,
    body: TaskAttachmentsBody,
    operateScope: Optional[str] = Query(None, alias="operateScope"),
    db: Session = Depends(get_db),
    user: dict = Depends(require_any_menu_code("biz:qcTask:list", "biz:myQcTask:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        obj = task_svc.update_task_attachments(
            db,
            task_id,
            attachments=body.third_party_attachments,
            tenant_no=tenant_no,
            user_id=_get_current_user_id(user),
        )
        return success_response(task_svc._task_to_dict(obj), message="已保存")
    except PermissionError as e:
        return error_response(403, str(e))
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.delete("/qc-tasks/{task_id}")
async def delete_qc_task_api(
    task_id: str,
    user: dict = Depends(require_admin_or_super_admin),
    db: Session = Depends(get_db),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        task_svc.delete_qc_task(db, task_id, tenant_no, user.get("user_id"))
        return success_response(None, message="删除成功")
    except ValueError as e:
        return error_response(400, str(e))


# ---------- 质检物料库 ----------


def _maybe_strip_qc_material_amount_fields(
    db: Session, user: dict, rows: Iterable[Dict[str, Any]]
) -> None:
    if user_has_menu_perm(db, user, QC_MATERIAL_VIEW_AMOUNT_PERM):
        return
    strip_row_fields(rows, *QC_MATERIAL_AMOUNT_FIELD_NAMES)


def _user_can_view_qc_material_amount(db: Session, user: dict) -> bool:
    return user_has_menu_perm(db, user, QC_MATERIAL_VIEW_AMOUNT_PERM)


def _strip_amount_from_write_data(db: Session, user: dict, data: Dict[str, Any]) -> None:
    if _user_can_view_qc_material_amount(db, user):
        return
    for key in ("unit_price", "unitPrice", "amount"):
        data.pop(key, None)


def _resolve_stock_in_amounts(
    db: Session, user: dict, unit_price: Any, amount: Any
) -> tuple:
    if _user_can_view_qc_material_amount(db, user):
        return unit_price, amount
    return 0, 0


def _maybe_strip_qc_third_party_fee_fields(
    db: Session, user: dict, data: Dict[str, Any]
) -> None:
    if user_has_menu_perm(db, user, QC_THIRD_PARTY_VIEW_AMOUNT_PERM):
        return
    strip_row_fields([data], "thirdPartyFeeTotal")
    third_items = data.get("thirdPartyItems")
    if isinstance(third_items, list):
        strip_row_fields(third_items, "feeAmount")
    tasks = data.get("tasks")
    if isinstance(tasks, list):
        for task in tasks:
            if isinstance(task, dict) and (task.get("taskType") or "").strip() == "dsfjc":
                strip_row_fields([task], "feeAmount")
    work_order = data.get("workOrder")
    if isinstance(work_order, dict):
        strip_row_fields([work_order], "thirdPartyFeeTotal")
        wo_tasks = work_order.get("tasks")
        if isinstance(wo_tasks, list):
            for task in wo_tasks:
                if isinstance(task, dict) and (task.get("taskType") or "").strip() == "dsfjc":
                    strip_row_fields([task], "feeAmount")


def _maybe_strip_qc_material_stock_check_detail(db: Session, user: dict, data: Dict[str, Any]) -> None:
    if user_has_menu_perm(db, user, QC_MATERIAL_VIEW_AMOUNT_PERM):
        return
    for key in ("batchLines", "unusedLines"):
        lines = data.get(key)
        if isinstance(lines, list):
            strip_row_fields(lines, *QC_MATERIAL_AMOUNT_FIELD_NAMES)


class QcMaterialBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)
    material_code: str = Field(..., alias="materialCode")
    material_name: str = Field(..., alias="materialName")
    spec_model: Optional[str] = Field(None, alias="specModel")
    unit: Optional[str] = None
    warning_qty: Optional[float] = Field(0, alias="warningQty")
    status: str = "1"
    remark: Optional[str] = None


class QcMaterialUpdateBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)
    material_code: Optional[str] = Field(None, alias="materialCode")
    material_name: Optional[str] = Field(None, alias="materialName")
    spec_model: Optional[str] = Field(None, alias="specModel")
    unit: Optional[str] = None
    warning_qty: Optional[float] = Field(None, alias="warningQty")
    status: Optional[str] = None
    remark: Optional[str] = None


class StockInBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)
    stock_in_no: str = Field(..., alias="stockInNo")
    stock_in_date: str = Field(..., alias="stockInDate")
    expire_date: str = Field(..., alias="expireDate")
    catalog_no: str = Field(..., alias="catalogNo")
    batch_no: str = Field(..., alias="batchNo")
    manufacturer: str
    unit_price: float = Field(..., alias="unitPrice")
    amount: float
    qty: float = Field(..., gt=0)
    remark: Optional[str] = None
    stock_in_time: Optional[str] = Field(None, alias="stockInTime")


class BatchStockInItem(BaseModel):
    model_config = ConfigDict(populate_by_name=True)
    material_id: str = Field(..., alias="materialId")
    stock_in_no: str = Field(..., alias="stockInNo")
    stock_in_date: str = Field(..., alias="stockInDate")
    expire_date: str = Field(..., alias="expireDate")
    catalog_no: str = Field(..., alias="catalogNo")
    batch_no: str = Field(..., alias="batchNo")
    manufacturer: str
    unit_price: float = Field(..., alias="unitPrice")
    amount: float
    qty: float = Field(..., gt=0)
    remark: Optional[str] = None


class BatchStockInBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)
    items: List[BatchStockInItem] = Field(..., min_length=1)
    remark: Optional[str] = None
    stock_in_time: Optional[str] = Field(None, alias="stockInTime")


class BatchStockOutItem(BaseModel):
    model_config = ConfigDict(populate_by_name=True)
    batch_id: str = Field(..., alias="batchId")
    qty: float = Field(..., gt=0)
    remark: Optional[str] = None


class BatchStockOutBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)
    items: List[BatchStockOutItem] = Field(..., min_length=1)
    receiver: Optional[str] = None
    purpose: Optional[str] = None
    remark: Optional[str] = None
    stock_out_time: Optional[str] = Field(None, alias="stockOutTime")


class BatchDiscardItem(BaseModel):
    model_config = ConfigDict(populate_by_name=True)
    batch_id: str = Field(..., alias="batchId")
    qty: float = Field(..., gt=0)
    usage_unit: Optional[str] = Field(None, alias="usageUnit")
    remark: Optional[str] = None


class BatchDiscardBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)
    items: List[BatchDiscardItem] = Field(..., min_length=1)
    discard_reason: str = Field(..., alias="discardReason")
    remark: Optional[str] = None
    discard_time: Optional[str] = Field(None, alias="discardTime")


class QcMaterialBatchUpdateBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)
    stock_in_no: Optional[str] = Field(None, alias="stockInNo")
    stock_in_date: Optional[str] = Field(None, alias="stockInDate")
    expire_date: Optional[str] = Field(None, alias="expireDate")
    catalog_no: Optional[str] = Field(None, alias="catalogNo")
    batch_no: Optional[str] = Field(None, alias="batchNo")
    manufacturer: Optional[str] = None
    unit_price: Optional[float] = Field(None, alias="unitPrice")
    amount: Optional[float] = None
    in_qty: Optional[float] = Field(None, alias="inQty")
    remaining_qty: Optional[float] = Field(None, alias="remainingQty")
    remark: Optional[str] = None
    qc_attachment_urls: Optional[str] = Field(None, alias="qcAttachmentUrls")
    material_code: Optional[str] = Field(None, alias="materialCode")
    material_name: Optional[str] = Field(None, alias="materialName")
    spec_model: Optional[str] = Field(None, alias="specModel")
    unit: Optional[str] = None
    warning_qty: Optional[float] = Field(None, alias="warningQty")
    status: Optional[str] = None


@router.get("/qc-material-batches")
async def list_qc_material_batches(
    page: int = Query(1, ge=1),
    pageSize: int = Query(10, ge=1, le=100),
    keyword: Optional[str] = None,
    materialId: Optional[str] = None,
    status: Optional[str] = None,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcMaterial:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        items, total = batch_svc.list_batches(
            db,
            page=page,
            page_size=pageSize,
            keyword=keyword,
            material_id=materialId,
            status=status,
            tenant_no=tenant_no,
            user_info=user,
        )
        _maybe_strip_qc_material_amount_fields(db, user, items)
        return success_response(_page_payload(items, total, page, pageSize))
    except PermissionError as e:
        return error_response(403, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.get("/qc-material-batches/options")
async def qc_material_batch_options(
    keyword: Optional[str] = None,
    materialId: Optional[str] = None,
    onlyAvailable: bool = Query(True, alias="onlyAvailable"),
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcMaterial:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        options = batch_svc.batch_options(
            db,
            tenant_no,
            keyword=keyword,
            material_id=materialId,
            only_available=onlyAvailable,
        )
        _maybe_strip_qc_material_amount_fields(db, user, options)
        return success_response(options)
    except Exception as e:
        return error_response(400, str(e))


@router.get("/qc-material-batches/{batch_id}")
async def get_qc_material_batch(
    batch_id: str,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcMaterial:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        payload = batch_svc.get_batch_detail(db, batch_id, tenant_no=tenant_no)
        _maybe_strip_qc_material_amount_fields(db, user, [payload])
        return success_response(payload)
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.put("/qc-material-batches/{batch_id}")
async def update_qc_material_batch(
    batch_id: str,
    body: QcMaterialBatchUpdateBody,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcMaterial:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        user_id = _get_current_user_id(user)
        data = body.model_dump(exclude_none=True)
        _strip_amount_from_write_data(db, user, data)
        obj = batch_svc.update_batch(
            db,
            batch_id,
            tenant_no=tenant_no,
            user_id=user_id,
            **data,
        )
        material = mat_svc.get_material(db, obj.material_id, tenant_no=tenant_no)
        payload = batch_svc._batch_row_to_dict(obj, material)
        _maybe_strip_qc_material_amount_fields(db, user, [payload])
        return success_response(
            payload,
            message="更新成功",
        )
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.delete("/qc-material-batches/{batch_id}")
async def delete_qc_material_batch(
    batch_id: str,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcMaterial:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        user_id = _get_current_user_id(user)
        batch_svc.delete_batch(db, batch_id, tenant_no=tenant_no, user_id=user_id)
        return success_response(None, message="删除成功")
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.get("/qc-materials")
async def list_qc_materials(
    page: int = Query(1, ge=1),
    pageSize: int = Query(10, ge=1, le=100),
    keyword: Optional[str] = None,
    status: Optional[str] = None,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcMaterial:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        items, total = mat_svc.list_materials(
            db, page=page, page_size=pageSize, keyword=keyword, status=status, tenant_no=tenant_no,
            user_info=user,
        )
        return success_response(_page_payload(items, total, page, pageSize))
    except PermissionError as e:
        return error_response(403, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.get("/qc-materials/options")
async def qc_material_options(
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcMaterial:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        return success_response(mat_svc.options_list(db, tenant_no=tenant_no))
    except Exception as e:
        return error_response(400, str(e))


@router.post("/qc-materials")
async def create_qc_material(
    body: QcMaterialBody,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcMaterial:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        user_id = _get_current_user_id(user)
        obj = mat_svc.create_material(
            db,
            material_code=body.material_code,
            material_name=body.material_name,
            spec_model=body.spec_model,
            unit=body.unit,
            warning_qty=Decimal(str(body.warning_qty))
            if body.warning_qty is not None
            else None,
            status=mat_svc._norm_status(body.status),
            remark=body.remark,
            tenant_no=tenant_no,
            user_id=user_id,
        )
        return success_response(mat_svc._row_to_dict(obj), message="创建成功")
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.put("/qc-materials/{material_id}")
async def update_qc_material(
    material_id: str,
    body: QcMaterialUpdateBody,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcMaterial:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        user_id = _get_current_user_id(user)
        data = body.model_dump(exclude_none=True)
        if "warning_qty" in data:
            data["warning_qty"] = Decimal(str(data["warning_qty"]))
        if "status" in data:
            data["status"] = mat_svc._norm_status(data["status"])
        obj = mat_svc.update_material(
            db,
            material_id,
            tenant_no=tenant_no,
            user_id=user_id,
            **data,
        )
        return success_response(mat_svc._row_to_dict(obj), message="更新成功")
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.delete("/qc-materials/{material_id}")
async def delete_qc_material(
    material_id: str,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcMaterial:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        user_id = _get_current_user_id(user)
        mat_svc.soft_delete_material(db, material_id, tenant_no=tenant_no)
        return success_response(None, message="删除成功")
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.post("/qc-materials/batch-stock-in")
async def batch_stock_in_qc_material(
    body: BatchStockInBody,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcMaterial:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        user_id = _get_current_user_id(user)
        operate_time = datetime.now()
        if body.stock_in_time:
            rt = parse_datetime(body.stock_in_time)
            if not rt:
                return error_response(400, "入库时间格式无效")
            operate_time = rt
        items = []
        for x in body.items:
            unit_price, amount = _resolve_stock_in_amounts(
                db, user, x.unit_price, x.amount
            )
            items.append(
                {
                "material_id": x.material_id,
                "materialId": x.material_id,
                "stock_in_no": x.stock_in_no,
                "stockInNo": x.stock_in_no,
                "stock_in_date": x.stock_in_date,
                "stockInDate": x.stock_in_date,
                "expire_date": x.expire_date,
                "expireDate": x.expire_date,
                "catalog_no": x.catalog_no,
                "catalogNo": x.catalog_no,
                "batch_no": x.batch_no,
                "batchNo": x.batch_no,
                "manufacturer": x.manufacturer,
                "unit_price": unit_price,
                "unitPrice": unit_price,
                "amount": amount,
                "qty": x.qty,
                "remark": x.remark,
            }
            )
        count = batch_svc.batch_stock_in(
            db,
            items=items,
            remark=body.remark,
            tenant_no=tenant_no,
            user_id=user_id,
            operate_time=operate_time,
        )
        return success_response({"count": count}, message=f"批量入库成功，共 {count} 项")
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.post("/qc-materials/batch-stock-out")
async def batch_stock_out_qc_material(
    body: BatchStockOutBody,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcMaterial:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        user_id = _get_current_user_id(user)
        operate_time = datetime.now()
        if body.stock_out_time:
            rt = parse_datetime(body.stock_out_time)
            if not rt:
                return error_response(400, "出库时间格式无效")
            operate_time = rt
        items = [
            {"batch_id": x.batch_id, "batchId": x.batch_id, "qty": x.qty, "remark": x.remark}
            for x in body.items
        ]
        count = batch_svc.batch_stock_out(
            db,
            items=items,
            receiver=body.receiver,
            purpose=body.purpose,
            remark=body.remark,
            tenant_no=tenant_no,
            user_id=user_id,
            operate_time=operate_time,
        )
        return success_response({"count": count}, message=f"批量出库成功，共 {count} 项")
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.post("/qc-materials/batch-discard")
async def batch_discard_qc_material(
    body: BatchDiscardBody,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcMaterial:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        user_id = _get_current_user_id(user)
        operate_time = datetime.now()
        if body.discard_time:
            rt = parse_datetime(body.discard_time)
            if not rt:
                return error_response(400, "废弃时间格式无效")
            operate_time = rt
        items = [
            {
                "batch_id": x.batch_id,
                "batchId": x.batch_id,
                "qty": x.qty,
                "usageUnit": x.usage_unit,
                "usage_unit": x.usage_unit,
                "remark": x.remark,
            }
            for x in body.items
        ]
        count = batch_svc.batch_discard(
            db,
            items=items,
            discard_reason=body.discard_reason,
            remark=body.remark,
            tenant_no=tenant_no,
            user_id=user_id,
            operate_time=operate_time,
        )
        return success_response({"count": count}, message=f"批量废弃成功，共 {count} 项")
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.post("/qc-materials/{material_id}/stock-in")
async def stock_in_qc_material(
    material_id: str,
    body: StockInBody,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcMaterial:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        user_id = _get_current_user_id(user)
        operate_time = datetime.now()
        if body.stock_in_time:
            rt = parse_datetime(body.stock_in_time)
            if not rt:
                return error_response(400, "入库时间格式无效")
            operate_time = rt
        from decimal import Decimal

        unit_price, amount = _resolve_stock_in_amounts(
            db, user, body.unit_price, body.amount
        )
        obj = batch_svc.stock_in_one(
            db,
            material_id,
            stock_in_no=body.stock_in_no,
            stock_in_date=body.stock_in_date,
            expire_date=body.expire_date,
            catalog_no=body.catalog_no,
            batch_no=body.batch_no,
            manufacturer=body.manufacturer,
            unit_price=unit_price,
            amount=amount,
            qty=Decimal(str(body.qty)),
            remark=body.remark,
            tenant_no=tenant_no,
            user_id=user_id,
            operate_time=operate_time,
        )
        return success_response(batch_svc._batch_row_to_dict(obj), message="入库成功")
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.post("/qc-material-batches/batch-stock-in")
async def batch_stock_in_qc_material_batches(
    body: BatchStockInBody,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcMaterial:list")),
):
    """批量入库（与 /qc-materials/batch-stock-in 等价）。"""
    return await batch_stock_in_qc_material(body, db, user)


@router.post("/qc-material-batches/batch-stock-out")
async def batch_stock_out_qc_material_batches(
    body: BatchStockOutBody,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcMaterial:list")),
):
    """批量出库（与 /qc-materials/batch-stock-out 等价）。"""
    return await batch_stock_out_qc_material(body, db, user)


@router.post("/qc-material-batches/batch-discard")
async def batch_discard_qc_material_batches(
    body: BatchDiscardBody,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcMaterial:list")),
):
    """批量废弃（与 /qc-materials/batch-discard 等价）。"""
    return await batch_discard_qc_material(body, db, user)


# ---------- 物料变动记录 ----------


@router.get("/qc-material-usages")
async def list_qc_material_usages(
    page: int = Query(1, ge=1),
    pageSize: int = Query(10, ge=1, le=100),
    materialId: Optional[str] = None,
    changeType: Optional[str] = None,
    startTime: Optional[str] = None,
    endTime: Optional[str] = None,
    keyword: Optional[str] = None,
    stockInNo: Optional[str] = None,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcMaterialUsage:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        items, total = mu_svc.list_usages(
            db, tenant_no, page=page, page_size=pageSize,
            material_id=materialId, change_type=changeType,
            start_time=startTime, end_time=endTime,
            keyword=keyword, stock_in_no=stockInNo,
            user_info=user,
        )
        _maybe_strip_qc_material_amount_fields(db, user, items)
        return success_response(_page_payload(items, total, page, pageSize))
    except PermissionError as e:
        return error_response(403, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.get("/my-qc-material-usages")
async def list_my_qc_material_usages(
    page: int = Query(1, ge=1),
    pageSize: int = Query(10, ge=1, le=100),
    materialId: Optional[str] = None,
    changeType: Optional[str] = None,
    startTime: Optional[str] = None,
    endTime: Optional[str] = None,
    keyword: Optional[str] = None,
    stockInNo: Optional[str] = None,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:myQcMaterialUsage:list")),
):
    """当前登录人的物料领用记录（手动出库领用人 / 任务使用填报人）。"""
    try:
        tenant_no = _get_tenant_no(db, user)
        items, total = mu_svc.list_my_usages(
            db,
            tenant_no,
            user_id=_get_current_user_id(user),
            nick_name=(user.get("real_name") or "").strip(),
            page=page,
            page_size=pageSize,
            material_id=materialId,
            change_type=changeType,
            start_time=startTime,
            end_time=endTime,
            keyword=keyword,
            stock_in_no=stockInNo,
        )
        if not user_has_menu_perm(db, user, MY_QC_MATERIAL_USAGE_VIEW_AMOUNT_PERM):
            strip_row_fields(items, "unitPrice", "amount")
        return success_response(_page_payload(items, total, page, pageSize))
    except PermissionError as e:
        return error_response(403, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.get("/qc-material-usages/{usage_id}/linked-task-usages")
async def list_qc_material_linked_task_usages(
    usage_id: str,
    db: Session = Depends(get_db),
    user: dict = Depends(
        require_any_menu_code("biz:qcMaterialUsage:list", "biz:myQcMaterialUsage:list")
    ),
):
    """领用记录下关联的质检任务物料消耗明细。"""
    try:
        tenant_no = _get_tenant_no(db, user)
        items = mu_svc.list_linked_task_usages(
            db, usage_id, tenant_no, user_info=user
        )
        if not (
            user_has_menu_perm(db, user, QC_MATERIAL_VIEW_AMOUNT_PERM)
            or user_has_menu_perm(db, user, MY_QC_MATERIAL_USAGE_VIEW_AMOUNT_PERM)
        ):
            strip_row_fields(items, *QC_MATERIAL_AMOUNT_FIELD_NAMES)
        return success_response(items)
    except HTTPException as e:
        detail = e.detail
        msg = detail if isinstance(detail, str) else str(detail)
        return error_response(e.status_code, msg)
    except PermissionError as e:
        return error_response(403, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.get("/qc-material-stock-check-requisitions")
async def list_qc_material_stock_check_requisitions(
    page: int = Query(1, ge=1),
    pageSize: int = Query(50, ge=1, le=200),
    keyword: Optional[str] = None,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcMaterial:list")),
):
    """盘点登记：待处理领用记录（未标记已使用完）。"""
    try:
        tenant_no = _get_tenant_no(db, user)
        items, total = mu_svc.list_stock_check_requisitions(
            db,
            tenant_no,
            page=page,
            page_size=pageSize,
            keyword=keyword,
            user_info=user,
        )
        _maybe_strip_qc_material_amount_fields(db, user, items)
        return success_response(_page_payload(items, total, page, pageSize))
    except PermissionError as e:
        return error_response(403, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.post("/qc-material-usages/{usage_id}/mark-fully-used")
async def mark_qc_material_usage_fully_used(
    usage_id: str,
    db: Session = Depends(get_db),
    user: dict = Depends(
        require_any_menu_code("biz:qcMaterial:list", "biz:qcMaterialUsage:list")
    ),
):
    """标记领用记录已使用完（盘点登记 / 变动记录）。"""
    try:
        tenant_no = _get_tenant_no(db, user)
        user_id = _get_current_user_id(user)
        mu_svc.mark_requisition_fully_used(
            db,
            usage_id,
            tenant_no=tenant_no,
            user_id=user_id,
            user_info=user,
        )
        return success_response(None, message="已标记为使用完")
    except PermissionError as e:
        return error_response(403, str(e))
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


# ---------- 库存盘点 ----------


class StockCheckCreateBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)
    title: str
    check_time: Optional[str] = Field(None, alias="checkTime")
    remark: Optional[str] = None


class StockCheckUnusedLineItem(BaseModel):
    model_config = ConfigDict(populate_by_name=True)
    usage_id: Optional[str] = Field(None, alias="usageId")
    batch_id: Optional[str] = Field(None, alias="batchId")
    material_code: Optional[str] = Field(None, alias="materialCode")
    material_name: str = Field(..., alias="materialName")
    spec_model: Optional[str] = Field(None, alias="specModel")
    unit: Optional[str] = None
    stock_in_no: Optional[str] = Field(None, alias="stockInNo")
    stock_in_date: Optional[str] = Field(None, alias="stockInDate")
    expire_date: Optional[str] = Field(None, alias="expireDate")
    catalog_no: Optional[str] = Field(None, alias="catalogNo")
    batch_no: Optional[str] = Field(None, alias="batchNo")
    manufacturer: Optional[str] = None
    unit_price: Optional[float] = Field(None, alias="unitPrice")
    holder: Optional[str] = None
    unused_qty: float = Field(..., alias="unusedQty", gt=0)
    remark: Optional[str] = None


class StockCheckUnusedLinesBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)
    items: List[StockCheckUnusedLineItem] = Field(default_factory=list)


@router.get("/qc-material-stock-checks")
async def list_qc_material_stock_checks(
    page: int = Query(1, ge=1),
    pageSize: int = Query(10, ge=1, le=100),
    keyword: Optional[str] = None,
    status: Optional[str] = None,
    startTime: Optional[str] = None,
    endTime: Optional[str] = None,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcMaterial:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        items, total = stock_check_svc.list_checks(
            db,
            tenant_no,
            page=page,
            page_size=pageSize,
            keyword=keyword,
            status=status,
            start_time=startTime,
            end_time=endTime,
            user_info=user,
        )
        return success_response(_page_payload(items, total, page, pageSize))
    except PermissionError as e:
        return error_response(403, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.post("/qc-material-stock-checks")
async def create_qc_material_stock_check(
    body: StockCheckCreateBody,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcMaterial:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        user_id = _get_current_user_id(user)
        dept_id = user.get("deptId") or user.get("dept_id") or ""
        res = stock_check_svc.create_check(
            db,
            title=body.title,
            tenant_no=tenant_no,
            user_id=user_id,
            dept_id=dept_id,
            check_time=body.check_time,
            remark=body.remark,
        )
        return success_response(res, message="盘点单创建成功")
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.get("/qc-material-stock-checks/{check_id}")
async def get_qc_material_stock_check(
    check_id: str,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcMaterial:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        data = stock_check_svc.get_check_detail(db, check_id, tenant_no)
        _maybe_strip_qc_material_stock_check_detail(db, user, data)
        return success_response(data)
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.put("/qc-material-stock-checks/{check_id}/unused-lines")
async def save_qc_material_stock_check_unused_lines(
    check_id: str,
    body: StockCheckUnusedLinesBody,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcMaterial:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        user_id = _get_current_user_id(user)
        dept_id = user.get("deptId") or user.get("dept_id") or ""
        count = stock_check_svc.save_unused_lines(
            db,
            check_id,
            items=[x.model_dump(by_alias=False) for x in body.items],
            tenant_no=tenant_no,
            user_id=user_id,
            dept_id=dept_id,
        )
        return success_response({"count": count}, message="登记保存成功")
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.post("/qc-material-stock-checks/{check_id}/complete")
async def complete_qc_material_stock_check(
    check_id: str,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcMaterial:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        user_id = _get_current_user_id(user)
        stock_check_svc.complete_check(db, check_id, tenant_no=tenant_no, user_id=user_id)
        return success_response(None, message="盘点已完成")
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.post("/qc-material-stock-checks/{check_id}/cancel")
async def cancel_qc_material_stock_check(
    check_id: str,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code("biz:qcMaterial:list")),
):
    try:
        tenant_no = _get_tenant_no(db, user)
        user_id = _get_current_user_id(user)
        stock_check_svc.cancel_check(db, check_id, tenant_no=tenant_no, user_id=user_id)
        return success_response(None, message="盘点已作废")
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


# ---------- 质检物料金额查看授权 ----------


class QcMaterialAmountAuthGrantBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)
    user_id: str = Field(..., alias="userId")


class QcMaterialAmountAuthBatchBody(BaseModel):
    model_config = ConfigDict(populate_by_name=True)
    user_ids: List[str] = Field(..., alias="userIds", min_length=1)


@router.get("/qc-material-amount-auth/users")
async def list_qc_material_amount_auth_users(
    page: int = Query(1, ge=1),
    pageSize: int = Query(10, ge=1, le=100),
    keyword: Optional[str] = None,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code(QC_MATERIAL_AMOUNT_AUTH_LIST_PERM)),
):
    """已授权「质检物料金额查看」角色的用户列表。"""
    try:
        tenant_no = _get_tenant_no(db, user)
        items, total = amount_auth_svc.list_authorized_users(
            db,
            tenant_no=tenant_no,
            page=page,
            page_size=pageSize,
            keyword=keyword,
        )
        return success_response(_page_payload(items, total, page, pageSize))
    except Exception as e:
        return error_response(400, str(e))


@router.post("/qc-material-amount-auth/users")
async def grant_qc_material_amount_auth(
    body: QcMaterialAmountAuthGrantBody,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code(QC_MATERIAL_AMOUNT_AUTH_LIST_PERM)),
):
    """为用户绑定「质检物料金额查看」专用角色。"""
    try:
        tenant_no = _get_tenant_no(db, user)
        operator_id = _get_current_user_id(user)
        created = amount_auth_svc.grant_amount_view_role(
            db,
            tenant_no=tenant_no,
            user_id=body.user_id.strip(),
            operator_id=operator_id,
        )
        msg = "授权成功" if created else "该用户已授权"
        return success_response({"created": created}, message=msg)
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.delete("/qc-material-amount-auth/users/{user_id}")
async def revoke_qc_material_amount_auth(
    user_id: str,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code(QC_MATERIAL_AMOUNT_AUTH_LIST_PERM)),
):
    """解除用户的「质检物料金额查看」专用角色。"""
    try:
        tenant_no = _get_tenant_no(db, user)
        operator_id = _get_current_user_id(user)
        removed = amount_auth_svc.revoke_amount_view_role(
            db,
            tenant_no=tenant_no,
            user_id=user_id.strip(),
            operator_id=operator_id,
        )
        if not removed:
            return error_response(400, "该用户未授权或已解除")
        return success_response(None, message="已解除授权")
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))


@router.post("/qc-material-amount-auth/users/batch-revoke")
async def batch_revoke_qc_material_amount_auth(
    body: QcMaterialAmountAuthBatchBody,
    db: Session = Depends(get_db),
    user: dict = Depends(require_menu_code(QC_MATERIAL_AMOUNT_AUTH_LIST_PERM)),
):
    """批量解除「质检物料金额查看」授权。"""
    try:
        tenant_no = _get_tenant_no(db, user)
        operator_id = _get_current_user_id(user)
        count = 0
        for uid in body.user_ids:
            uid = (uid or "").strip()
            if not uid:
                continue
            if amount_auth_svc.revoke_amount_view_role(
                db,
                tenant_no=tenant_no,
                user_id=uid,
                operator_id=operator_id,
            ):
                count += 1
        return success_response({"count": count}, message=f"已解除 {count} 项授权")
    except ValueError as e:
        return error_response(400, str(e))
    except Exception as e:
        return error_response(400, str(e))