package jnpf.limsController;

import jnpf.audit.sdk.annotation.AuditLog;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jnpf.limsEntity.LimsLiuyangBiangengShenqingEntity;
import jnpf.limsEntity.LimsLiuyangJihuaBiangengShenqingEntity;
import jnpf.limsEntity.LimsLiuyangJihuaBiangengShenqingZixiangEntity;
import jnpf.limsEntity.LimsLiuyangJihuaCalculateParam;
import jnpf.limsEntity.LimsLiuyangJihuaCalculateResult;
import jnpf.limsEntity.LimsLiuyangJihuaBiangengCalculateParam;
import jnpf.limsEntity.LimsLiuyangJihuaEntity;
import jnpf.limsEntity.LimsLiuyangJihuaZixiangEntity;
import jnpf.limsEntity.LimsLiuyangJiluEntity;
import jnpf.limsEntity.LiuyangStatus;
import jnpf.limsEntity.LiuyangWendingxingZhouqiZixiangEntity;
import jnpf.limsEntity.LimsQingyandanEntity;
import jnpf.limsService.LiuyangWendingxingZhouqiZixiangService;
import jnpf.limsService.LimsLiuyangJihuaService;
import jnpf.limsService.LimsLiuyangJihuaZixiangService;
import jnpf.limsService.LimsLiuyangBiangengShenqingService;
import jnpf.limsService.LimsLiuyangJihuaBiangengShenqingService;
import jnpf.limsService.LimsLiuyangJihuaBiangengShenqingZixiangService;
import jnpf.limsService.LimsLiuyangJiluService;
import jnpf.limsService.LimsQingyandanService;
import jnpf.util.R;
import jnpf.util.RandomUtil;
import jnpf.util.UserProvider;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.sql.DataSource;
import java.math.BigDecimal;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

@Slf4j
@Tag(name = "lims留样接口", description = "留样记录流程操作")
@RestController
@RequestMapping("/lims/biz")
public class LimsLiuyangController {

    private static final String BIANGENG_ZIXIANG_TABLE = "lims_liuyang_jihua_biangeng_shenqing_zixiang";
    private static final String LIUYANG_CHUKU_SHENQING_TABLE = "lims_liuyang_chuku_shenqing";
    private static final String LIUYANG_CHUKU_SHENQING_ZIXIANG_TABLE = "lims_liuyang_chuku_shenqing_zixiang";
    private static final String LIUYANG_CHUKU_TABLE = "lims_liuyang_chuku";
    private static final String LIUYANG_XIAOHUI_SHENQING_TABLE = "lims_liuyang_xiaohui_shenqing";
    private static final String LIUYANG_XIAOHUI_SHENQING_ZIXIANG_TABLE = "lims_liuyang_xiaohui_shenqing_zixiang";
    private static final String BIZ_STATUS_DESTROYED = "destroyed";
    private static final String BIZ_STATUS_DISABLED = "disabled";

    private static final List<String> DEFAULT_BIANGENG_ZIXIANG_FIELDS = Arrays.asList(
            "zhouqi",
            "zhouqi_danwei",
            "jihua_riqi",
            "shifou_yiguancha",
            "guancha_riqi",
            "guancha_ren",
            "guancha_shuliang",
            "guancha_qingkuang",
            "guancha_jieguo",
            "beizhu"
    );

    @Autowired
    private LimsLiuyangJiluService limsLiuyangJiluService;

    @Autowired
    private LimsQingyandanService limsQingyandanService;

    @Autowired
    private LiuyangWendingxingZhouqiZixiangService liuyangWendingxingZhouqiZixiangService;

    @Autowired
    private LimsLiuyangJihuaService limsLiuyangJihuaService;

    @Autowired
    private LimsLiuyangJihuaZixiangService limsLiuyangJihuaZixiangService;

    @Autowired
    private LimsLiuyangBiangengShenqingService limsLiuyangBiangengShenqingService;

    @Autowired
    private LimsLiuyangJihuaBiangengShenqingService limsLiuyangJihuaBiangengShenqingService;

    @Autowired
    private LimsLiuyangJihuaBiangengShenqingZixiangService limsLiuyangJihuaBiangengShenqingZixiangService;

    @Autowired
    private DataSource dataSource;

    @Autowired
    private JdbcTemplate jdbcTemplate;

    /**
     * 留样操作：
     * submit -> 待审核，并把请验单 liuyang_jilu_id 关联到当前留样记录；
     * reject -> 已退回，并清空请验单 liuyang_jilu_id；
     * accept -> 已接收，并同步入库数量/单位为留样现存量；
     * delete -> 按 JNPF 表单规范软删除留样记录。
     */
    @Transactional(rollbackFor = Exception.class)
    @Operation(summary = "留样操作（提交/拒绝/同意）")
    @PostMapping("/liuyang/action")
    @AuditLog(action = "LIUYANG_ACTION", label = "留样操作", bizType = "LIUYANG",
            bizCodeExpr = "#result.success ? (#params['id'] ?: 'LIUYANG_ACTION') : ''", targetTable = "lims_liuyang_jilu",
            targetIdExpr = "#params['id']", extraExpr = "{'action': #params['action']}",
            diff = true, entityClass = LimsLiuyangJiluEntity.class)
    public R<String> liuyangAction(@RequestBody Map<String, String> params) {
        String action = params.get("action");
        String id = params.get("id");
        String flowId = firstNotBlank(params.get("flow_id"), params.get("flowId"));
        String taskId = firstNotBlank(params.get("task_id"), params.get("taskId"));
        String bizSign = params.get("biz_sign");

        if (action == null || action.isEmpty()) {
            return R.error("缺少 action");
        }
        if ((id == null || id.isEmpty()) && (flowId == null || flowId.isEmpty())) {
            return R.error("缺少 flow_id");
        }

        LimsLiuyangJiluEntity liuyangJilu = findLiuyangJilu(id, flowId, taskId);
        if (liuyangJilu == null) {
            return R.error("留样记录数据不存在");
        }

        switch (action) {
            case "submit":
                updateLiuyangStatus(liuyangJilu, LiuyangStatus.PENDING_AUDIT, bizSign);
                updateQingyandanLiuyangJiluId(liuyangJilu, liuyangJilu.getId());
                return R.success("提交成功");
            case "reject":
                updateLiuyangStatus(liuyangJilu, LiuyangStatus.REJECTED, bizSign);
                updateQingyandanLiuyangJiluId(liuyangJilu, null);
                return R.success("拒绝成功");
            case "accept":
                receiveLiuyangJilu(liuyangJilu, bizSign);
                return R.success("同意成功");
            case "delete":
                softDeleteLiuyangJilu(liuyangJilu, bizSign);
                updateQingyandanLiuyangJiluId(liuyangJilu, null);
                return R.success("删除成功");
            default:
                return R.error("不支持的操作: " + action);
        }
    }

