package com.malk.huagao.service.impl;


import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.malk.huagao.entity.*;
import com.malk.huagao.mapper.KdYdOrderDetailMapper;
import com.malk.huagao.mapper.KdYdOrderMapper;
import com.malk.huagao.mapper.KdYdOrderPaymentMapper;
import com.malk.huagao.service.IKdYdOrderService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.malk.server.aliwork.YDConf;
import com.malk.server.aliwork.YDParam;
import com.malk.server.aliwork.YDSearch;
import com.malk.server.common.McR;
import com.malk.server.dingtalk.DDR_New;
import com.malk.service.aliwork.YDClient;
import com.malk.utils.UtilMap;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.MDC;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;


import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.SimpleDateFormat;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.*;

/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @author LQY
 * @since 2025-10-15
 */
@Service
public class KdYdOrderServiceImpl extends ServiceImpl<KdYdOrderMapper, KdYdOrder> implements IKdYdOrderService {
    @Autowired
    private YDClient ydClient;
    @Autowired
    private KdYdOrderMapper kdYdOrderMapper;
    @Autowired
    private KdYdOrderDetailMapper kdYdOrderDetailMapper;
    @Autowired
    private KdYdOrderPaymentMapper kdYdOrderPaymentMapper;


    @Override
    public void insertkdYdOrder(Map map) {
        MDC.put("MDC_KEY_PID", "1003");
        String formInstId = UtilMap.getString(map, "formInstId");
        String type = UtilMap.getString(map, "type");

        if ("3".equals(type)) {
            String bm = UtilMap.getString(map, "bm");
            KdYdOrder kdYdOrder = new KdYdOrder();
            kdYdOrder.setOperationType("3");
            kdYdOrder.setSyncStatus("0");
            kdYdOrderMapper.update(kdYdOrder, new LambdaQueryWrapper<KdYdOrder>().eq(KdYdOrder::getDjbh, bm));
            return; // 或者根据你的业务逻辑返回相应的结果
        }
        if ("4".equals(type)) {
            String bm = UtilMap.getString(map, "bm");
            KdYdOrder kdYdOrder = new KdYdOrder();
            kdYdOrder.setOperationType("4");
            kdYdOrder.setSyncStatus("0");
            kdYdOrderMapper.update(kdYdOrder, new LambdaQueryWrapper<KdYdOrder>().eq(KdYdOrder::getDjbh, bm));
            return; // 或者根据你的业务逻辑返回相应的结果
        }
        DDR_New ddrNew = ydClient.queryData(YDParam.builder()
                .formInstId(formInstId)
                .build(), YDConf.FORM_QUERY.retrieve_id);
        Map formData = ddrNew.getFormData();

        String djlx = UtilMap.getString(formData, "selectField_mejowmna");
        String khmc = UtilMap.getString(formData, "textField_mejnamf2");
        String djbh = UtilMap.getString(formData, "textField_mjs6fuwo");
        if("2".equals(type)){
             djbh = UtilMap.getString(formData, "textField_mjs6fuwo");
        }
        LocalDateTime rq = parseTimestamp(UtilMap.getString(formData, "dateField_mejowmnb"));
        String khxypj = UtilMap.getString(formData, "selectField_mewirdx4");
        String ywlx = UtilMap.getString(formData, "textField_mfxv2vfz");
        String xsy = UtilMap.getString(formData, "employeeField_mejowmng").replace("[\"", "").replace("\"]", "").trim();
        String xslx = UtilMap.getString(formData, "selectField_mejowmnc");
        String bzq = UtilMap.getString(formData, "selectField_mf6gyfkq");
        String xsbm = UtilMap.getString(formData, "departmentSelectField_mfxv2vfu").replace("[\"", "").replace("\"]", "").trim();
        String bz = UtilMap.getString(formData, "textareaField_mejnamfb");
        String jsbb = UtilMap.getString(formData, "selectField_mejowmnk");
        String sktj = UtilMap.getString(formData, "selectField_mgisux07");
        String zdzkestr = UtilMap.getString(formData, "numberField_mejowmni");
        BigDecimal zdzke = toBigDecimal(zdzkestr);
//        String fj = UtilMap.getString(formData, "attachmentField_mfoqcctz");
//        JSONArray array = JSONObject.parseArray(fj);
//        List<String> resultList = new ArrayList<>();
//        if(array != null){
//            for (int i = 0; i < array.size(); i++) {
//                JSONObject jsonObject = array.getJSONObject(i);
//                String url = jsonObject.getString("url");
//                String s = ydClient.convertTemporaryUrl(url, 3600000);
//                resultList.add(s);
//            }
//        }
//        if(StringUtils.isNotBlank(fj)){
//            List<Map> fjList =(List<Map>) JSON.parse(fj);
//            resultList.add(ydClient.convertTemporaryUrl(UtilMap.getString(fjList.get(0),"url"), 3600000));
//        }
        String sestr = UtilMap.getString(formData, "numberField_mfxv2vgh");
        BigDecimal se = toBigDecimal(sestr);
        String jestr = UtilMap.getString(formData, "numberField_mfxv2vgj");
        BigDecimal je = toBigDecimal(jestr);
        String jshjstr = UtilMap.getString(formData, "numberField_mewfgzkv");
        BigDecimal jshj = toBigDecimal(jshjstr);
        String sfhs = UtilMap.getString(formData, "radioField_mfxv2vg4");
        String jws = UtilMap.getString(formData, "radioField_mfxv2vgm");
        List<Map> tableField = (List<Map>) formData.get("tableField_mfbx1pqi");
        List<Map> tableFieldPayment = (List<Map>) formData.get("tableField_mhiui6v5");

        KdYdOrder kdYdOrder = new KdYdOrder();
        kdYdOrder.setDjlx(djlx);
        kdYdOrder.setDjbh(djbh);
        kdYdOrder.setKhmc(khmc);
        kdYdOrder.setRq(rq);
        kdYdOrder.setKhxypj(khxypj);
        kdYdOrder.setYwlx(ywlx);
        kdYdOrder.setXslx(xslx);
        kdYdOrder.setBzq(bzq);
        kdYdOrder.setXsy(xsy);
        kdYdOrder.setXsbm(xsbm);
        kdYdOrder.setBz(bz);
        kdYdOrder.setJsbb(jsbb);
        kdYdOrder.setSktj(sktj);
        kdYdOrder.setZdzke(zdzke);
        kdYdOrder.setSe(se);
        kdYdOrder.setJe(je);
        kdYdOrder.setJshj(jshj);
        kdYdOrder.setSfhs(sfhs);
        kdYdOrder.setJws(jws);
        kdYdOrder.setSyncStatus("0");

        Long id;
        if ("2".equals(type)) {
            // 查询已存在的订单
            KdYdOrder existing = kdYdOrderMapper.selectOne(
                    new LambdaQueryWrapper<KdYdOrder>().eq(KdYdOrder::getDjbh, djbh)
            );
            if (existing == null) {
                throw new IllegalArgumentException("无法更新订单：单据编号 [" + djbh + "] 不存在");
            }
            id = existing.getId();
            kdYdOrder.setId(id);
            kdYdOrder.setOperationType("2");
            kdYdOrderMapper.updateById(kdYdOrder); // 使用 updateById 更安全
        } else {
            kdYdOrder.setOperationType("1");
            kdYdOrderMapper.insert(kdYdOrder);
            id = kdYdOrder.getId(); // MyBatis-Plus 会自动回填主键
        }

// ====== 1. 获取数据库中当前 orderId 的所有明细（用于后续对比删除）======
        LambdaQueryWrapper<KdYdOrderDetail> existingWrapper = new LambdaQueryWrapper<>();
        existingWrapper.eq(KdYdOrderDetail::getOrderId, id);
        List<KdYdOrderDetail> existingDetails = kdYdOrderDetailMapper.selectList(existingWrapper);
        Set<Integer> incomingDetailIds = new HashSet<>(); // 用于记录本次传入的 detailId

// ====== 2. 遍历传入的 tableField，逐条处理 ======
        if (tableField != null) {
//            for (Map item : tableField) {
//                int detailId = parseInt(safeGetString(item, "indexField"), 0); // 建议前端传一个明确的 index 或 detailId 字段
//                // 如果前端没有显式传 detailId，可以用循环计数（但需注意顺序稳定性）
//                // 这里假设你用 count 作为 detailId（与前端一致）
//                // 若前端表格支持拖拽/乱序，建议传唯一行ID，但你当前用的是序号，我们继续用 count
//
//                // 注意：你原代码用 count++，这里我们改用从数据中获取或维持顺序
//                // 为兼容你原有逻辑，我们仍用递增序号，但更推荐前端传 detailId
//            }

            // 重新遍历，使用 index 作为 detailId
            for (int i = 0; i < tableField.size(); i++) {
                Map item = tableField.get(i);
                int detailId = parseInt(safeGetString(item, "numberField_mjzfodew"), 0);
                incomingDetailIds.add(detailId);

                String wlbm = safeGetString(item, "textField_mfbx1pqt");
                String wlmc = safeGetString(item, "textField_mfbx1pqs");
                String ggxh = safeGetString(item, "textField_mfbx1pqr");
                String xsdw = safeGetString(item, "textField_mfbx1pqq");
                int xssl = parseInt(safeGetString(item, "numberField_mfbx1pr4"), 0);
                String ssxl = safeGetString(item, "selectField_mfbx1pr1");
                BigDecimal dj = toBigDecimal(safeGetString(item, "numberField_mfbx1prf"));
                BigDecimal cxzkje = toBigDecimal(safeGetString(item, "numberField_mk56soin"));
                BigDecimal hsdj = toBigDecimal(safeGetString(item, "numberField_mfbx1prg"));
                String sfzp = safeGetString(item, "radioField_mfbx1prc");
                String bz1 = safeGetString(item, "textareaField_mjryuaok");
                int sl = parseInt(safeGetString(item, "numberField_mfbx1prb"), 0);
                BigDecimal zse = toBigDecimal(safeGetString(item, "numberField_mfbx1prh"));
                BigDecimal zje = toBigDecimal(safeGetString(item, "numberField_mfbx1pri"));
                BigDecimal zjshj = toBigDecimal(safeGetString(item, "numberField_mfbx1prj"));
                BigDecimal jj = toBigDecimal(safeGetString(item, "numberField_mfbx1prk"));
                BigDecimal zkl = toBigDecimal(safeGetString(item, "numberField_mfbx1pru"));
                BigDecimal zke = toBigDecimal(safeGetString(item, "numberField_mfbx1prt"));
                LocalDateTime yhrq = parseTimestamp(UtilMap.getString(item, "dateField_mfbx1prs"));
                BigDecimal xsjzj = toBigDecimal(safeGetString(item, "numberField_mfbx1pr0"));
                String zmzs = safeGetString(item, "textField_mfxv2vgv");

                // 查询是否已存在
                LambdaQueryWrapper<KdYdOrderDetail> queryWrapper = new LambdaQueryWrapper<>();
                queryWrapper.eq(KdYdOrderDetail::getOrderId, id)
                        .eq(KdYdOrderDetail::getDetailId, detailId);
                KdYdOrderDetail existing = kdYdOrderDetailMapper.selectOne(queryWrapper);

                if (existing != null) {
                    // 更新
                    existing.setWlbm(wlbm);
                    existing.setWlmc(wlmc);
                    existing.setGgxh(ggxh);
                    existing.setXsdw(xsdw);
                    existing.setXssl(xssl);
                    existing.setSsxl(ssxl);
                    existing.setCxzkje(cxzkje);
                    existing.setDj(dj);
                    existing.setHsdj(hsdj);
                    existing.setSfzp(sfzp);
                    existing.setSl(sl);
                    existing.setBz(bz1);
                    existing.setSe(zse);
                    existing.setJe(zje);
                    existing.setJshj(zjshj);
                    existing.setJj(jj);
                    existing.setZkl(zkl);
                    existing.setZke(zke);
                    existing.setYhrq(yhrq);
                    existing.setXsjzj(xsjzj);
                    existing.setSmzs(zmzs);
                    existing.setSyncStatus("0");
                    existing.setOperationType(type); // 注意：type 决定是 insert(1) 还是 update(2/3)

                    kdYdOrderDetailMapper.updateById(existing);
                } else {
                    // 新增
                    KdYdOrderDetail kdYdOrderDetail = new KdYdOrderDetail();
                    kdYdOrderDetail.setOrderId(id);
                    kdYdOrderDetail.setDetailId(detailId);
                    kdYdOrderDetail.setWlbm(wlbm);
                    kdYdOrderDetail.setCxzkje(cxzkje);
                    kdYdOrderDetail.setWlmc(wlmc);
                    kdYdOrderDetail.setGgxh(ggxh);
                    kdYdOrderDetail.setXsdw(xsdw);
                    kdYdOrderDetail.setXssl(xssl);
                    kdYdOrderDetail.setSsxl(ssxl);
                    kdYdOrderDetail.setDj(dj);
                    kdYdOrderDetail.setHsdj(hsdj);
                    kdYdOrderDetail.setSfzp(sfzp);
                    kdYdOrderDetail.setSl(sl);
                    kdYdOrderDetail.setSe(zse);
                    kdYdOrderDetail.setJe(zje);
                    kdYdOrderDetail.setBz(bz1);
                    kdYdOrderDetail.setJshj(zjshj);
                    kdYdOrderDetail.setJj(jj);
                    kdYdOrderDetail.setZkl(zkl);
                    kdYdOrderDetail.setZke(zke);
                    kdYdOrderDetail.setYhrq(yhrq);
                    kdYdOrderDetail.setXsjzj(xsjzj);
                    kdYdOrderDetail.setSmzs(zmzs);
                    kdYdOrderDetail.setSyncStatus("0");
                    kdYdOrderDetail.setOperationType("1"); // 新增始终是 1

                    kdYdOrderDetailMapper.insert(kdYdOrderDetail);
                }
            }
        }

// ====== 3. 删除数据库中存在但本次未传入的明细 ======
        for (KdYdOrderDetail existing : existingDetails) {
            if (!incomingDetailIds.contains(existing.getDetailId())) {
                kdYdOrderDetailMapper.deleteById(existing.getId());
                // 或者软删除：update sync_status = '9' 等
            }
        }

// ====== 处理付款计划子表（KdYdOrderPayment）======

// 1. 查询数据库中当前 orderId 下所有已存在的付款记录
        LambdaQueryWrapper<KdYdOrderPayment> paymentExistingWrapper = new LambdaQueryWrapper<>();
        paymentExistingWrapper.eq(KdYdOrderPayment::getOrderId, id);
        List<KdYdOrderPayment> existingPayments = kdYdOrderPaymentMapper.selectList(paymentExistingWrapper);
        Set<Integer> incomingPaymentDetailIds = new HashSet<>();

        if (tableFieldPayment != null) {
            for (int i = 0; i < tableFieldPayment.size(); i++) {
                Map row = tableFieldPayment.get(i);
                int detailId = i + 1; // 使用 1-based 序号作为 detailId（需与前端表格顺序一致）
                incomingPaymentDetailIds.add(detailId);

                String sfys = safeGetString(row, "radioField_mhiui6v7");
                String gldh = safeGetString(row, "textField_mhiui6va");
                BigDecimal ysbl = toBigDecimal(UtilMap.getString(row, "numberField_mhiui6v6"));
                BigDecimal ysje = toBigDecimal(UtilMap.getString(row, "numberField_mhiui6v8"));
                BigDecimal ssje = toBigDecimal(UtilMap.getString(row, "numberField_mhiui6vb"));
                LocalDateTime endTime = parseTimestamp(UtilMap.getString(row, "dateField_mhiui6v9"));

                // 查询是否已存在该 (orderId, detailId)
                LambdaQueryWrapper<KdYdOrderPayment> queryWrapper = new LambdaQueryWrapper<>();
                queryWrapper.eq(KdYdOrderPayment::getOrderId, id)
                        .eq(KdYdOrderPayment::getDetailId, detailId);
                KdYdOrderPayment existingPayment = kdYdOrderPaymentMapper.selectOne(queryWrapper);

                if (existingPayment != null) {
                    // 更新
                    existingPayment.setSfys(sfys);
                    existingPayment.setGldh(gldh);
                    existingPayment.setYsbl(ysbl);
                    existingPayment.setYsje(ysje);
                    existingPayment.setSsje(ssje);
                    existingPayment.setEndTime(endTime);
                    existingPayment.setSyncStatus("0");
                    existingPayment.setOperationType(type); // 使用传入的 type（"2" 或 "3"）

                    kdYdOrderPaymentMapper.updateById(existingPayment);
                } else {
                    // 新增
                    KdYdOrderPayment payment = new KdYdOrderPayment();
                    payment.setOrderId(id);
                    payment.setDetailId(detailId);
                    payment.setSfys(sfys);
                    payment.setGldh(gldh);
                    payment.setYsbl(ysbl);
                    payment.setYsje(ysje);
                    payment.setSsje(ssje);
                    payment.setEndTime(endTime);
                    payment.setSyncStatus("0");
                    payment.setOperationType("1"); // 新增操作类型为 "1"

                    kdYdOrderPaymentMapper.insert(payment);
                }
            }
        }

// 3. 删除数据库中存在但本次未传入的付款记录
        for (KdYdOrderPayment existing : existingPayments) {
            if (!incomingPaymentDetailIds.contains(existing.getDetailId())) {
                kdYdOrderPaymentMapper.deleteById(existing.getId());
                // 或软删除：existing.setSyncStatus("9"); updateById
            }
        }
//        ydClient.operateData(
//                YDParam.builder()
//                        .formInstanceId(formInstId)
//                        .updateFormDataJson(JSONObject.toJSONString(UtilMap.map("textField_mgrmn66f", id)))
//                        .useLatestVersion(true).build(), YDConf.FORM_OPERATION.update);

    }