    /**
     * 留样销毁流程操作：
     * submit -> 销毁单号回写到留样记录；
     * reject -> 清空留样记录销毁单号；
     * accept -> shifou_pizhun=yes 时置为已销毁并禁用关联观察计划及子项，shifou_pizhun=no 时清空销毁单号。
     */
    @Transactional(rollbackFor = Exception.class)
    @Operation(summary = "留样销毁操作（提交/拒绝/同意）")
    @PostMapping("/liuyang/xiaohui/action")
    @AuditLog(action = "DESTROY_ACTION", label = "留样销毁操作", bizType = "LIUYANG",
            bizCodeExpr = "#result.success ? (#params['id'] ?: 'LIUYANG_DESTROY') : ''", targetTable = "lims_liuyang_jilu",
            targetIdExpr = "#params['id']", extraExpr = "{'action': #params['action']}",
            diff = true, entityClass = LimsLiuyangJiluEntity.class)
    public R<String> liuyangXiaohuiAction(@RequestBody Map<String, String> params) {
        if (params == null) {
            return R.error("请求参数不能为空");
        }
        String flowId = firstNotBlank(params.get("flow_id"), params.get("flowId"));
        String taskId = firstNotBlank(params.get("task_id"), params.get("taskId"));
        String action = params.get("action");
        String shifouPizhun = firstNotBlank(params.get("shifou_pizhun"), params.get("shifouPizhun"));

        if (isBlank(flowId)) {
            return R.error("流程id(flow_id)不能为空");
        }
        if (isBlank(taskId)) {
            return R.error("流程任务id(task_id)不能为空");
        }
        if (isBlank(action)) {
            return R.error("缺少 action");
        }

        Map<String, Object> shenqing = findLiuyangXiaohuiShenqing(flowId, taskId);
        if (shenqing == null || shenqing.isEmpty()) {
            return R.error("留样销毁申请数据不存在");
        }
        String shenqingId = getString(shenqing, "f_id");
        String xiaohuiDanhao = getString(shenqing, "xiaohui_danhao");
        List<String> liuyangJiluIds = listLiuyangXiaohuiJiluIds(shenqingId);
        if (liuyangJiluIds.isEmpty()) {
            return R.error("留样销毁申请子项不能为空");
        }

        switch (action) {
            case "submit":
                if (isBlank(xiaohuiDanhao)) {
                    return R.error("销毁单号不能为空");
                }
                updateLiuyangXiaohuiDanhao(liuyangJiluIds, xiaohuiDanhao);
                return R.success("提交成功");
            case "reject":
                updateLiuyangXiaohuiDanhao(liuyangJiluIds, null);
                return R.success("拒绝成功");
            case "accept":
                if ("yes".equals(shifouPizhun)) {
                    acceptLiuyangXiaohui(liuyangJiluIds);
                    return R.success("同意成功");
                }
                if ("no".equals(shifouPizhun)) {
                    updateLiuyangXiaohuiDanhao(liuyangJiluIds, null);
                    return R.success("拒绝成功");
                }
                return R.error("是否批准(shifou_pizhun)不能为空，且必须为 yes 或 no");
            default:
                return R.error("不支持的操作: " + action);
        }
    }

    /**
     * 计算留样计划子项周期列表。
     */
    @Operation(summary = "计算留样计划周期")
    @PostMapping("/liuyang/jihua/calculate")
    public R<List<LimsLiuyangJihuaCalculateResult>> calculateLiuyangJihua(@RequestBody LimsLiuyangJihuaCalculateParam param) {
        if (param == null || isBlank(param.getLiuyangJiluId())) {
            return R.error("留样记录主键不能为空");
        }
        if (isBlank(param.getLiuyangZhouqiId())) {
            return R.error("留样周期主键不能为空");
        }

        LimsLiuyangJiluEntity liuyangJilu = limsLiuyangJiluService.getById(param.getLiuyangJiluId());
        if (liuyangJilu == null || Integer.valueOf(1).equals(liuyangJilu.getDeleteMark())) {
            return R.error("留样记录数据不存在");
        }
        if (liuyangJilu.getShouyangRiqi() == null) {
            return R.error("留样记录收样日期不能为空");
        }

        List<LiuyangWendingxingZhouqiZixiangEntity> zhouqiList = listWendingxingZhouqiZixiang(param.getLiuyangZhouqiId());
        if (zhouqiList.isEmpty()) {
            return R.error("稳定性周期子项不能为空");
        }

        try {
            List<LimsLiuyangJihuaCalculateResult> jihuaList = zhouqiList.stream()
                    .map(row -> buildJihuaZixiang(row, liuyangJilu.getShouyangRiqi()))
                    .collect(Collectors.toList());
            return R.success("计算成功", jihuaList);
        } catch (IllegalArgumentException e) {
            return R.error(e.getMessage());
        }
    }

    /**
     * 计划变更时，按新的留样日期重新计算未观察计划，并保留已观察的原计划。
     */
    @Operation(summary = "计算留样计划变更子项")
    @PostMapping("/liuyang/jihua/biangeng/calculate")
    public R<List<Map<String, Object>>> calculateLiuyangJihuaBiangeng(@RequestBody LimsLiuyangJihuaBiangengCalculateParam param) {
        if (param == null || isBlank(param.getLiuyangJihuaId())) {
            return R.error("留样观察计划主键不能为空");
        }
        if (isBlank(param.getLiuyangZhouqiId())) {
            return R.error("留样周期主键不能为空");
        }
        if (param.getLiuyangRiqi() == null) {
            return R.error("留样日期不能为空");
        }

        List<LiuyangWendingxingZhouqiZixiangEntity> zhouqiList = listWendingxingZhouqiZixiang(param.getLiuyangZhouqiId());
        if (zhouqiList.isEmpty()) {
            return R.error("稳定性周期子项不能为空");
        }

        try {
            List<String> responseFields = getBiangengZixiangBusinessFields();
            List<Map<String, Object>> result = new ArrayList<>();

            List<LimsLiuyangJihuaZixiangEntity> observedList = listObservedJihuaZixiang(param.getLiuyangJihuaId());
            Set<String> observedZhouqiKeys = observedList.stream()
                    .map(row -> buildZhouqiKey(row.getZhouqi(), row.getZhouqiDanwei()))
                    .collect(Collectors.toSet());
            observedList.stream()
                    .map(row -> buildBiangengRow(row, responseFields))
                    .forEach(result::add);

            zhouqiList.stream()
                    .filter(row -> !observedZhouqiKeys.contains(buildZhouqiKey(row.getZhouqi(), row.getZhouqiDanwei())))
                    .map(row -> buildBiangengRow(row, param.getLiuyangRiqi(), responseFields))
                    .forEach(result::add);

            return R.success("计算成功", result);
        } catch (IllegalArgumentException e) {
            return R.error(e.getMessage());
        }
    }

    /**
     * 提交留样观察计划：启用计划，并关联回留样记录。
     */
    @Transactional(rollbackFor = Exception.class)
    @Operation(summary = "提交留样观察计划")
    @PostMapping("/liuyang/jihua/submit")
    @AuditLog(action = "PLAN_SUBMIT", label = "提交留样观察计划", bizType = "LIUYANG",
            bizCodeExpr = "#result.success ? 'LIUYANG_PLAN' : ''", targetTable = "lims_liuyang_jihua",
            targetIdExpr = "#formData['id'] ?: #formData['f_id']", diff = true,
            entityClass = LimsLiuyangJihuaEntity.class)
    public R<String> submitLiuyangJihua(@RequestBody Map<String, Object> formData) {
        String jihuaId = getFormId(formData);
        if (isBlank(jihuaId)) {
            return R.error("留样观察计划主键不能为空");
        }

        LimsLiuyangJihuaEntity jihua = limsLiuyangJihuaService.getById(jihuaId);
        if (jihua == null || Integer.valueOf(1).equals(jihua.getDeleteMark())) {
            return R.error("留样观察计划数据不存在");
        }
        if (isBlank(jihua.getLiuyangJiluId())) {
            return R.error("留样观察计划未关联留样记录");
        }

        LimsLiuyangJihuaEntity jihuaUpdate = new LimsLiuyangJihuaEntity();
        jihuaUpdate.setId(jihua.getId());
        jihuaUpdate.setBizStatus("enabled");
        limsLiuyangJihuaService.updateById(jihuaUpdate);
        jihua.setBizStatus("enabled");

        syncJihuaInfoToZixiang(jihua);

        LimsLiuyangJiluEntity jiluUpdate = new LimsLiuyangJiluEntity();
        jiluUpdate.setId(jihua.getLiuyangJiluId());
        jiluUpdate.setLiuyangJihuaId(jihua.getId());
        limsLiuyangJiluService.updateById(jiluUpdate);

        return R.success("提交成功");
    }

    /**
     * 留样观察计划变更：将变更申请同步到实际留样观察计划。
     */
    @Transactional(rollbackFor = Exception.class)
    @Operation(summary = "留样观察计划变更")
    @PostMapping("/liuyang/jihua/biangeng/action")
    @AuditLog(action = "PLAN_CHANGE", label = "留样观察计划变更", bizType = "LIUYANG",
            bizCodeExpr = "#result.success ? (#params['id'] ?: 'LIUYANG_PLAN_CHANGE') : ''", targetTable = "lims_liuyang_jihua",
            targetIdExpr = "T(jnpf.limsService.support.LimsAuditTargetIds).liuyangJihuaByChangeFlow(" +
                    "#params['flow_id'] ?: #params['flowId'], #params['task_id'] ?: #params['taskId'])",
            extraExpr = "{'action': #params['action']}", diff = true,
            entityClass = LimsLiuyangJihuaEntity.class)
    public R<String> liuyangJihuaBiangengAction(@RequestBody Map<String, String> params) {
        if (params == null) {
            return R.error("请求参数不能为空");
        }
        String flowId = firstNotBlank(params.get("flow_id"), params.get("flowId"));
        String taskId = firstNotBlank(params.get("task_id"), params.get("taskId"));

        if (isBlank(flowId)) {
            return R.error("流程id(flow_id)不能为空");
        }
        if (isBlank(taskId)) {
            return R.error("流程任务id(task_id)不能为空");
        }

        LimsLiuyangJihuaBiangengShenqingEntity shenqing = findJihuaBiangengShenqing(flowId, taskId);
        if (shenqing == null) {
            return R.error("留样观察计划变更申请数据不存在");
        }
        if (isBlank(shenqing.getLiuyangJihuaId())) {
            return R.error("变更申请未关联留样观察计划");
        }

        LimsLiuyangJihuaEntity jihua = limsLiuyangJihuaService.getById(shenqing.getLiuyangJihuaId());
        if (jihua == null || Integer.valueOf(1).equals(jihua.getDeleteMark())) {
            return R.error("留样观察计划数据不存在");
        }

        updateJihuaByBiangeng(shenqing);
        softDeleteUnobservedJihuaZixiang(shenqing.getLiuyangJihuaId());
        syncBiangengZixiangToJihuaZixiang(jihua, shenqing);

        return R.success("变更成功");
    }

    /**
     * 留样数量变更：将变更申请的入库数量/单位同步到留样记录。
     * 仅当留样记录未出库（入库数量 == 留样现存量）时允许变更。
     */
    @Transactional(rollbackFor = Exception.class)
    @Operation(summary = "留样数量变更")
    @PostMapping("/liuyang/biangeng/action")
    @AuditLog(action = "QUANTITY_CHANGE", label = "留样数量变更", bizType = "LIUYANG",
            bizCodeExpr = "#result.success ? #params['liuyang_jilu_id'] : ''",
            targetTable = "lims_liuyang_jilu", targetIdExpr = "#params['liuyang_jilu_id']",
            diff = true, entityClass = LimsLiuyangJiluEntity.class)
    public R<String> liuyangBiangengAction(@RequestBody Map<String, String> params) {
        String liuyangJiluId = params.get("liuyang_jilu_id");
        String biangengShenqingId = params.get("biangeng_shenqing_id");

        if (isBlank(liuyangJiluId)) {
            return R.error("留样记录主键不能为空");
        }
        if (isBlank(biangengShenqingId)) {
            return R.error("变更申请主键不能为空");
        }

        LimsLiuyangJiluEntity jilu = findById(liuyangJiluId);
        if (jilu == null) {
            return R.error("留样记录数据不存在");
        }

        LimsLiuyangBiangengShenqingEntity shenqing = findBiangengShenqing(biangengShenqingId);
        if (shenqing == null) {
            return R.error("变更申请数据不存在");
        }

        if (!equalsNullable(jilu.getRukuShuliang(), jilu.getLiuyangXiancunliang())) {
            return R.error("该留样样品已出库，无法变更数量");
        }

        LimsLiuyangJiluEntity jiluUpdate = new LimsLiuyangJiluEntity();
        jiluUpdate.setId(jilu.getId());
        jiluUpdate.setRukuShuliang(shenqing.getRukuShuliang());
        jiluUpdate.setLiuyangXiancunliang(shenqing.getRukuShuliang());
        jiluUpdate.setDanwei(shenqing.getDanwei());
        jiluUpdate.setLiuyangXiancunliangDanwei(shenqing.getDanwei());
        limsLiuyangJiluService.updateById(jiluUpdate);

        syncBiangengToJihua(liuyangJiluId, shenqing);

        return R.success("变更成功");
    }

    /**
     * 留样出库验证：审批前校验申请出库数量不能大于留样现存量。
     */
    @Operation(summary = "留样出库验证")
    @PostMapping("/liuyang/chuku/validate")
    public R<String> validateLiuyangChuku(@RequestBody Map<String, String> params) {
        if (params == null) {
            return R.error("请求参数不能为空");
        }
        String flowId = params.get("flow_id");
        String taskId = params.get("task_id");
        if (isBlank(flowId)) {
            return R.error("流程id(flow_id)不能为空");
        }
        if (isBlank(taskId)) {
            return R.error("流程任务id(task_id)不能为空");
        }

        try {
            String shenqingId = findLiuyangChukuShenqingId(flowId, taskId);
            if (isBlank(shenqingId)) {
                return R.error("留样出库申请数据不存在");
            }

            List<Map<String, String>> zixiangList = listLiuyangChukuShenqingZixiang(shenqingId);
            for (Map<String, String> zixiang : zixiangList) {
                String liuyangJiluId = zixiang.get("liuyang_jilu_id");
                LimsLiuyangJiluEntity jilu = isBlank(liuyangJiluId) ? null : findById(liuyangJiluId);
                if (jilu == null) {
                    return R.error(buildChukuStockErrorMessage(zixiang));
                }

                BigDecimal chukuShuliang = parseDecimal(zixiang.get("chuku_shuliang"));
                BigDecimal xiancunliang = parseDecimal(jilu.getLiuyangXiancunliang());
                if (chukuShuliang == null || xiancunliang == null || chukuShuliang.compareTo(xiancunliang) > 0) {
                    return R.error(buildChukuStockErrorMessage(zixiang, jilu));
                }
            }
            return R.success("验证通过");
        } catch (SQLException e) {
            log.error("留样出库验证失败：flowId={}, taskId={}", flowId, taskId, e);
            return R.error("留样出库验证失败");
        }
    }