    @Override
    public void SckdYdOrder(Map map) {
        MDC.put("MDC_KEY_PID", "1003");

        try {
            String formInstId = UtilMap.getString(map, "formInstId");
            String khbm = UtilMap.getString(map, "khbm");

            // 1. 查询订单详情
            DDR_New ddrNew = ydClient.queryData(YDParam.builder()
                    .formInstId(formInstId)
                    .build(), YDConf.FORM_QUERY.retrieve_id);

            if (ddrNew == null || ddrNew.getFormData() == null) {
                throw new RuntimeException("未找到订单信息");
            }

            Map formData1 = ddrNew.getFormData();
            String ddje = UtilMap.getString(formData1, "numberField_mfxv2vgj");

            // 参数校验
            if (ddje == null || ddje.trim().isEmpty()) {
                throw new RuntimeException("订单金额不能为空");
            }

            // 2. 计算订单金额（保留两位小数）
            Double orderAmount = null;
            try {
                orderAmount = Double.parseDouble(ddje);
                orderAmount = Math.round(orderAmount * 100.0) / 100.0;
            } catch (NumberFormatException e) {
                throw new RuntimeException("订单金额格式错误: " + ddje);
            }

            // 3. 查询客户历史信息
            List<Map> list = (List<Map>) ydClient.queryData(YDParam.builder()
                    .formUuid("FORM-F79B680547674A6BBD11C0D511E3C14B28FY")
                    .searchFieldJson(JSONObject.toJSONString(Arrays.asList(
                            new YDSearch("textField_mjm9k35n",
                                    khbm,
                                    "客户编号",
                                    YDSearch.Type.TEXT_FIELD,
                                    YDSearch.Operator.EQ)
                    )))
                    .build(), YDConf.FORM_QUERY.retrieve_list_all).getData();

            if (list == null || list.isEmpty()) {
                throw new RuntimeException("未找到客户信息，客户编号：" + khbm);
            }

            // 4. 获取客户现有信息
            Map customerData = list.get(0);
            Double historicalAmount = UtilMap.getDouble(customerData, "numberField_mjm9k35k");
            String dddateTimestampStr = UtilMap.getString(customerData, "dateField_mjqkkcsg");
            String sfdateTimestampStr = UtilMap.getString(customerData, "dateField_mjm9k35l");

            // 参数校验
            if (dddateTimestampStr == null || dddateTimestampStr.trim().isEmpty()) {
                throw new RuntimeException("最后成交日期不能为空");
            }

            // 处理历史金额
            if (historicalAmount == null) {
                historicalAmount = 0.0;
            } else {
                historicalAmount = Math.round(historicalAmount * 100.0) / 100.0;
            }

            // 5. 计算总金额
            Double totalAmount = orderAmount + historicalAmount;
            totalAmount = Math.round(totalAmount * 100.0) / 100.0;

            System.out.println("金额计算：订单金额=" + orderAmount +
                    ", 历史金额=" + historicalAmount +
                    ", 总金额=" + totalAmount);

            // 6. 时间戳转换
            long dddateTimestamp = Long.parseLong(dddateTimestampStr.trim());
            long currentTimestamp = System.currentTimeMillis();
            long sfdateTimestamp = (sfdateTimestampStr != null && !sfdateTimestampStr.trim().isEmpty())
                    ? Long.parseLong(sfdateTimestampStr.trim()) : 0;

            // 计算时间差（天数）
            long currentToDdDays = (currentTimestamp - dddateTimestamp) / (1000 * 60 * 60 * 24);
            long sfToDdDays = (sfdateTimestamp > 0) ? (sfdateTimestamp - dddateTimestamp) / (1000 * 60 * 60 * 24) : 0;

            System.out.println("时间计算：当前时间-" + timestampToDateString(String.valueOf(currentTimestamp)) +
                    ", 成交日期-" + timestampToDateString(dddateTimestampStr) +
                    ", 当前-成交相差=" + currentToDdDays + "天" +
                    ", 公海-成交相差=" + sfToDdDays + "天");

            String ghcDateTimestamp = null;
            String selectFieldValue = "";
            String khsx = "";

// 1. 设置客户属性（单独判断）
            if(totalAmount >= 75000 && sfToDdDays <= 180){
                khsx = "自行开发";
            }

// 2. 第一个条件：当前时间-成交日期<90天 且 总金额>0 且 公海日期-成交日期≈180天
            if (currentToDdDays < 90 && totalAmount > 0 && Math.abs(sfToDdDays - 180) <= 1) {
                // 在成交日期上加90天
                ghcDateTimestamp = String.valueOf(calculateTimestamp(sfdateTimestamp, 90));
                selectFieldValue = "半年金额不足";
                System.out.println("条件1触发：公海池时间设为成交日期+90天=" +
                        timestampToDateString(ghcDateTimestamp));
            }
// 3. 第二个条件：总金额≥7.5万 且 公海日期-成交日期≤180天
            else if (totalAmount >= 75000 && sfToDdDays <= 180) {
                // 在成交日期上加180天
                ghcDateTimestamp = String.valueOf(calculateTimestamp(sfdateTimestamp, 180));
                selectFieldValue = "半年金额不足";
                System.out.println("条件2触发：公海池时间设为成交日期+180天=" +
                        timestampToDateString(ghcDateTimestamp));
            }
// 4. 第三个条件：金额<15万 且 公海日期-成交日期>180天
            else if (totalAmount < 150000 && sfToDdDays > 180) {
                selectFieldValue = "一年金额不足";
                System.out.println("条件3触发：金额<15万且公海日期>180天，设置一年金额不足");
            }
// 5. 其他情况
            else {
                if (totalAmount > 0) {
                    // 基础情况：金额大于0
                    ghcDateTimestamp = String.valueOf(calculateTimestamp(sfdateTimestamp, 90));
                    selectFieldValue = "半年金额不足";
                    System.out.println("基础情况：金额大于0，公海池时间+90天=" +
                            timestampToDateString(ghcDateTimestamp));
                } else if (totalAmount < 75000) {
                    // 金额 < 7.5万
                    selectFieldValue = "半年金额不足";
                    System.out.println("金额<7.5万，但未设置公海池时间");
                } else if (totalAmount < 150000) {
                    // 7.5万 ≤ 金额 < 15万
                    selectFieldValue = "一年金额不足";
                    System.out.println("金额7.5-15万，但未设置公海池时间");
                }
            }


            // 8. 构建更新数据
            Map<String, Object> formData = new HashMap<>();
            formData.put("dateField_mjm9k35j", dddateTimestampStr); // 最后成交日期（保持原时间戳）

            // 只有selectField有值时才设置
            if (!selectFieldValue.isEmpty()) {
                formData.put("selectField_l3nrjuq0", selectFieldValue);
            }

            if (ghcDateTimestamp != null) {
                formData.put("dateField_mjm9k35l", ghcDateTimestamp); // 释放公海日期
            } else {
                formData.put("dateField_mjm9k35l", ""); // 明确设置为空
            }

            // 更新累计金额（保留两位小数）
            formData.put("numberField_mjm9k35k", totalAmount);
            formData.put("selectField_mjsco9d4", khsx);

            System.out.println("更新客户数据：" + formData);

            // 9. 执行更新操作
            ydClient.operateData(YDParam.builder()
                    .formUuid("FORM-F79B680547674A6BBD11C0D511E3C14B28FY")
                    .appType("APP_VQDMMWS6OR1VHL8VMFD3")
                    .systemToken("XE766X81JHKXK4Z27SYOI86CPCLQ3J1LV7ODMH2")
                    .noExecuteExpression(false)
                    .searchFieldJson(JSONObject.toJSONString(Arrays.asList(
                            new YDSearch("textField_mjm9k35n",
                                    khbm,
                                    "客户编号",
                                    YDSearch.Type.TEXT_FIELD,
                                    YDSearch.Operator.EQ)
                    )))
                    .formDataJson(JSONObject.toJSONString(formData))
                    .build(), YDConf.FORM_OPERATION.upsert);

            System.out.println("客户信息更新成功，客户编号：" + khbm);

        } catch (Exception e) {
            System.err.println("处理订单失败: " + e.getMessage());
            e.printStackTrace();
            throw new RuntimeException("处理订单失败: " + e.getMessage(), e);
        } finally {
            MDC.remove("MDC_KEY_PID");
        }
    }