    /**
     * 留样出库：按申请子项扣减留样现存量，同步观察计划现存量，并写出库记录。
     */
    @Transactional(rollbackFor = Exception.class)
    @Operation(summary = "留样出库")
    @PostMapping("/liuyang/chuku/action")
    @AuditLog(action = "OUTBOUND", label = "留样出库", bizType = "LIUYANG",
            bizCodeExpr = "#result.success ? #params['liuyang_jilu_id'] : ''",
            targetTable = "lims_liuyang_jilu", targetIdExpr = "#params['liuyang_jilu_id']",
            diff = true, entityClass = LimsLiuyangJiluEntity.class)
    public R<String> liuyangChukuAction(@RequestBody Map<String, String> params) {
        if (params == null) {
            return R.error("请求参数不能为空");
        }
        String flowId = params.get("flow_id");
        String taskId = params.get("task_id");
        if (isBlank(flowId)) {
            return R.error("流程id(flow_id)不能为空");
        }
        if (isBlank(taskId)) {
            return R.error("流程任务id(task_id)不能为空");
        }

        Map<String, Object> shenqing = findLiuyangChukuShenqing(flowId, taskId);
        if (shenqing == null || shenqing.isEmpty()) {
            return R.error("留样出库申请数据不存在");
        }
        String shenqingId = getString(shenqing, "f_id");
        List<Map<String, Object>> zixiangList = listLiuyangChukuShenqingZixiangRows(shenqingId);
        if (zixiangList.isEmpty()) {
            return R.error("留样出库申请子项不能为空");
        }

        for (Map<String, Object> zixiang : zixiangList) {
            String liuyangJiluId = getString(zixiang, "liuyang_jilu_id");
            LimsLiuyangJiluEntity jilu = isBlank(liuyangJiluId) ? null : findById(liuyangJiluId);
            if (jilu == null) {
                return R.error(buildChukuStockErrorMessage(zixiang));
            }

            BigDecimal chukuShuliang = parseDecimal(getString(zixiang, "chuku_shuliang"));
            BigDecimal oldXiancunliang = parseDecimal(jilu.getLiuyangXiancunliang());
            if (chukuShuliang == null || oldXiancunliang == null || chukuShuliang.compareTo(oldXiancunliang) > 0) {
                return R.error(buildChukuStockErrorMessage(zixiang, jilu));
            }

            BigDecimal newXiancunliang = oldXiancunliang.subtract(chukuShuliang);
            String newXiancunliangText = toPlainString(newXiancunliang);

            LimsLiuyangJiluEntity jiluUpdate = new LimsLiuyangJiluEntity();
            jiluUpdate.setId(jilu.getId());
            jiluUpdate.setLiuyangXiancunliang(newXiancunliangText);
            limsLiuyangJiluService.updateById(jiluUpdate);

            syncChukuLiuyangXiancunliangToJihua(jilu.getId(), newXiancunliangText);
            insertLiuyangChukuRecord(shenqing, zixiang, jilu, oldXiancunliang);
        }

        return R.success("出库成功");
    }

    private Map<String, Object> findLiuyangChukuShenqing(String flowId, String taskId) {
        String sql = "select * from " + LIUYANG_CHUKU_SHENQING_TABLE
                + " where f_flow_id = ? and f_flow_task_id = ?"
                + " and (f_delete_mark is null or f_delete_mark <> 1)"
                + " limit 1";
        List<Map<String, Object>> list = jdbcTemplate.queryForList(sql, flowId, taskId);
        return list.isEmpty() ? null : list.get(0);
    }

    private List<Map<String, Object>> listLiuyangChukuShenqingZixiangRows(String shenqingId) {
        String sql = "select * from " + LIUYANG_CHUKU_SHENQING_ZIXIANG_TABLE
                + " where f_foreign_id = ?"
                + " and (f_delete_mark is null or f_delete_mark <> 1)";
        return jdbcTemplate.queryForList(sql, shenqingId);
    }

    private void syncChukuLiuyangXiancunliangToJihua(String liuyangJiluId, String liuyangXiancunliang) {
        LambdaUpdateWrapper<LimsLiuyangJihuaEntity> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(LimsLiuyangJihuaEntity::getLiuyangJiluId, liuyangJiluId)
                .and(w -> w.isNull(LimsLiuyangJihuaEntity::getDeleteMark)
                        .or()
                        .ne(LimsLiuyangJihuaEntity::getDeleteMark, 1))
                .set(LimsLiuyangJihuaEntity::getLiuyangXiancunliang, liuyangXiancunliang);
        limsLiuyangJihuaService.update(wrapper);
    }

    private void insertLiuyangChukuRecord(Map<String, Object> shenqing,
                                          Map<String, Object> zixiang,
                                          LimsLiuyangJiluEntity jilu,
                                          BigDecimal oldXiancunliang) {
        String sql = "insert into " + LIUYANG_CHUKU_TABLE
                + " (f_id, f_foreign_id, f_tenant_id, chuku_shenqing_id,"
                + " yangpin_mingcheng, yangpin_bianma, guige, pihao,"
                + " liuyang_xiancunliang, chuku_shuliang, danwei, yongtu,"
                + " shenqing_ren, shenqing_riqi, fafang_ren, shenhe_ren, shenhe_riqi, fafang_riqi)"
                + " values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
        String shenqingId = getString(shenqing, "f_id");
        jdbcTemplate.update(sql,
                RandomUtil.uuId(),
                jilu.getId(),
                firstNotBlank(getString(zixiang, "f_tenant_id"), getString(shenqing, "f_tenant_id")),
                shenqingId,
                firstNotBlank(getString(zixiang, "yangpin_mingcheng"), jilu.getYangpinMingcheng()),
                firstNotBlank(getString(zixiang, "yangpin_bianma"), jilu.getYangpinBianma()),
                firstNotBlank(getString(zixiang, "guige"), jilu.getGuige()),
                firstNotBlank(getString(zixiang, "pihao"), jilu.getPihao()),
                toPlainString(oldXiancunliang),
                parseDecimal(getString(zixiang, "chuku_shuliang")),
                firstNotBlank(getString(zixiang, "danwei"), jilu.getDanwei()),
                firstNotBlank(getString(zixiang, "yongtu"), getString(shenqing, "yongtu")),
                getObject(shenqing, "shenqing_ren"),
                getObject(shenqing, "shenqing_riqi"),
                getObject(shenqing, "fafang_ren"),
                getObject(shenqing, "shenhe_ren"),
                getObject(shenqing, "shenhe_riqi"),
                getObject(shenqing, "fafang_riqi"));
    }

    private Map<String, Object> findLiuyangXiaohuiShenqing(String flowId, String taskId) {
        String sql = "select * from " + LIUYANG_XIAOHUI_SHENQING_TABLE
                + " where f_flow_id = ? and f_flow_task_id = ?"
                + " and (f_delete_mark is null or f_delete_mark <> 1)"
                + " limit 1";
        List<Map<String, Object>> list = jdbcTemplate.queryForList(sql, flowId, taskId);
        return list.isEmpty() ? null : list.get(0);
    }

    private List<String> listLiuyangXiaohuiJiluIds(String shenqingId) {
        String sql = "select distinct liuyang_jilu_id from " + LIUYANG_XIAOHUI_SHENQING_ZIXIANG_TABLE
                + " where f_foreign_id = ?"
                + " and liuyang_jilu_id is not null and liuyang_jilu_id <> ''"
                + " and (f_delete_mark is null or f_delete_mark <> 1)";
        return jdbcTemplate.queryForList(sql, shenqingId).stream()
                .map(row -> getString(row, "liuyang_jilu_id"))
                .filter(value -> !isBlank(value))
                .distinct()
                .collect(Collectors.toList());
    }

    private void updateLiuyangXiaohuiDanhao(List<String> liuyangJiluIds, String xiaohuiDanhao) {
        LambdaUpdateWrapper<LimsLiuyangJiluEntity> wrapper = new LambdaUpdateWrapper<>();
        wrapper.in(LimsLiuyangJiluEntity::getId, liuyangJiluIds)
                .and(w -> w.isNull(LimsLiuyangJiluEntity::getDeleteMark)
                        .or()
                        .ne(LimsLiuyangJiluEntity::getDeleteMark, 1))
                .set(LimsLiuyangJiluEntity::getXiaohuiDanhao, xiaohuiDanhao);
        limsLiuyangJiluService.update(wrapper);
    }

    private void acceptLiuyangXiaohui(List<String> liuyangJiluIds) {
        LambdaUpdateWrapper<LimsLiuyangJiluEntity> jiluUpdate = new LambdaUpdateWrapper<>();
        jiluUpdate.in(LimsLiuyangJiluEntity::getId, liuyangJiluIds)
                .and(w -> w.isNull(LimsLiuyangJiluEntity::getDeleteMark)
                        .or()
                        .ne(LimsLiuyangJiluEntity::getDeleteMark, 1))
                .set(LimsLiuyangJiluEntity::getBizStatus, BIZ_STATUS_DESTROYED);
        limsLiuyangJiluService.update(jiluUpdate);

        List<String> jihuaIds = listLiuyangJihuaIdsByJiluIds(liuyangJiluIds);

        LambdaUpdateWrapper<LimsLiuyangJihuaEntity> jihuaUpdate = new LambdaUpdateWrapper<>();
        jihuaUpdate.in(LimsLiuyangJihuaEntity::getLiuyangJiluId, liuyangJiluIds)
                .and(w -> w.isNull(LimsLiuyangJihuaEntity::getDeleteMark)
                        .or()
                        .ne(LimsLiuyangJihuaEntity::getDeleteMark, 1))
                .set(LimsLiuyangJihuaEntity::getBizStatus, BIZ_STATUS_DISABLED);
        limsLiuyangJihuaService.update(jihuaUpdate);

        if (!jihuaIds.isEmpty()) {
            LambdaUpdateWrapper<LimsLiuyangJihuaZixiangEntity> zixiangUpdate = new LambdaUpdateWrapper<>();
            zixiangUpdate.in(LimsLiuyangJihuaZixiangEntity::getForeignId, jihuaIds)
                    .and(w -> w.isNull(LimsLiuyangJihuaZixiangEntity::getDeleteMark)
                            .or()
                            .ne(LimsLiuyangJihuaZixiangEntity::getDeleteMark, 1))
                    .set(LimsLiuyangJihuaZixiangEntity::getBizStatus, BIZ_STATUS_DISABLED);
            limsLiuyangJihuaZixiangService.update(zixiangUpdate);
        }
    }

    private List<String> listLiuyangJihuaIdsByJiluIds(List<String> liuyangJiluIds) {
        LambdaQueryWrapper<LimsLiuyangJihuaEntity> query = new LambdaQueryWrapper<>();
        query.in(LimsLiuyangJihuaEntity::getLiuyangJiluId, liuyangJiluIds)
                .and(w -> w.isNull(LimsLiuyangJihuaEntity::getDeleteMark)
                        .or()
                        .ne(LimsLiuyangJihuaEntity::getDeleteMark, 1));
        return limsLiuyangJihuaService.list(query).stream()
                .map(LimsLiuyangJihuaEntity::getId)
                .filter(value -> !isBlank(value))
                .distinct()
                .collect(Collectors.toList());
    }

    private String findLiuyangChukuShenqingId(String flowId, String taskId) throws SQLException {
        String sql = "select f_id from " + LIUYANG_CHUKU_SHENQING_TABLE
                + " where f_flow_id = ? and f_flow_task_id = ?"
                + " and (f_delete_mark is null or f_delete_mark <> 1)"
                + " limit 1";
        try (Connection connection = dataSource.getConnection();
             PreparedStatement statement = connection.prepareStatement(sql)) {
            statement.setString(1, flowId);
            statement.setString(2, taskId);
            try (ResultSet resultSet = statement.executeQuery()) {
                return resultSet.next() ? resultSet.getString("f_id") : null;
            }
        }
    }

    private List<Map<String, String>> listLiuyangChukuShenqingZixiang(String shenqingId) throws SQLException {
        String sql = "select liuyang_jilu_id, chuku_shuliang, yangpin_mingcheng, pihao from "
                + LIUYANG_CHUKU_SHENQING_ZIXIANG_TABLE
                + " where f_foreign_id = ?"
                + " and (f_delete_mark is null or f_delete_mark <> 1)";
        List<Map<String, String>> list = new ArrayList<>();
        try (Connection connection = dataSource.getConnection();
             PreparedStatement statement = connection.prepareStatement(sql)) {
            statement.setString(1, shenqingId);
            try (ResultSet resultSet = statement.executeQuery()) {
                while (resultSet.next()) {
                    Map<String, String> row = new LinkedHashMap<>();
                    row.put("liuyang_jilu_id", resultSet.getString("liuyang_jilu_id"));
                    row.put("chuku_shuliang", resultSet.getString("chuku_shuliang"));
                    row.put("yangpin_mingcheng", resultSet.getString("yangpin_mingcheng"));
                    row.put("pihao", resultSet.getString("pihao"));
                    list.add(row);
                }
            }
        }
        return list;
    }

    private String buildChukuStockErrorMessage(Map<String, ?> zixiang) {
        return buildChukuStockErrorMessage(zixiang, null);
    }

    private String buildChukuStockErrorMessage(Map<String, ?> zixiang, LimsLiuyangJiluEntity jilu) {
        String yangpinMingcheng = firstNotBlank(getString(zixiang, "yangpin_mingcheng"), jilu == null ? null : jilu.getYangpinMingcheng());
        String pihao = firstNotBlank(getString(zixiang, "pihao"), jilu == null ? null : jilu.getPihao());
        return trimToEmpty(yangpinMingcheng) + "批次" + trimToEmpty(pihao) + "库存不足，不满足出库条件";
    }

    private BigDecimal parseDecimal(String value) {
        if (isBlank(value)) {
            return null;
        }
        try {
            return new BigDecimal(value.trim());
        } catch (NumberFormatException e) {
            return null;
        }
    }

    private String firstNotBlank(String first, String second) {
        return isBlank(first) ? second : first;
    }

    private String trimToEmpty(String value) {
        return value == null ? "" : value.trim();
    }

    private String getString(Map<String, ?> row, String key) {
        if (row == null || key == null) {
            return null;
        }
        Object value = row.get(key);
        return value == null ? null : String.valueOf(value);
    }

    private Object getObject(Map<String, ?> row, String key) {
        if (row == null || key == null) {
            return null;
        }
        return row.get(key);
    }

    private String toPlainString(BigDecimal value) {
        return value == null ? null : value.stripTrailingZeros().toPlainString();
    }