    /**
     * 计算时间戳：在基础时间戳上添加天数
     * @param baseTimestamp 基础时间戳（毫秒）
     * @param days 要添加的天数
     * @return 计算后的时间戳（毫秒）
     */
    private long calculateTimestamp(long baseTimestamp, int days) {
        try {
            long oneDayMillis = 24L * 60L * 60L * 1000L;
            long daysMillis = (long) days * oneDayMillis;
            return baseTimestamp + daysMillis;
        } catch (Exception e) {
            System.err.println("时间戳计算失败：" + baseTimestamp + ", 天数：" + days);
            return baseTimestamp + (days * 24L * 60L * 60L * 1000L);
        }
    }

    /**
     * 辅助方法：将时间戳转换为可读日期（仅用于调试）
     */
    private String timestampToDateString(String timestamp) {
        try {
            long ts = Long.parseLong(timestamp.trim());
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            return sdf.format(new Date(ts));
        } catch (Exception e) {
            return "无效时间戳：" + timestamp;
        }
    }

    /**
     * 重载方法：直接接收long类型时间戳
     */
    private String timestampToDateString(long timestamp) {
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            return sdf.format(new Date(timestamp));
        } catch (Exception e) {
            return "无效时间戳：" + timestamp;
        }
    }

    private static LocalDateTime parseTimestamp(String timestampStr) {
        if (timestampStr == null || timestampStr.trim().isEmpty()) return null;
        try {
            long timestamp = Long.parseLong(timestampStr.trim());
            return LocalDateTime.ofInstant(
                    Instant.ofEpochMilli(timestamp),
                    ZoneId.systemDefault()
            );
        } catch (NumberFormatException e) {
            return null;
        }
    }

    private static int parseInt(String str, int defaultValue) {
        if (str == null || str.trim().isEmpty()) {
            return defaultValue;
        }
        try {
            return Integer.parseInt(str.trim());
        } catch (NumberFormatException e) {
            return defaultValue;
        }
    }

    private String safeGetString(Map formData, String key) {
        Object val = formData.get(key);
        return val == null ? "" : String.valueOf(val);
    }

    public static BigDecimal toBigDecimal(String str) {
        if (str == null || str.trim().isEmpty()) {
            return BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP);
        }
        try {
            return new BigDecimal(str.trim())
                    .setScale(2, RoundingMode.HALF_UP);
        } catch (NumberFormatException e) {
            // 返回默认值而不是抛出异常，避免程序中断
            return BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP);
        }
    }

    /**
     * 重载方法，支持Number类型输入
     */
    public static BigDecimal toBigDecimal(Number number) {
        if (number == null) {
            return BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP);
        }
        return new BigDecimal(number.toString())
                .setScale(2, RoundingMode.HALF_UP);
    }
}