    private void syncBiangengToJihua(String liuyangJiluId, LimsLiuyangBiangengShenqingEntity shenqing) {
        LambdaUpdateWrapper<LimsLiuyangJihuaEntity> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(LimsLiuyangJihuaEntity::getLiuyangJiluId, liuyangJiluId)
                .and(w -> w.isNull(LimsLiuyangJihuaEntity::getDeleteMark)
                        .or()
                        .ne(LimsLiuyangJihuaEntity::getDeleteMark, 1))
                .set(LimsLiuyangJihuaEntity::getRukuShuliang, shenqing.getRukuShuliang())
                .set(LimsLiuyangJihuaEntity::getLiuyangXiancunliang, shenqing.getRukuShuliang())
                .set(LimsLiuyangJihuaEntity::getDanwei, shenqing.getDanwei())
                .set(LimsLiuyangJihuaEntity::getLiuyangXiancunliangDanwei, shenqing.getDanwei());
        limsLiuyangJihuaService.update(wrapper);
    }

    private LimsLiuyangBiangengShenqingEntity findBiangengShenqing(String id) {
        LambdaQueryWrapper<LimsLiuyangBiangengShenqingEntity> query = new LambdaQueryWrapper<>();
        query.eq(LimsLiuyangBiangengShenqingEntity::getId, id)
                .and(w -> w.isNull(LimsLiuyangBiangengShenqingEntity::getDeleteMark)
                        .or()
                        .ne(LimsLiuyangBiangengShenqingEntity::getDeleteMark, 1));
        query.last("limit 1");
        return limsLiuyangBiangengShenqingService.getOne(query, false);
    }

    private LimsLiuyangJihuaBiangengShenqingEntity findJihuaBiangengShenqing(String flowId, String taskId) {
        LambdaQueryWrapper<LimsLiuyangJihuaBiangengShenqingEntity> query = new LambdaQueryWrapper<>();
        query.eq(LimsLiuyangJihuaBiangengShenqingEntity::getFlowId, flowId)
                .eq(LimsLiuyangJihuaBiangengShenqingEntity::getFlowTaskId, taskId)
                .and(w -> w.isNull(LimsLiuyangJihuaBiangengShenqingEntity::getDeleteMark)
                        .or()
                        .ne(LimsLiuyangJihuaBiangengShenqingEntity::getDeleteMark, 1));
        query.last("limit 1");
        return limsLiuyangJihuaBiangengShenqingService.getOne(query, false);
    }

    private void updateJihuaByBiangeng(LimsLiuyangJihuaBiangengShenqingEntity shenqing) {
        LimsLiuyangJihuaEntity update = new LimsLiuyangJihuaEntity();
        update.setId(shenqing.getLiuyangJihuaId());
        update.setLiuyangRiqi(shenqing.getLiuyangRiqi());
        update.setLiuyangZhouqiId(shenqing.getLiuyangZhouqiId());
        limsLiuyangJihuaService.updateById(update);
    }

    private void softDeleteUnobservedJihuaZixiang(String jihuaId) {
        LambdaUpdateWrapper<LimsLiuyangJihuaZixiangEntity> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(LimsLiuyangJihuaZixiangEntity::getForeignId, jihuaId)
                .and(w -> w.isNull(LimsLiuyangJihuaZixiangEntity::getShifouYiguancha)
                        .or()
                        .ne(LimsLiuyangJihuaZixiangEntity::getShifouYiguancha, "yes"))
                .and(w -> w.isNull(LimsLiuyangJihuaZixiangEntity::getDeleteMark)
                        .or()
                        .ne(LimsLiuyangJihuaZixiangEntity::getDeleteMark, 1))
                .set(LimsLiuyangJihuaZixiangEntity::getDeleteMark, 1)
                .set(LimsLiuyangJihuaZixiangEntity::getDeleteTime, new Date())
                .set(LimsLiuyangJihuaZixiangEntity::getDeleteUserId, UserProvider.getUser().getUserId());
        limsLiuyangJihuaZixiangService.update(wrapper);
    }

    private void syncBiangengZixiangToJihuaZixiang(LimsLiuyangJihuaEntity jihua, LimsLiuyangJihuaBiangengShenqingEntity shenqing) {
        List<LimsLiuyangJihuaBiangengShenqingZixiangEntity> shenqingZixiangList = listUnobservedJihuaBiangengZixiang(shenqing.getId());
        if (shenqingZixiangList.isEmpty()) {
            return;
        }

        List<LimsLiuyangJihuaZixiangEntity> jihuaZixiangList = shenqingZixiangList.stream()
                .map(row -> buildJihuaZixiangFromBiangeng(jihua, shenqing, row))
                .collect(Collectors.toList());
        limsLiuyangJihuaZixiangService.saveBatch(jihuaZixiangList);
    }

    private List<LimsLiuyangJihuaBiangengShenqingZixiangEntity> listUnobservedJihuaBiangengZixiang(String shenqingId) {
        LambdaQueryWrapper<LimsLiuyangJihuaBiangengShenqingZixiangEntity> query = new LambdaQueryWrapper<>();
        query.eq(LimsLiuyangJihuaBiangengShenqingZixiangEntity::getForeignId, shenqingId)
                .and(w -> w.isNull(LimsLiuyangJihuaBiangengShenqingZixiangEntity::getShifouYiguancha)
                        .or()
                        .ne(LimsLiuyangJihuaBiangengShenqingZixiangEntity::getShifouYiguancha, "yes"))
                .and(w -> w.isNull(LimsLiuyangJihuaBiangengShenqingZixiangEntity::getDeleteMark)
                        .or()
                        .ne(LimsLiuyangJihuaBiangengShenqingZixiangEntity::getDeleteMark, 1))
                .orderByAsc(LimsLiuyangJihuaBiangengShenqingZixiangEntity::getJihuaRiqi);
        return limsLiuyangJihuaBiangengShenqingZixiangService.list(query);
    }

    private LimsLiuyangJihuaZixiangEntity buildJihuaZixiangFromBiangeng(
            LimsLiuyangJihuaEntity jihua,
            LimsLiuyangJihuaBiangengShenqingEntity shenqing,
            LimsLiuyangJihuaBiangengShenqingZixiangEntity shenqingZixiang) {
        LimsLiuyangJihuaZixiangEntity zixiang = new LimsLiuyangJihuaZixiangEntity();
        zixiang.setId(RandomUtil.uuId());
        zixiang.setForeignId(jihua.getId());
        zixiang.setZhouqi(shenqingZixiang.getZhouqi());
        zixiang.setZhouqiDanwei(shenqingZixiang.getZhouqiDanwei());
        zixiang.setJihuaRiqi(shenqingZixiang.getJihuaRiqi());
        zixiang.setGuanchaRiqi(shenqingZixiang.getGuanchaRiqi());
        zixiang.setGuanchaRen(shenqingZixiang.getGuanchaRen());
        zixiang.setGuanchaShuliang(shenqingZixiang.getGuanchaShuliang());
        zixiang.setGuanchaQingkuang(shenqingZixiang.getGuanchaQingkuang());
        zixiang.setGuanchaJieguo(shenqingZixiang.getGuanchaJieguo());
        zixiang.setShifouYiguancha(shenqingZixiang.getShifouYiguancha());
        zixiang.setBeizhu(shenqingZixiang.getBeizhu());
        zixiang.setBizType(jihua.getBizType());
        zixiang.setYangpinMingcheng(jihua.getYangpinMingcheng());
        zixiang.setYangpinBianma(jihua.getYangpinBianma());
        zixiang.setGuige(jihua.getGuige());
        zixiang.setPihao(jihua.getPihao());
        zixiang.setShengchanRiqi(jihua.getShengchanRiqi());
        zixiang.setYouxiaoqi(jihua.getYouxiaoqi());
        zixiang.setLiuyangRiqi(shenqing.getLiuyangRiqi());
        zixiang.setGuanchaShuliangDanwei(jihua.getDanwei());
        zixiang.setBizStatus(jihua.getBizStatus());
        return zixiang;
    }

    private boolean equalsNullable(String a, String b) {
        if (a == null && b == null) {
            return true;
        }
        if (a == null || b == null) {
            return false;
        }
        return a.trim().equals(b.trim());
    }

    private String getFormId(Map<String, Object> formData) {
        if (formData == null) {
            return null;
        }
        Object id = formData.get("f_id");
        if (id == null) {
            id = formData.get("id");
        }
        return id == null ? null : String.valueOf(id);
    }

    private void syncJihuaInfoToZixiang(LimsLiuyangJihuaEntity jihua) {
        LambdaUpdateWrapper<LimsLiuyangJihuaZixiangEntity> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(LimsLiuyangJihuaZixiangEntity::getForeignId, jihua.getId())
                .and(w -> w.isNull(LimsLiuyangJihuaZixiangEntity::getDeleteMark)
                        .or()
                        .ne(LimsLiuyangJihuaZixiangEntity::getDeleteMark, 1))
                // 提交计划时，将主表样品信息冗余到周期子项，便于后续观察列表独立展示。
                .set(LimsLiuyangJihuaZixiangEntity::getBizType, jihua.getBizType())
                .set(LimsLiuyangJihuaZixiangEntity::getYangpinMingcheng, jihua.getYangpinMingcheng())
                .set(LimsLiuyangJihuaZixiangEntity::getYangpinBianma, jihua.getYangpinBianma())
                .set(LimsLiuyangJihuaZixiangEntity::getGuige, jihua.getGuige())
                .set(LimsLiuyangJihuaZixiangEntity::getPihao, jihua.getPihao())
                .set(LimsLiuyangJihuaZixiangEntity::getShengchanRiqi, jihua.getShengchanRiqi())
                .set(LimsLiuyangJihuaZixiangEntity::getYouxiaoqi, jihua.getYouxiaoqi())
                .set(LimsLiuyangJihuaZixiangEntity::getLiuyangRiqi, jihua.getLiuyangRiqi())
                .set(LimsLiuyangJihuaZixiangEntity::getGuanchaShuliangDanwei, jihua.getDanwei())
                .set(LimsLiuyangJihuaZixiangEntity::getBizStatus, jihua.getBizStatus());
        limsLiuyangJihuaZixiangService.update(wrapper);
    }

    private LimsLiuyangJiluEntity findLiuyangJilu(String id, String flowId, String taskId) {
        if (id != null && !id.isEmpty()) {
            return findById(id);
        }
        return findByFlow(flowId, taskId);
    }

    private LimsLiuyangJiluEntity findById(String id) {
        LambdaQueryWrapper<LimsLiuyangJiluEntity> query = new LambdaQueryWrapper<>();
        query.eq(LimsLiuyangJiluEntity::getId, id)
                .and(w -> w.isNull(LimsLiuyangJiluEntity::getDeleteMark)
                        .or()
                        .ne(LimsLiuyangJiluEntity::getDeleteMark, 1));
        query.last("limit 1");
        return limsLiuyangJiluService.getOne(query, false);
    }

    private LimsLiuyangJiluEntity findByFlow(String flowId, String taskId) {
        LambdaQueryWrapper<LimsLiuyangJiluEntity> query = new LambdaQueryWrapper<>();
        query.eq(LimsLiuyangJiluEntity::getFlowId, flowId)
                .and(w -> w.isNull(LimsLiuyangJiluEntity::getDeleteMark)
                        .or()
                        .ne(LimsLiuyangJiluEntity::getDeleteMark, 1));
        if (taskId != null && !taskId.isEmpty()) {
            query.eq(LimsLiuyangJiluEntity::getFlowTaskId, taskId);
        }
        query.last("limit 1");
        return limsLiuyangJiluService.getOne(query, false);
    }

    private List<LiuyangWendingxingZhouqiZixiangEntity> listWendingxingZhouqiZixiang(String zhouqiId) {
        LambdaQueryWrapper<LiuyangWendingxingZhouqiZixiangEntity> query = new LambdaQueryWrapper<>();
        query.eq(LiuyangWendingxingZhouqiZixiangEntity::getForeignId, zhouqiId)
                .and(w -> w.isNull(LiuyangWendingxingZhouqiZixiangEntity::getDeleteMark)
                        .or()
                        .ne(LiuyangWendingxingZhouqiZixiangEntity::getDeleteMark, 1))
                .orderByAsc(LiuyangWendingxingZhouqiZixiangEntity::getZhouqi);
        return liuyangWendingxingZhouqiZixiangService.list(query);
    }

    private List<LimsLiuyangJihuaZixiangEntity> listObservedJihuaZixiang(String jihuaId) {
        LambdaQueryWrapper<LimsLiuyangJihuaZixiangEntity> query = new LambdaQueryWrapper<>();
        query.eq(LimsLiuyangJihuaZixiangEntity::getForeignId, jihuaId)
                .eq(LimsLiuyangJihuaZixiangEntity::getShifouYiguancha, "yes")
                .and(w -> w.isNull(LimsLiuyangJihuaZixiangEntity::getDeleteMark)
                        .or()
                        .ne(LimsLiuyangJihuaZixiangEntity::getDeleteMark, 1))
                .orderByAsc(LimsLiuyangJihuaZixiangEntity::getJihuaRiqi);
        return limsLiuyangJihuaZixiangService.list(query);
    }

    private LimsLiuyangJihuaCalculateResult buildJihuaZixiang(LiuyangWendingxingZhouqiZixiangEntity zhouqi, Date shouyangRiqi) {
        if (zhouqi.getZhouqi() == null) {
            throw new IllegalArgumentException("周期不能为空");
        }
        if (isBlank(zhouqi.getZhouqiDanwei())) {
            throw new IllegalArgumentException("周期单位不能为空");
        }

        LimsLiuyangJihuaCalculateResult item = new LimsLiuyangJihuaCalculateResult();
        item.setZhouqi(zhouqi.getZhouqi());
        item.setZhouqiDanwei(zhouqi.getZhouqiDanwei());
        item.setJihuaRiqi(calculateJihuaRiqi(shouyangRiqi, zhouqi.getZhouqi(), zhouqi.getZhouqiDanwei()));
        item.setGuanchaRiqi(null);
        item.setShifouYiguancha("no");
        return item;
    }

    private Map<String, Object> buildBiangengRow(LimsLiuyangJihuaZixiangEntity jihuaZixiang, List<String> responseFields) {
        Map<String, Object> row = newEmptyBiangengRow(responseFields);
        putIfPresent(row, "zhouqi", jihuaZixiang.getZhouqi());
        putIfPresent(row, "zhouqi_danwei", jihuaZixiang.getZhouqiDanwei());
        putIfPresent(row, "jihua_riqi", jihuaZixiang.getJihuaRiqi());
        putIfPresent(row, "shifou_yiguancha", jihuaZixiang.getShifouYiguancha());
        putIfPresent(row, "guancha_riqi", jihuaZixiang.getGuanchaRiqi());
        putIfPresent(row, "guancha_ren", jihuaZixiang.getGuanchaRen());
        putIfPresent(row, "guancha_shuliang", jihuaZixiang.getGuanchaShuliang());
        putIfPresent(row, "guancha_qingkuang", jihuaZixiang.getGuanchaQingkuang());
        putIfPresent(row, "guancha_jieguo", jihuaZixiang.getGuanchaJieguo());
        putIfPresent(row, "beizhu", jihuaZixiang.getBeizhu());
        return row;
    }

    private Map<String, Object> buildBiangengRow(LiuyangWendingxingZhouqiZixiangEntity zhouqi, Date liuyangRiqi, List<String> responseFields) {
        if (zhouqi.getZhouqi() == null) {
            throw new IllegalArgumentException("周期不能为空");
        }
        if (isBlank(zhouqi.getZhouqiDanwei())) {
            throw new IllegalArgumentException("周期单位不能为空");
        }

        Map<String, Object> row = newEmptyBiangengRow(responseFields);
        putIfPresent(row, "zhouqi", zhouqi.getZhouqi());
        putIfPresent(row, "zhouqi_danwei", zhouqi.getZhouqiDanwei());
        putIfPresent(row, "jihua_riqi", calculateJihuaRiqi(liuyangRiqi, zhouqi.getZhouqi(), zhouqi.getZhouqiDanwei()));
        putIfPresent(row, "shifou_yiguancha", "no");
        return row;
    }

    private Map<String, Object> newEmptyBiangengRow(List<String> responseFields) {
        Map<String, Object> row = new LinkedHashMap<>();
        for (String field : responseFields) {
            row.put(field, null);
        }
        return row;
    }

    private void putIfPresent(Map<String, Object> row, String field, Object value) {
        if (row.containsKey(field)) {
            row.put(field, value);
        }
    }

    private String buildZhouqiKey(BigDecimal zhouqi, String zhouqiDanwei) {
        if (zhouqi == null || isBlank(zhouqiDanwei)) {
            return "";
        }
        return zhouqi.stripTrailingZeros().toPlainString() + "|" + zhouqiDanwei.trim();
    }

    private List<String> getBiangengZixiangBusinessFields() {
        Set<String> fields = new LinkedHashSet<>();
        try (Connection connection = dataSource.getConnection()) {
            DatabaseMetaData metaData = connection.getMetaData();
            readBusinessColumns(fields, metaData, connection.getCatalog(), connection.getSchema(), BIANGENG_ZIXIANG_TABLE);
            if (fields.isEmpty()) {
                readBusinessColumns(fields, metaData, connection.getCatalog(), connection.getSchema(), BIANGENG_ZIXIANG_TABLE.toUpperCase());
            }
        } catch (Exception e) {
            log.warn("读取{}字段失败，使用默认字段", BIANGENG_ZIXIANG_TABLE, e);
        }
        if (fields.isEmpty()) {
            fields.addAll(DEFAULT_BIANGENG_ZIXIANG_FIELDS);
        }
        return new ArrayList<>(fields);
    }

    private void readBusinessColumns(Set<String> fields, DatabaseMetaData metaData, String catalog, String schema, String tableName) throws SQLException {
        try (ResultSet columns = metaData.getColumns(catalog, schema, tableName, null)) {
            while (columns.next()) {
                String columnName = columns.getString("COLUMN_NAME");
                if (!isBlank(columnName) && !columnName.toLowerCase().startsWith("f_")) {
                    fields.add(columnName);
                }
            }
        }
    }

    private Date calculateJihuaRiqi(Date shouyangRiqi, BigDecimal zhouqi, String zhouqiDanwei) {
        int amount = toIntegerZhouqi(zhouqi);
        LocalDateTime baseTime = LocalDateTime.ofInstant(shouyangRiqi.toInstant(), ZoneId.systemDefault());
        LocalDateTime jihuaTime;
        switch (zhouqiDanwei.trim()) {
            case "day":
            case "天":
                jihuaTime = baseTime.plusDays(amount);
                break;
            case "week":
            case "周":
                jihuaTime = baseTime.plusWeeks(amount);
                break;
            case "month":
            case "月":
                jihuaTime = baseTime.plusMonths(amount);
                break;
            case "quarter":
            case "季":
                jihuaTime = baseTime.plusMonths(amount * 3L);
                break;
            case "year":
            case "年":
                jihuaTime = baseTime.plusYears(amount);
                break;
            default:
                throw new IllegalArgumentException("不支持的周期单位：" + zhouqiDanwei);
        }
        return Date.from(jihuaTime.atZone(ZoneId.systemDefault()).toInstant());
    }

    private int toIntegerZhouqi(BigDecimal zhouqi) {
        try {
            return zhouqi.stripTrailingZeros().intValueExact();
        } catch (ArithmeticException e) {
            throw new IllegalArgumentException("周期必须为整数：" + zhouqi);
        }
    }

    private void updateLiuyangStatus(LimsLiuyangJiluEntity liuyangJilu, LiuyangStatus status, String bizSign) {
        LimsLiuyangJiluEntity update = new LimsLiuyangJiluEntity();
        update.setId(liuyangJilu.getId());
        update.setBizStatus(status.getCode());
        if (bizSign != null && !bizSign.isEmpty()) {
            update.setBizSign(bizSign);
        }
        limsLiuyangJiluService.updateById(update);
    }

    private void receiveLiuyangJilu(LimsLiuyangJiluEntity liuyangJilu, String bizSign) {
        LimsLiuyangJiluEntity update = new LimsLiuyangJiluEntity();
        update.setId(liuyangJilu.getId());
        update.setBizStatus(LiuyangStatus.RECEIVED.getCode());
        update.setLiuyangXiancunliang(liuyangJilu.getRukuShuliang());
        update.setLiuyangXiancunliangDanwei(liuyangJilu.getDanwei());
        if (bizSign != null && !bizSign.isEmpty()) {
            update.setBizSign(bizSign);
        }
        limsLiuyangJiluService.updateById(update);
    }

    private void softDeleteLiuyangJilu(LimsLiuyangJiluEntity liuyangJilu, String bizSign) {
        LimsLiuyangJiluEntity update = new LimsLiuyangJiluEntity();
        update.setId(liuyangJilu.getId());
        update.setDeleteMark(1);
        update.setDeleteTime(new Date());
        update.setDeleteUserId(UserProvider.getUser().getUserId());
        if (bizSign != null && !bizSign.isEmpty()) {
            update.setBizSign(bizSign);
        }
        limsLiuyangJiluService.updateById(update);
    }

    private void updateQingyandanLiuyangJiluId(LimsLiuyangJiluEntity liuyangJilu, String liuyangJiluId) {
        String qingyandanId = liuyangJilu.getQingyandanId();
        if (qingyandanId == null || qingyandanId.isEmpty()) {
            return;
        }

        LimsQingyandanEntity qingyandan = limsQingyandanService.getById(qingyandanId);
        if (qingyandan == null) {
            return;
        }

        LambdaUpdateWrapper<LimsQingyandanEntity> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.eq(LimsQingyandanEntity::getId, qingyandan.getId())
                .set(LimsQingyandanEntity::getLiuyangJiluId, liuyangJiluId);
        limsQingyandanService.update(updateWrapper);
    }

    private boolean isBlank(String value) {
        return value == null || value.trim().isEmpty();
    }
}