package com.malk.service.sync;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.malk.model.H3yunResponse;
import com.malk.model.KingdeeSaveResponse;
import com.malk.model.WangdianResponse;
import com.malk.service.h3yun.H3yunService;
import com.malk.service.kingdee.KingdeeService;
import com.malk.service.wangdian.WangdianService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import cn.hutool.core.util.StrUtil;

import java.text.SimpleDateFormat;
import java.util.*;

/**
 * 数据同步服务
 *
 * 功能说明：实现三大系统之间的数据同步逻辑
 *
 * 同步方向：
 * 1. 氚云 -> 金蝶：API主动推送
 * 2. 金蝶 -> 氚云：Webhook事件触发
 * 3. 氚云 -> 旺店通：定时任务/触发推送
 *
 * 异常处理机制（需求文档4.1）：
 * - 重试机制：网络超时或返回"系统繁忙"时，采用指数退避重试（1s, 5s, 30s）
 * - 日志记录：所有接口调用记录完整请求报文和响应报文
 *
 * 幂等性设计（需求文档4.2）：
 * - 金蝶 -> 氚云：利用单据编号查询氚云是否已存在，防止重复写入
 * - 氚云 -> 金蝶：利用金蝶Save接口"编码相同即修改"特性，保证数据不重复
 */
@Service
public class SyncService {

    private static final Logger log = LoggerFactory.getLogger(SyncService.class);

    @Autowired
    private KingdeeService kingdeeService;

    @Autowired
    private H3yunService h3yunService;

    @Autowired
    private WangdianService wangdianService;

    // ==================== Webhook数据解析辅助方法 ====================

    /**
     * 从webhook数据中获取单据详情
     * 如果webhookData为空，则调用Kingdee API查询
     */
    private JSONObject getBillDetailFromWebhook(JSONObject webhookData, String formId, String billNo) {
        if (webhookData != null) {
            JSONObject data = webhookData.getJSONObject("data");
            if (data != null) {
                log.info("使用webhook数据, billNo: {}", billNo);
                return data;
            }
        }
        // fallback: 调用API查询
        log.info("webhook数据为空，调用API查询, formId: {}, billNo: {}", formId, billNo);
        return kingdeeService.queryBillDetail(formId, billNo);
    }

    /**
     * 从单据明细中计算总数量
     */
    private Integer getTotalQtyFromBillEntry(JSONObject billDetail) {
        JSONArray entryArray = billDetail.getJSONArray("billentry");
        if (entryArray != null && !entryArray.isEmpty()) {
            double totalQty = 0;
            for (int i = 0; i < entryArray.size(); i++) {
                JSONObject entry = entryArray.getJSONObject(i);
                Double qty = entry.getDouble("qty");
                if (qty != null) {
                    totalQty += qty;
                }
            }
            return (int) totalQty;
        }
        return 0;
    }

    // ==================== 氚云 -> 金蝶同步 ====================

    /**
     * 同步供应商档案到金蝶
     */
    public KingdeeSaveResponse syncSupplierToKingdee(String code, String name, String createOrgId,
                                                     String useOrgId, String creditCode) {
        try {
            Map<String, Object> data = new HashMap<>();
            data.put("code", code);
            data.put("name", name);
            data.put("createOrgId", createOrgId);
            data.put("useOrgId", useOrgId);
            data.put("creditCode", creditCode);

            return kingdeeService.saveSupplier(data);
        } catch (Exception e) {
            log.error("同步供应商档案到金蝶异常, code: {}", code, e);
            throw e;
        }
    }

    /**
     * 同步客户档案到金蝶
     */
    public KingdeeSaveResponse syncCustomerToKingdee(String code, String name, String group, String taxNo) {
        try {
            Map<String, Object> data = new HashMap<>();
            data.put("code", code);
            data.put("name", name);
            data.put("group", group);
            data.put("taxNo", taxNo);

            return kingdeeService.saveCustomer(data);
        } catch (Exception e) {
            log.error("同步客户档案到金蝶异常, code: {}", code, e);
            throw e;
        }
    }

    /**
     * 同步物料档案到金蝶
     */
    public KingdeeSaveResponse syncMaterialToKingdee(String code, String name, String baseUnitId,
                                                     String materialGroup, String createOrgId) {
        try {
            Map<String, Object> data = new HashMap<>();
            data.put("code", code);
            data.put("name", name);
            data.put("baseUnitId", baseUnitId);
            data.put("materialGroup", materialGroup);
            data.put("createOrgId", createOrgId);

            return kingdeeService.saveMaterial(data);
        } catch (Exception e) {
            log.error("同步物料档案到金蝶异常, code: {}", code, e);
            throw e;
        }
    }

    /**
     * 同步仓库档案到金蝶
     */
    public KingdeeSaveResponse syncStockToKingdee(String code, String name, String useOrgId, String stockProperty) {
        try {
            Map<String, Object> data = new HashMap<>();
            data.put("code", code);
            data.put("name", name);
            data.put("useOrgId", useOrgId);
            data.put("stockProperty", stockProperty);

            return kingdeeService.saveStock(data);
        } catch (Exception e) {
            log.error("同步仓库档案到金蝶异常, code: {}", code, e);
            throw e;
        }
    }

    /**
     * 同步采购申请单到金蝶
     */
    public KingdeeSaveResponse syncPurchaseRequisitionToKingdee(String applicationOrgId, String date,
                                                                String materialId, Double reqQty) {
        try {
            Map<String, Object> data = new HashMap<>();
            data.put("applicationOrgId", applicationOrgId);
            data.put("date", date);
            data.put("materialId", materialId);
            data.put("reqQty", reqQty);

            return kingdeeService.savePurchaseRequisition(data);
        } catch (Exception e) {
            log.error("同步采购申请单到金蝶异常", e);
            throw e;
        }
    }

    /**
     * 同步销售订单到金蝶
     */
    public KingdeeSaveResponse syncSaleOrderToKingdee(String saleOrgId, String customerId,
                                                      String materialId, Double qty) {
        try {
            Map<String, Object> data = new HashMap<>();
            data.put("saleOrgId", saleOrgId);
            data.put("customerId", customerId);
            data.put("materialId", materialId);
            data.put("qty", qty);

            return kingdeeService.saveSaleOrder(data);
        } catch (Exception e) {
            log.error("同步销售订单到金蝶异常", e);
            throw e;
        }
    }

    /**
     * 全量同步金蝶银行行名行号到氚云表
     * - F0000001: union_number
     * - F0000002: name
     * - F0000004: 默认“可用”
     */
    public Map<String, Object> syncKingdeeBankListToH3yun() {
        Map<String, Object> result = new LinkedHashMap<>();
        String startCreateTime = "2024-08-05 16:42:32";
        int pageNo = 1;
        int pageSize = 200;
        boolean lastPage = false;
        int totalRows = 0;
        int successCount = 0;
        int failCount = 0;
        List<String> errors = new ArrayList<>();

        result.put("startCreateTime", startCreateTime);

        while (!lastPage) {
            JSONObject pageResult = kingdeeService.getBankList(startCreateTime, pageNo, pageSize);
            JSONObject data = pageResult.getJSONObject("data");
            if (data == null) {
                break;
            }

            JSONArray rows = data.getJSONArray("rows");
            int currentRowCount = rows == null ? 0 : rows.size();
            totalRows += currentRowCount;
            log.info("开始同步金蝶银行行名行号第 {} 页, 本页 {} 条", pageNo, currentRowCount);

            if (rows != null) {
                for (int i = 0; i < rows.size(); i++) {
                    JSONObject row = rows.getJSONObject(i);
                    try {
                        String unionNumber = row.getString("union_number");
                        String name = row.getString("name");

                        if (StrUtil.isBlank(unionNumber)) {
                            failCount++;
                            errors.add(String.format("跳过银行行名行号：name=%s，union_number为空", name));
                            continue;
                        }

                        String existingObjectId = findExistingBankObjectId(unionNumber);

                        Map<String, Object> formData = new LinkedHashMap<>();
                        formData.put("F0000001", unionNumber);
                        formData.put("F0000002", name);
                        formData.put("F0000004", "可用");

                        if (StrUtil.isNotBlank(existingObjectId)) {
                            h3yunService.updateFormData("D293655sn1gizwncl0ulfdqwcll", existingObjectId, formData);
                        } else {
                            h3yunService.createBizObject("D293655sn1gizwncl0ulfdqwcll", formData);
                        }
                        successCount++;
                    } catch (Exception e) {
                        failCount++;
                        errors.add("处理银行行名行号异常: " + e.getMessage());
                        log.error("同步银行行名行号到氚云异常, row: {}", row.toJSONString(), e);
                    }
                }
            }

            Boolean pageLast = data.getBoolean("lastPage");
            lastPage = Boolean.TRUE.equals(pageLast);
            if (pageLast == null && currentRowCount < pageSize) {
                lastPage = true;
            }
            pageNo++;
        }

        result.put("totalRows", totalRows);
        result.put("success", failCount == 0);
        result.put("successCount", successCount);
        result.put("failCount", failCount);
        result.put("errors", errors);
        return result;
    }

    private String findExistingBankObjectId(String unionNumber) {
        String filter = String.format("F0000001 = '%s'", unionNumber);
        JSONObject result = h3yunService.queryBizObjects("D293655sn1gizwncl0ulfdqwcll", filter, 1, 0);
        JSONObject returnData = result.getJSONObject("ReturnData");
        if (returnData != null) {
            JSONArray bizObjectArray = returnData.getJSONArray("BizObjectArray");
            if (bizObjectArray != null && !bizObjectArray.isEmpty()) {
                return bizObjectArray.getJSONObject(0).getString("ObjectId");
            }
        }
        return null;
    }

    /**
     * 全量同步金蝶库存汇总到氚云分仓库存表
     * 默认映射：
     * - F0000100: 物料ID（按K3 material主数据ID匹配氚云物料表）
     * - F0000106: 物料编码
     * - F0000101: 仓库ID（按仓库编码匹配氚云仓库表）
     * - F0000102: 默认0
     * - F0000105: 库存数量 qty
     * - F0000104: 可用数量 avbqty
     */
    public Map<String, Object> syncKingdeeInventorySumToH3yun() {
        Map<String, Object> result = new LinkedHashMap<>();
        List<String> orgList = getEnabledInventoryOrgList();
        result.put("orgList", orgList);

        if (orgList.isEmpty()) {
            result.put("success", false);
            result.put("totalRows", 0);
            result.put("successCount", 0);
            result.put("failCount", 0);
            result.put("errors", Collections.singletonList("未查询到可用的库存组织编码"));
            return result;
        }

        int totalRows = 0;
        int successCount = 0;
        int failCount = 0;
        List<String> errors = new ArrayList<>();

        for (String org : orgList) {
            try {
                List<JSONObject> rows = kingdeeService.getAllInventorySumRows(org, 100);
                totalRows += rows.size();
                log.info("开始同步库存组织 {}, 共 {} 条库存汇总数据", org, rows.size());

                for (JSONObject row : rows) {
                    try {
                        String materialK3Id = row.getString("material");
                        String materialNumber = row.getString("material.number");
                        String warehouseNumber = row.getString("warehouse.number");
                        String qty = row.getString("qty");
                        String avbqty = row.getString("avbqty");

                        String materialObjectId = h3yunService.getObjectIdByFieldValue(
                                "D293655fc1a38f7956f400a886f376911a54a30", "K3id", materialK3Id);
                        String warehouseObjectId = h3yunService.getObjectIdByFieldValue(
                                "D293655scvrhqr64jemxdkqk6gf", "SeqNo", warehouseNumber);
                        String orgID = h3yunService.getObjectIdByFieldValue(
                                "D29365537feb4e5e8644b21b7fd938dd322dab3", "F0000002", org);
                        if (StrUtil.isBlank(materialObjectId) || StrUtil.isBlank(warehouseObjectId)) {
                            failCount++;
                            errors.add(String.format("跳过库存行：org=%s material=%s warehouse=%s，氚云档案未匹配", org, materialNumber, warehouseNumber));
                            continue;
                        }

                        String existingObjectId = findExistingStockDetailObjectId(orgID, materialObjectId, warehouseObjectId);

                        Map<String, Object> formData = new LinkedHashMap<>();
                        formData.put("F0000102", org);
                        formData.put("F0000100", materialObjectId);
                        formData.put("F0000106", materialNumber);
                        formData.put("F0000101", warehouseObjectId);
                        formData.put("F0000105", parseDecimalOrZero(qty));
                        formData.put("F0000104", parseDecimalOrZero(avbqty));
                        formData.put("F0000107", orgID);

                        if (StrUtil.isNotBlank(existingObjectId)) {
                            h3yunService.updateFormData("D293655sukswvxwuqus2tdbygynr", existingObjectId, formData);
                        } else {
                            h3yunService.createBizObject("D293655sukswvxwuqus2tdbygynr", formData);
                        }
                        successCount++;
                    } catch (Exception e) {
                        failCount++;
                        errors.add(String.format("处理库存行异常: org=%s, %s", org, e.getMessage()));
                        log.error("同步单行库存到氚云异常, org: {}, row: {}", org, row.toJSONString(), e);
                    }
                }
            } catch (Exception e) {
                failCount++;
                errors.add(String.format("同步库存组织异常: org=%s, %s", org, e.getMessage()));
                log.error("同步库存组织异常, org: {}", org, e);
            }
        }

        result.put("success", failCount == 0);
        result.put("totalRows", totalRows);
        result.put("successCount", successCount);
        result.put("failCount", failCount);
        result.put("errors", errors);
        return result;
    }

    private List<String> getEnabledInventoryOrgList() {
        JSONObject result = h3yunService.queryBizObjects(
                "D29365537feb4e5e8644b21b7fd938dd322dab3",
                "F0000003 = '可用'",
                200,
                0
        );

        List<String> orgList = new ArrayList<>();
        JSONObject returnData = result.getJSONObject("ReturnData");
        if (returnData == null) {
            return orgList;
        }

        JSONArray bizObjectArray = returnData.getJSONArray("BizObjectArray");
        if (bizObjectArray == null) {
            return orgList;
        }

        for (int i = 0; i < bizObjectArray.size(); i++) {
            JSONObject bizObject = bizObjectArray.getJSONObject(i);
            String org = bizObject.getString("F0000002");
            if (StrUtil.isNotBlank(org) && !orgList.contains(org)) {
                orgList.add(org);
            }
        }
        return orgList;
    }

    private String findExistingStockDetailObjectId(String org, String materialObjectId, String warehouseObjectId) {
        String filter = String.format("F0000107 = '%s' AND F0000100 = '%s' AND F0000101 = '%s'", org, materialObjectId, warehouseObjectId);
        JSONObject result = h3yunService.queryBizObjects("D293655sukswvxwuqus2tdbygynr", filter, 1, 0);
        JSONObject returnData = result.getJSONObject("ReturnData");
        if (returnData != null) {
            JSONArray bizObjectArray = returnData.getJSONArray("BizObjectArray");
            if (bizObjectArray != null && !bizObjectArray.isEmpty()) {
                return bizObjectArray.getJSONObject(0).getString("ObjectId");
            }
        }
        return null;
    }

    private Double parseDecimalOrZero(String value) {
        if (StrUtil.isBlank(value)) {
            return 0D;
        }
        try {
            return Double.parseDouble(value);
        } catch (Exception e) {
            return 0D;
        }
    }

    // ==================== 金蝶 -> 氚云同步 ====================

    /**
     * 同步采购入库单（金蝶->氚云）
     * @param billNo 单据编号
     * @param webhookData 可选的webhook原始数据，如果传入则直接使用，避免再次查询
     */
    public boolean syncPurchaseInstockFromKingdee(String billtypeId, String billNo, JSONObject webhookData, String finalBilltypeName) {
        try {
            // 1. 检查是否已存在（幂等性）
            if (h3yunService.checkBillExists(H3yunService.SCHEMA_PURCHASE_INSTOCK, billNo, "F0000041")) {
                log.info("采购入库单已存在，跳过同步, billNo: {}", billNo);
                return true;
            }

//            // 2. 获取单据详情（优先使用webhook数据，其次查询API）
//            JSONObject billDetail = getBillDetailFromWebhook(webhookData, "STK_InStock", billNo);
//
//            // 3. 解析数据并写入氚云
//            String customerId = billDetail.getJSONObject("supplier") != null ? billDetail.getJSONObject("supplier").getString("number") : null;
//            Integer qty = getTotalQtyFromBillEntry(billDetail);

            H3yunResponse response = h3yunService.createPurchaseInstock(billNo, billtypeId, webhookData, finalBilltypeName);
            return response.isSuccess();
        } catch (Exception e) {
            log.error("同步采购入库单异常, billNo: {}", billNo, e);
            return false;
        }
    }


    /**
     * 同步采购退料单（金蝶->氚云）
     * @param billNo 单据编号
     * @param webhookData 可选的webhook原始数据，如果传入则直接使用，避免再次查询
     */
    public boolean syncPurchaseReturnFromKingdee(String billtypeId, String billNo, JSONObject webhookData, String finalBilltypeName) {
        try {
            if (h3yunService.checkBillExists(H3yunService.SCHEMA_PURCHASE_RETURN, billNo, "F0000042")) {
                log.info("采购退料单已存在，跳过同步, billNo: {}", billNo);
                return true;
            }

//            JSONObject billDetail = getBillDetailFromWebhook(webhookData, "STK_MisDelivery", billNo);
//            String customerId = billDetail.getJSONObject("supplier") != null ? billDetail.getJSONObject("supplier").getString("number") : null;
//            Integer qty = getTotalQtyFromBillEntry(billDetail);

            H3yunResponse response = h3yunService.createPurchaseReturn(billNo, billtypeId, webhookData, finalBilltypeName);
            return response.isSuccess();
        } catch (Exception e) {
            log.error("同步采购退料单异常, billNo: {}", billNo, e);
            return false;
        }
    }

    /**
     * 同步采购退料单（兼容旧方法）
     */

    /**
     * 同步销售出库单（金蝶->氚云）
     * @param billNo 单据编号
     * @param webhookData 可选的webhook原始数据，如果传入则直接使用，避免再次查询
     */
    public boolean syncSaleOutstockFromKingdee(String billtypeId, String billNo, JSONObject webhookData, String finalBilltypeName) {
        try {
            if (h3yunService.checkBillExists(H3yunService.SCHEMA_SALE_OUTSTOCK, billNo, "K3id")) {
                log.info("销售出库单已存在，跳过同步, billNo: {}", billNo);
                return true;
            }

//            JSONObject billDetail = getBillDetailFromWebhook(webhookData, "SAL_OUTSTOCK", billNo);
//            String customerId = billDetail.getJSONObject("customer") != null ? billDetail.getJSONObject("customer").getString("number") : null;
//            Integer qty = getTotalQtyFromBillEntry(billDetail);

            H3yunResponse response = h3yunService.createSaleOutstock(billNo, billtypeId, webhookData, finalBilltypeName);
            return response.isSuccess();
        } catch (Exception e) {
            log.error("同步销售出库单异常, billNo: {}", billNo, e);
            return false;
        }
    }

    /**
     * 同步销售出库单（兼容旧方法）
     */


    /**
     * 同步销售退货单（金蝶->氚云）
     * @param billNo 单据编号
     * @param webhookData 可选的webhook原始数据，如果传入则直接使用，避免再次查询
     */
    public boolean syncSaleReturnFromKingdee(String billtypeId, String billNo, JSONObject webhookData, String finalBilltypeName) {
        try {
            if (h3yunService.checkBillExists(H3yunService.SCHEMA_SALE_RETURN, billNo, "K3id")) {
                log.info("销售退货单已存在，跳过同步, billNo: {}", billNo);
                return true;
            }
//
//            JSONObject billDetail = getBillDetailFromWebhook(webhookData, "SAL_RETURNSTOCK", billNo);
//            String customerId = billDetail.getJSONObject("customer") != null ? billDetail.getJSONObject("customer").getString("number") : null;
//            Integer qty = getTotalQtyFromBillEntry(billDetail);

            H3yunResponse response = h3yunService.createSaleReturn(billNo, billtypeId, webhookData, finalBilltypeName);
            return response.isSuccess();
        } catch (Exception e) {
            log.error("同步销售退货单异常, billNo: {}", billNo, e);
            return false;
        }
    }

    // ==================== 氚云 -> 旺店通同步 ====================

    /**
     * 同步盘点单到旺店通（氚云->旺店通）
     */
    public boolean syncInventoryToWangdian(String warehouseNo, List<Map<String, Object>> profitItems,
                                           List<Map<String, Object>> lossItems) {
        try {
            boolean allSuccess = true;

            // 同步盘盈单
            if (profitItems != null && !profitItems.isEmpty()) {
                WangdianResponse profitResponse = wangdianService.createProfitOrder(warehouseNo, profitItems);
                if (!profitResponse.isSuccess()) {
                    log.error("同步盘盈单失败, error: {}", profitResponse.getErrorMessage());
                    allSuccess = false;
                }
            }

            // 同步盘亏单
            if (lossItems != null && !lossItems.isEmpty()) {
                WangdianResponse lossResponse = wangdianService.createLossOrder(warehouseNo, lossItems);
                if (!lossResponse.isSuccess()) {
                    log.error("同步盘亏单失败, error: {}", lossResponse.getErrorMessage());
                    allSuccess = false;
                }
            }

            return allSuccess;
        } catch (Exception e) {
            log.error("同步盘点单到旺店通异常, warehouseNo: {}", warehouseNo, e);
            return false;
        }
    }

    /**
     * 同步单个盘盈物料
     */
    public WangdianResponse syncSingleProfitToWangdian(String warehouseNo, String specNo, Integer num, String remark) {
        return wangdianService.createProfitOrder(warehouseNo, specNo, num, remark);
    }

    /**
     * 同步单个盘亏物料
     */
    public WangdianResponse syncSingleLossToWangdian(String warehouseNo, String specNo, Integer num, String remark) {
        return wangdianService.createLossOrder(warehouseNo, specNo, num, remark);
    }

    // ==================== 氚云 -> 金蝶统一同步接口 ====================

    /**
     * 统一同步方法（氚云->金蝶）
     *
     * 功能说明：根据对接类型，从氚云查询数据并同步到金蝶
     *
     * @param schemaCode 氚云表单编码
     * @param objectId 氚云数据ID
     * @param syncType 对接类型（SUPPLIER/CUSTOMER/MATERIAL/STOCK等）
     * @return 同步结果
     */
    public KingdeeSaveResponse syncToKingdeeByType(String schemaCode, String objectId, String syncType) {
        log.info("开始氚云->金蝶同步, schemaCode: {}, objectId: {}, syncType: {}", schemaCode, objectId, syncType);

        // 1. 查询氚云数据
        JSONObject bizData = h3yunService.getBizObjectById(schemaCode, objectId);
        if (bizData == null) {
            throw new RuntimeException("未查询到氚云数据, objectId: " + objectId);
        }

        // 2. 根据对接类型执行同步
        switch (syncType) {
            case H3yunService.SYNC_TYPE_SUPPLIER:
                //供应商
                return syncSupplierToKingdeeFromH3yun(bizData);
            case H3yunService.SYNC_TYPE_CUSTOMER:
                //客户
                return syncCustomerToKingdeeFromH3yun(bizData);
            case H3yunService.SYNC_TYPE_MATERIAL:
                //物料
                return syncMaterialToKingdeeFromH3yun(bizData);
            case H3yunService.SYNC_TYPE_STOCK:
                //仓库
                return syncStockToKingdeeFromH3yun(bizData);
            case H3yunService.SYNC_TYPE_PURCHASE_REQUISITION:
                //采购订单
                return syncPurchaseRequisitionToKingdeeFromH3yun(bizData);
            case H3yunService.SYNC_TYPE_SALE_ORDER:
                //销售订单
                return syncSaleOrderToKingdeeFromH3yun(bizData);
            case H3yunService.SYNC_TYPE_PURCHASE_RECEIVE:
                //收料通知单
                return syncPurchaseReceiveToKingdeeFromH3yun(bizData);
            case H3yunService.SYNC_TYPE_PURCHASE_RETURN:
                //采购退料申请
                return syncPurchaseReturnToKingdeeFromH3yun(bizData);
            case H3yunService.SYNC_TYPE_DELIVERY_NOTICE:
                //发货通知单
                return syncDeliveryNoticeToKingdeeFromH3yun(bizData);
            case H3yunService.SYNC_TYPE_RETURN_REQUEST:
                //退货申请单
                return syncReturnRequestToKingdeeFromH3yun(bizData);
            case H3yunService.SYNC_TYPE_PAYABLE_BILL:
                //财务应付单
                return syncPayableBillToKingdeeFromH3yun(bizData);
            case H3yunService.SYNC_TYPE_PAYMENT_REQUEST:
                //采购付款申请单@采购付款单
                return syncPaymentRequestToKingdeeFromH3yun(bizData);
            case H3yunService.SYNC_TYPE_PURCHASE_INVOICE:
                return syncPurchaseInvoiceToKingdeeFromH3yun(bizData);
            case H3yunService.SYNC_TYPE_SALES_INVOICE:
                return syncSalesInvoiceToKingdeeFromH3yun(bizData);
            case H3yunService.SYNC_TYPE_RECEIVE_BILL:
                //销售收款单
                return syncReceiveBillToKingdeeFromH3yun(bizData);
            case H3yunService.SYNC_TYPE_INVOICE_APPLY:
                //开票申请@财务应收单
                return syncInvoiceApplyToKingdeeFromH3yun(bizData);
            case H3yunService.SYNC_TYPE_PROJECT:
                //项目立项
                return syncProjectToKingdeeFromH3yun(bizData);
            default:

                throw new RuntimeException("不支持的对接类型: " + syncType);
        }
    }

    /***
     提供金蝶关联关系： 收料通知单关联采购订单   退料申请单关联采购入库单  发货通知单关联销售订单 退货申请单关联销售出库单     付款申请单关联财务应付单  销售收款单关联销售订单   销售出库单关联销售订单  开票申请单关联销售出库单
     金蝶回复：API中已经变更，注意使用新的API
     关联关系	billentry_lk_stableid	备注
     收料通知单关联采购订单	602924326097811460
     退料申请单关联采购入库单	602924315385558018
     发货通知单关联销售订单	602924332909361155
     退货申请单关联销售出库单	602924300688717826
     付款申请单关联财务应付单	577639813562251264	 注意：这个关联的是付款计划，不是物料明细
     销售收款单关联销售订单	602924332909361152	注意：这个关联的是收款款计划，而且收款计划明细中是预收，不是物料明细
     销售出库单关联销售订单	602924332909361155
     关联销售出库单	602924300688717826


     待金蝶确认：
     事件订阅发生的入库申请参数中有无收料通知单信息
     事件订阅发生的采购退料单参数中有无退料申请单信息
     事件订阅发生的销售出库单参数中有无发货通知单信息
     事件订阅发生的销售退货单参数中有无退货申请单信息
     金蝶回复：
     在订阅的参数中 billhead_lk 中的信息是关联的单据信息 */

    /**
     * 从氚云数据同步供应商到金蝶
     */
    private KingdeeSaveResponse syncSupplierToKingdeeFromH3yun(JSONObject bizData) {
        Map<String, Object> data = extractSupplierData(bizData);
        String k3Id = bizData.getString("K3id");

        KingdeeSaveResponse response;
        if (k3Id != null && !k3Id.trim().isEmpty()) {
            // 已有K3ID，执行修改流程：反审核 -> 修改 -> 提交 -> 审核
            log.info("供应商已存在K3ID: {}，执行修改流程", k3Id);
            response = kingdeeService.batchUpdateSupplierWithSubmit(data, k3Id);
        } else {
            // 无K3ID，执行新增流程：新增 -> 提交 -> 审核
            log.info("供应商无K3ID，执行新增流程");
            response = kingdeeService.batchAddSupplierWithSubmit(data);
        }

        writeBackSupplierBankEntryIds(bizData, response);
        return response;
    }

    public void writeBackSupplierBankEntryIds(JSONObject bizData, KingdeeSaveResponse response) {
        if (response == null || !response.isSuccess()) {
            return;
        }

        JSONArray bankEntryIds = extractSupplierBankEntryIds(response);
        if (bankEntryIds == null || bankEntryIds.isEmpty()) {
            return;
        }

        JSONArray sourceRows = bizData.getJSONArray("D293655Fb2deb81ad33c41e4bac91630e399d141");
        if (sourceRows == null || sourceRows.isEmpty()) {
            return;
        }

        JSONArray targetRows = new JSONArray();
        int count = Math.min(sourceRows.size(), bankEntryIds.size());
        for (int i = 0; i < count; i++) {
            JSONObject sourceRow = sourceRows.getJSONObject(i);
            JSONObject targetRow = new JSONObject(true);
            targetRow.put("F0000022", sourceRow.getString("F0000022"));
            targetRow.put("F0000023", sourceRow.getString("F0000023"));
            targetRow.put("F0000025", sourceRow.getString("F0000025"));
            targetRow.put("F0000024", sourceRow.getString("F0000024"));
            targetRow.put("F0000026", sourceRow.getString("F0000026"));
            targetRow.put("F0000027", bankEntryIds.getString(i));
            targetRows.add(targetRow);
        }

        Map<String, Object> updateData = new LinkedHashMap<>();
        updateData.put("D293655Fb2deb81ad33c41e4bac91630e399d141", targetRows);
        h3yunService.updateBizObject("D293655b4a0a34e44914aee9613a7bd3957df83", bizData.getString("ObjectId"), updateData);
    }

    private JSONArray extractSupplierBankEntryIds(KingdeeSaveResponse response) {
        JSONObject data = response.getData();
        if (data == null) {
            return null;
        }

        JSONArray resultArray = data.getJSONArray("result");
        if (resultArray == null || resultArray.isEmpty()) {
            return null;
        }

        for (int i = 0; i < resultArray.size(); i++) {
            JSONObject resultItem = resultArray.getJSONObject(i);
            if (resultItem == null) {
                continue;
            }

            JSONObject entryIds = resultItem.getJSONObject("entryIds");
            if (entryIds == null) {
                continue;
            }

            JSONArray entryBank = entryIds.getJSONArray("entry_bank");
            if (entryBank != null && !entryBank.isEmpty()) {
                return entryBank;
            }
        }
        return null;
    }

    /**
     * 从氚云数据同步客户到金蝶
     */
    private KingdeeSaveResponse syncCustomerToKingdeeFromH3yun(JSONObject bizData) {
        Map<String, Object> data = extractCustomerData(bizData);
        String k3Id = bizData.getString("K3id");
        if (k3Id != null && !k3Id.trim().isEmpty()) {
            // 已有K3ID，执行修改流程：反审核 -> 修改 -> 提交 -> 审核
            log.info("客户已存在K3ID: {}，执行修改流程", k3Id);
            return kingdeeService.batchUpdateCustomerWithSubmit(data, k3Id);
        } else {
            // 无K3ID，执行新增流程：新增 -> 提交 -> 审核
            log.info("客户无K3ID，执行新增流程");
            return kingdeeService.batchAddCustomerWithSubmit(data);
        }
    }

    /**
     * 从氚云数据同步物料到金蝶
     */
    private KingdeeSaveResponse syncMaterialToKingdeeFromH3yun(JSONObject bizData) {
        Map<String, Object> data = extractMaterialData(bizData);
        // 判断是否已有K3ID，有则修改，无则新增
        String k3Id = bizData.getString("K3id");
        if (k3Id != null && !k3Id.trim().isEmpty()) {
            // 已有K3ID，执行修改流程：反审核 -> 修改 -> 提交 -> 审核
            log.info("物料已存在K3ID: {}，执行修改流程", k3Id);
            return kingdeeService.batchUpdateMaterialWithSubmit(data, k3Id, bizData);
        } else {
            // 无K3ID，执行新增流程：新增 -> 提交 -> 审核
            log.info("物料无K3ID，执行新增流程");
            return kingdeeService.batchAddMaterialWithSubmit(data, bizData);
        }
    }

    /**
     * 从氚云数据同步仓库到金蝶
     */
    private KingdeeSaveResponse syncStockToKingdeeFromH3yun(JSONObject bizData) {
        Map<String, Object> data = extractStockData(bizData);
        String k3Id = bizData.getString("K3id");
        String numbersss = bizData.getString("SeqNo");
        if (k3Id != null && !k3Id.trim().isEmpty()) {
            // 已有K3ID，执行修改流程：反审核 -> 修改 -> 提交 -> 审核
            log.info("仓库已存在K3ID: {}，执行修改流程,仓库编码{}", k3Id, numbersss);
            return kingdeeService.batchUpdateStockWithSubmit(data, numbersss);
        } else {
            // 无K3ID，执行新增流程：新增 -> 提交 -> 审核
            log.info("仓库无K3ID，执行新增流程");
            return kingdeeService.batchAddStockWithSubmit(data);
        }
    }

    /**
     * 从氚云数据同步采购订单到金蝶
     */
    private KingdeeSaveResponse syncPurchaseRequisitionToKingdeeFromH3yun(JSONObject bizData) {
        Map<String, Object> data = extractPurchaseRequisitionData(bizData);
        String k3Id = bizData.getString("K3id");
        if (k3Id != null && !k3Id.trim().isEmpty()) {
            log.info("采购订单已存在K3ID: {}，执行修改流程", k3Id);
            return kingdeeService.batchUpdatePurchaseRequisitionWithSubmit(data, k3Id);
        } else {//AP-20260508-000009

            log.info("采购订单无K3ID，执行新增流程");
            return kingdeeService.batchAddPurchaseRequisitionWithSubmit(data);
        }
    }

    /**
     * 从氚云数据同步销售订单到金蝶
     */
    private KingdeeSaveResponse syncSaleOrderToKingdeeFromH3yun(JSONObject bizData) {
        Map<String, Object> data = extractSaleOrderData(bizData);
        String k3Id = bizData.getString("K3id");
        if (k3Id != null && !k3Id.trim().isEmpty()) {
            log.info("销售订单已存在K3ID: {}，执行修改流程", k3Id);
            return kingdeeService.batchUpdateSaleOrderWithSubmit(data, k3Id);
        } else {
            log.info("销售订单无K3ID，执行新增流程");
            return kingdeeService.batchAddSaleOrderWithSubmit(data);
        }
    }

    // 以下为扩展方法，可以根据实际氚云表单字段配置
    private KingdeeSaveResponse syncPurchaseReceiveToKingdeeFromH3yun(JSONObject bizData) {
        Map<String, Object> data = extractPurchaseReceiveData(bizData);
        String k3Id = bizData.getString("K3id");
        if (k3Id != null && !k3Id.trim().isEmpty()) {
            log.info("收料通知单已存在K3ID: {}，执行修改流程", k3Id);
            return kingdeeService.batchUpdatePurchaseReceiveWithSubmit(data, k3Id);
        } else {
            log.info("收料通知单无K3ID，执行新增流程");
            return kingdeeService.batchAddPurchaseReceiveWithSubmit(data);
        }
    }

    private KingdeeSaveResponse syncPurchaseReturnToKingdeeFromH3yun(JSONObject bizData) {
        Map<String, Object> data = extractPurchaseReturnData(bizData);
        String k3Id = bizData.getString("K3id");
        if (k3Id != null && !k3Id.trim().isEmpty()) {
            log.info("采购退料申请已存在K3ID: {}，执行修改流程", k3Id);
            return kingdeeService.batchUpdatePurchaseReturnWithSubmit(data, k3Id);
        } else {
            log.info("采购退料申请无K3ID，执行新增流程");
            return kingdeeService.batchAddPurchaseReturnWithSubmit(data);
        }
    }

    private KingdeeSaveResponse syncDeliveryNoticeToKingdeeFromH3yun(JSONObject bizData) {
        Map<String, Object> data = extractDeliveryNoticeData(bizData);
        String k3Id = bizData.getString("K3id");
        if (k3Id != null && !k3Id.trim().isEmpty()) {
            log.info("发货通知单已存在K3ID: {}，执行修改流程", k3Id);
            return kingdeeService.batchUpdateDeliveryNoticeWithSubmit(data, k3Id);
        } else {
            log.info("发货通知单无K3ID，执行新增流程");
            return kingdeeService.batchAddDeliveryNoticeWithSubmit(data);
        }
    }

    private KingdeeSaveResponse syncReturnRequestToKingdeeFromH3yun(JSONObject bizData) {
        Map<String, Object> data = extractReturnRequestData(bizData);
        String k3Id = bizData.getString("K3id");
        if (k3Id != null && !k3Id.trim().isEmpty()) {
            log.info("退货申请单已存在K3ID: {}，执行修改流程", k3Id);
            return kingdeeService.batchUpdateReturnRequestWithSubmit(data, k3Id);
        } else {
            log.info("退货申请单无K3ID，执行新增流程");
            return kingdeeService.batchAddReturnRequestWithSubmit(data);
        }
    }

    private KingdeeSaveResponse syncPaymentRequestToKingdeeFromH3yun(JSONObject bizData) {
        Map<String, Object> data = extractPaymentRequestData(bizData);
        String k3Id = bizData.getString("K3id");
        if (k3Id != null && !k3Id.trim().isEmpty()) {
            log.info("付款申请单已存在K3ID: {}，执行修改流程", k3Id);
            return kingdeeService.batchUpdatePaymentRequestWithSubmit(data, k3Id);
        } else {
            log.info("付款申请单无K3ID，执行新增流程");
            return kingdeeService.batchAddPaymentRequestWithSubmit(data);
        }
    }

    private KingdeeSaveResponse syncPayableBillToKingdeeFromH3yun(JSONObject bizData) {
        Map<String, Object> data = extractPayableBillData(bizData);
        String k3Id = bizData.getString("K3id");
        if (k3Id != null && !k3Id.trim().isEmpty()) {
            log.info("财务应付单已存在K3ID: {}，执行修改流程", k3Id);
            return kingdeeService.batchUpdatePayableBillWithSubmit(data, k3Id);
        } else {
            log.info("财务应付单无K3ID，执行新增流程");
            return kingdeeService.batchAddPayableBillWithSubmit(data);
        }
    }

    private KingdeeSaveResponse syncPurchaseInvoiceToKingdeeFromH3yun(JSONObject bizData) {
        Map<String, Object> data = extractPurchaseInvoiceData(bizData);
        String k3Id = bizData.getString("K3id");
        if (k3Id != null && !k3Id.trim().isEmpty()) {
            log.info("采购发票已存在K3ID: {}，执行修改流程", k3Id);
            return kingdeeService.batchUpdatePurchaseInvoiceWithSubmit(data, k3Id);
        } else {
            log.info("采购发票无K3ID，执行新增流程");
            return kingdeeService.batchAddPurchaseInvoiceWithSubmit(data);
        }
    }

    private KingdeeSaveResponse syncSalesInvoiceToKingdeeFromH3yun(JSONObject bizData) {
        Map<String, Object> data = extractSalesInvoiceData(bizData);
        String k3Id = bizData.getString("K3id");
        if (k3Id != null && !k3Id.trim().isEmpty()) {
            log.info("销售发票已存在K3ID: {}，执行修改流程", k3Id);
            return kingdeeService.batchUpdateSalesInvoiceWithSubmit(data, k3Id);
        } else {
            log.info("销售发票无K3ID，执行新增流程");
            return kingdeeService.batchAddSalesInvoiceWithSubmit(data);
        }
    }

    private KingdeeSaveResponse syncReceiveBillToKingdeeFromH3yun(JSONObject bizData) {
        Map<String, Object> data = extractReceiveBillData(bizData);
        String k3Id = bizData.getString("K3id");
        if (k3Id != null && !k3Id.trim().isEmpty()) {
            log.info("收款单已存在K3ID: {}，执行修改流程", k3Id);
            return kingdeeService.batchUpdateReceiveBillWithSubmit(data, k3Id);
        } else {
            log.info("收款单无K3ID，执行新增流程");
            return kingdeeService.batchAddReceiveBillWithSubmit(data);
        }
    }

    private KingdeeSaveResponse syncInvoiceApplyToKingdeeFromH3yun(JSONObject bizData) {
        Map<String, Object> data = extractInvoiceApplyData(bizData);
        String k3Id = bizData.getString("K3id");
        if (k3Id != null && !k3Id.trim().isEmpty()) {
            log.info("开票申请单已存在K3ID: {}，执行修改流程", k3Id);
            return kingdeeService.batchUpdateInvoiceApplyWithSubmit(data, k3Id);
        } else {
            log.info("开票申请单无K3ID，执行新增流程");
            return kingdeeService.batchAddInvoiceApplyWithSubmit(data);
        }
    }

    private KingdeeSaveResponse syncProjectToKingdeeFromH3yun(JSONObject bizData) {
        Map<String, Object> data = extractProjectData(bizData);
        String k3Id = bizData.getString("K3id");
        if (k3Id != null && !k3Id.trim().isEmpty()) {
            log.info("项目立项已存在K3ID: {}，执行修改流程", k3Id);
            return kingdeeService.batchUpdateProjectWithSubmit(data, k3Id);
        } else {
            log.info("项目立项无K3ID，执行新增流程");
            return kingdeeService.batchAddProjectWithSubmit(data);
        }
    }

    // ==================== 数据提取方法 ====================

    /**
     * 提取供应商数据
     *
     * 字段映射（可根据实际氚云表单字段名称调整）：
     * - F0000001: 供应商编码 -> code
     * - F0000002: 供应商名称 -> name
     * - F0000003: 创建组织 -> createOrgId
     * - F0000004: 使用组织 -> useOrgId
     * - F0000005: 社会信用代码 -> creditCode
     */
    private Map<String, Object> extractSupplierData(JSONObject bizData) {
        Map<String, Object> root = new LinkedHashMap<>();
        List<Object> dataList = new ArrayList<>();
        root.put("data", dataList);

        Map<String, Object> supplier = new LinkedHashMap<>();
        dataList.add(supplier);

        // 基本信息
        supplier.put("number", bizData.getString("SeqNo")); // 供应商编码
        supplier.put("name", bizData.getString("F0000001")); // 供应商名称
        supplier.put("simplename", bizData.getString("F0000003")); // 简称
        supplier.put("type", extractSupplierType(bizData.getString("F0000008"))); // 供应商伙伴类型
        supplier.put("societycreditcode", bizData.getString("F0000012")); // 社会信用代码
        supplier.put("bizfunction", extractBizFunction(bizData.getString("F0000006"))); // 业务职能
        supplier.put("tx_register_no", bizData.getString("F0000013")); // 纳税人识别号
        supplier.put("artificialperson", bizData.getString("F0000014")); // 法人代表
        supplier.put("regcapital", bizData.getString("F0000015")); // 注册资本
        supplier.put("curegcapital_number", "CNY"); // 注册资本币别
        supplier.put("businessterm", bizData.getString("F0000016")); // 营业期限
        supplier.put("businessscope", bizData.getString("F0000017")); // 经营范围
        if (bizData.getString("F0000018") != null && !bizData.getString("F0000018").trim().isEmpty()) {
            supplier.put("establishdate", formatDate(bizData.getString("F0000018"))); // 成立时间
        }


        supplier.put("createorg_number", bizData.getString("F0000007") == "" ? "001" : bizData.getString("F0000007")); // 创建组织
        supplier.put("country_number", "001"); // 国家

        supplier.put("creator_number", bizData.getString("UserID") == "" ? "43007523" : bizData.getString("UserID")); // 创建人
        supplier.put("modifier_number", bizData.getString("UserID") == "" ? "43007523" : bizData.getString("UserID")); // 修改人

        // 地址相关
        supplier.put("bizpartner_address", bizData.getString("F0000009")); // 供应商地址
        supplier.put("bizpartner_fax", bizData.getString("F0000009")); // 传真

        // 联系人信息
        supplier.put("linkman", bizData.getString("F0000010")); // 联系人
        supplier.put("bizpartner_phone", bizData.getString("F0000011")); // 电话】
        supplier.put("paycond_number", h3yunService.getFieldValueById("D293655sxvsttpe7re2tep6gvsdg", bizData.getString("F0000019"), "F0000001"));
        supplier.put("idno", bizData.getString("F0000028")); // 身份证号


        // 银行账户信息
        List<Map<String, Object>> bankList = new ArrayList<>();
        JSONArray billentryArray = bizData.getJSONArray("D293655Fb2deb81ad33c41e4bac91630e399d141");
        if (billentryArray != null && !billentryArray.isEmpty()) {
            for (int i = 0; i < billentryArray.size(); i++) {
                JSONObject entryData = billentryArray.getJSONObject(i);
                Map<String, Object> bank = new LinkedHashMap<>();

                String uuidHex = entryData.getString("F0000027");
                if (uuidHex != null && !uuidHex.isEmpty()) {
                    bank.put("id", uuidHex);
                } else {
                    bank.put("id", "0");
                }
                bank.put("bank_number", h3yunService.getFieldValueById("D293655sn1gizwncl0ulfdqwcll", entryData.getString("F0000025"), "F0000001")); // 银行编码
                bank.put("accountname", entryData.getString("F0000023")); // 开户名称
                bank.put("bankaccount", entryData.getString("F0000022")); // 银行账号
                bank.put("currency_number", h3yunService.getFieldValueById("D293655f08d8524a8254d35b3681ea527ce2c59", entryData.getString("F0000024"), "F0000001")); // 币别
                if (i == 0) {
                    bank.put("isdefault_bank", true);

                }
                bankList.add(bank);
            }
        }
        supplier.put("entry_bank", bankList);


//        List<Map<String, Object>> linkmanList = new ArrayList<>();
//        Map<String, Object> linkman = new LinkedHashMap<>();
//        linkman.put("contactperson", bizData.getString("F0000010")); // 联系人姓名
//        linkman.put("phone", bizData.getString("F0000011")); // 联系人电话
//        linkman.put("isdefault_linkman", true);
//        linkmanList.add(linkman);
//        supplier.put("entry_linkman", linkmanList);


        // 税号信息
//        List<Map<String, Object>> taxList = new ArrayList<>();
//        Map<String, Object> tax = new LinkedHashMap<>();
//        tax.put("taxcertificate_number", bizData.getString("F0000015")); // 税号
//        taxList.add(tax);
//        supplier.put("entry_tax", taxList);

        // 分组信息
//        List<Map<String, Object>> groupList = new ArrayList<>();
//        Map<String, Object> group = new LinkedHashMap<>();
//        group.put("standardid_number", bizData.getString("F0000016")); // 组内标准编码
//        groupList.add(group);
//        supplier.put("entry_groupstandard", groupList);

        // 其他字段


//        supplier.put("duns", bizData.getString("F0000021")); // DUNS编码
//        supplier.put("paycond_number", bizData.getString("F0000022")); // 付款条件编码
//        supplier.put("taxrate_number", bizData.getString("F0000023")); // 税率编码
//        supplier.put("paymentcurrency_number", bizData.getString("F0000024")); // 付款币别
//        supplier.put("settlementcyid_number", bizData.getString("F0000025")); // 结算币别
//        supplier.put("settlementtypeid_number", bizData.getString("F0000026")); // 结算方式
//        supplier.put("internal_company_number", bizData.getString("F0000027")); // 内账公司
//
//
//        supplier.put("taxregistplace_number", bizData.getString("F0000030")); // 税务登记地

        // 如果有K3ID则设置，用于修改
        String k3Id = bizData.getString("K3id");
        if (k3Id != null && !k3Id.isEmpty()) {
            supplier.put("id", k3Id);
            // supplier.put("masterid", k3Id);
        }

        return root;
    }

    /**
     * 提取客户数据（金蝶API格式）
     * 返回格式: {"data":[{"number":"CUS-001","name":"客户名称",...}]}
     */
    @SuppressWarnings("unchecked")
    private Map<String, Object> extractCustomerData(JSONObject bizData) {
        Map<String, Object> data = new HashMap<>();
        List<Map<String, Object>> dataList = new ArrayList<>();
        Map<String, Object> customer = new LinkedHashMap<>();

        // 基础字段
        customer.put("number", bizData.getString("SeqNo")); // 客户编码
        customer.put("name", bizData.getString("F0000001")); // 客户名称
        customer.put("simplename", bizData.getString("F0000002")); // 简称
        customer.put("type", extractCustomerType(bizData.getString("F0000016"))); // 客户类型
        customer.put("bizfunction", extractBizFunction(bizData.getString("F0000015"))); // 业务职能


        // 社会信息
        customer.put("societycreditcode", bizData.getString("F0000020")); // 社会信用代码
        customer.put("tx_register_no", bizData.getString("F0000021")); // 纳税人识别号
        customer.put("artificialperson", bizData.getString("F0000022")); // 法人代表
        customer.put("regcapital", bizData.getString("F0000023")); // 注册资本
        customer.put("curegcapital_number", "CNY"); // 注册资本币别
        customer.put("businessterm", bizData.getString("F0000024")); // 营业期限
        customer.put("businessscope", bizData.getString("F0000025")); // 经营范围
        if (bizData.getString("F0000026") != null && !bizData.getString("F0000026").trim().isEmpty()) {
            customer.put("establishdate", formatDate(bizData.getString("F0000026"))); // 成立时间
        }


        // 组织相关
        customer.put("createorg_number", StrUtil.blankToDefault(bizData.getString("F0000019"), "001")); // 创建组织
//        customer.put("country_number", "001"); // 国家
//        customer.put("admindivision", bizData.getString("F0000014")); // 行政区域

        // 联系方式
        customer.put("linkman", bizData.getString("F0000004")); // 联系人
        customer.put("bizpartner_phone", bizData.getString("F0000005")); // 电话
        customer.put("bizpartner_address", bizData.getString("F0000011")); // 地址
//        customer.put("bizpartner_fax", bizData.getString("F0000018")); // 传真
//        customer.put("postal_code", bizData.getString("F0000019")); // 邮编

        // 财务相关
//        customer.put("taxrate_number", bizData.getString("F0000020")); // 税率
//        customer.put("taxno", bizData.getString("F0000021")); // 税务登记号
//        customer.put("duns", bizData.getString("F0000022")); // 数据唯一标识

        // 结算相关
        customer.put("settlementcyid_number", "CNY"); // 结算币别
        customer.put("paymentcurrency_number", "CNY"); // 收付款币别

        // 创建人/修改人
        customer.put("creator_number", StrUtil.blankToDefault(bizData.getString("UserID"), "43007523")); // 创建人
        customer.put("modifier_number", StrUtil.blankToDefault(bizData.getString("UserID"), "43007523")); // 修改人

        customer.put("receivingcondid_number", h3yunService.getFieldValueById("D293655sv6bv8bozikwrkze3rk1", bizData.getString("F0000028"), "F0000001"));
//身份证号
        customer.put("idno", bizData.getString("F0000032"));
////发票类型-无异议
//        customer.put("invoicecategory_number", h3yunService.getFieldValueById("D293655sdzbyn4yqt0ub0k8e9euc", bizData.getString("F0000033"), "F0000001"));
        String k3Id = bizData.getString("K3id");
        if (k3Id != null && !k3Id.isEmpty()) {
            customer.put("id", k3Id);
            // supplier.put("masterid", k3Id);
        }
        List<Map<String, Object>> groupStandardList = new ArrayList<>();//分类标准
        Map<String, Object> groupStandard = new LinkedHashMap<>();
        groupStandard.put("standardid_number", "JBFLBZ"); // 组内编码
        groupStandard.put("groupid_number", h3yunService.getFieldValueById("D293655syoqw97qcuoxuxbhjkzo", bizData.getString("F0000027"), "F0000001")); // 组合号
        groupStandardList.add(groupStandard);

        customer.put("entry_groupstandard", groupStandardList);
        dataList.add(customer);
        data.put("data", dataList);
        return data;
    }


    /**
     * 提取客户类型
     * 格式如 "普通客户-1" -> "1"
     */
    private String extractCustomerType(String typeStr) {
        if (typeStr == null || typeStr.trim().isEmpty()) {
            return "1"; // 默认值
        }
        int index = typeStr.lastIndexOf("-");
        if (index >= 0 && index < typeStr.length() - 1) {
            return typeStr.substring(index + 1);
        }
        return "1";
    }

    /**
     * 格式化日期为 yyyy-MM-dd 格式
     * 输入格式如 "2026/4/17 0:00:00" -> "2026-04-17"
     */
    private String formatDate(String dateStr) {
        if (dateStr == null || dateStr.trim().isEmpty()) {
            return "";
        }
        try {
            return cn.hutool.core.date.DateUtil.parse(dateStr).toString("yyyy-MM-dd");
        } catch (Exception e) {
            log.warn("日期解析失败: {}, 返回原值", dateStr);
            return dateStr;
        }
    }

    /**
     * 提取项目立项数据（金蝶API格式）
     * 默认映射如下，后续可按实际氚云字段调整：
     * - number: SeqNo
     * - name: F0000001
     * - createorg_number: F0000002，默认001
     * - group_number: F0000003
     * - parent_number: F0000004
     * - planbegindate: F0000005
     * - planenddate: F0000006
     * - proaddress: F0000007
     * - sourcetype: 固定A
     */
    private Map<String, Object> extractProjectData(JSONObject bizData) {
        Map<String, Object> root = new LinkedHashMap<>();
        List<Map<String, Object>> dataList = new ArrayList<>();
        Map<String, Object> project = new LinkedHashMap<>();

        project.put("number", bizData.getString("SeqNo"));//项目编码
        project.put("name", bizData.getString("F0000002"));//项目名称

        project.put("createorg_number", h3yunService.getFieldValueById("D29365537feb4e5e8644b21b7fd938dd322dab3", bizData.getString("F0000042"), "F0000002"));
        if (bizData.getString("F0000043") != "") {
            project.put("group_number", h3yunService.getFieldValueById("D293655sgawiua6uedgcpglojm", bizData.getString("F0000043"), "F0000001"));
        }

//        project.put("parent_number", bizData.getString("F0000004"));
        project.put("planbegindate", formatDate(bizData.getString("F0000050")));
        project.put("planenddate", formatDate(bizData.getString("F0000051")));
//        project.put("proaddress", bizData.getString("F0000007"));
        project.put("sourcetype", "C");

        String k3Id = bizData.getString("K3id");
        if (StrUtil.isNotBlank(k3Id)) {
            project.put("id", k3Id);
        }

        dataList.add(project);
        root.put("data", dataList);
        return root;
    }

    /**
     * 提取物料数据（按金蝶物料接口格式）
     */
    private Map<String, Object> extractMaterialData(JSONObject bizData) {
        // 1. 构建根节点 Map
        Map<String, Object> root = new LinkedHashMap<>();
        List<Object> materialsList = new ArrayList<>();
        root.put("materials", materialsList);

        // 2. 构建 materials 数组中的第一个对象
        Map<String, Object> materialItem = new LinkedHashMap<>();
        materialsList.add(materialItem);

        // 3. 构建 commonInfoVo 对象
        Map<String, Object> commonInfoVo = new LinkedHashMap<>();

//        commonInfoVo.put("enableproduct", false);
//        commonInfoVo.put("createorg", bizData.getString("F0000005")); // 创建组织
//        commonInfoVo.put("bondcontrol", ""); // 可根据业务配置
//
//        // serviceattribute 是数组
//       // commonInfoVo.put("serviceattribute", Collections.singletonList(bizData.getString("F0000010")));
//
//
//
//
//        commonInfoVo.put("enableinv", false);
//        commonInfoVo.put("enableinspect", false);
//        commonInfoVo.put("group", bizData.getString("F0000004")); // 物料分组
//        commonInfoVo.put("taxrate", bizData.getString("F0000007")); // 税率
//
//
//        commonInfoVo.put("enablesale", false);
//        commonInfoVo.put("atpcheck", "");
//
//        commonInfoVo.put("enablepur", false);
//
//        commonInfoVo.put("enableoutsource", false);
//
//
//        commonInfoVo.put("enableasset", false);

        // 4. 构建 materialInfoVo 对象
        Map<String, Object> materialInfoVo = new LinkedHashMap<>();

        // 4.1 构建 auxptyentry 数组
//        List<Map<String, Object>> auxptyentryList = new ArrayList<>();
//        Map<String, Object> auxptyEntry = new LinkedHashMap<>();
//        auxptyEntry.put("isaffectprice", false);
//        auxptyEntry.put("auxpty_id", bizData.getString("F0000011")); // 辅助属性ID
//        auxptyEntry.put("iscomcontrol", false);
//        auxptyEntry.put("id", bizData.getString("F0000012")); // 辅助属性项ID
//        auxptyEntry.put("auxptynumber", bizData.getString("F0000013")); // 辅助属性编码
//        auxptyEntry.put("isaffectinv", false);
//        auxptyEntry.put("isaffectplan", false);
//        auxptyEntry.put("seq", 235);
//        auxptyentryList.add(auxptyEntry);
        //  materialInfoVo.put("auxptyentry", auxptyentryList);


        // 4.3 填充 materialInfoVo 其他字段
        String K3id = bizData.getString("K3id");
        if (K3id != null && !K3id.isEmpty()) {
            materialInfoVo.put("id", K3id); // 物料ID（仅在SeqNo不为空时设置）
        }
        materialInfoVo.put("name", bizData.getString("F0000001")); // 物料名称
        materialInfoVo.put("number", bizData.getString("SeqNo")); // 物料编码
        materialInfoVo.put("createorg", bizData.getString("F0000027") == "" ? "001" : bizData.getString("F0000027")); // 创建组织ID为空默认吾流
        materialInfoVo.put("baseunit", bizData.getString("F0000026") == "" ? "pcs" : bizData.getString("F0000026")); // 基本单位ID
        materialInfoVo.put("unitconvertdir", bizData.getString("F0000008") == "逆向换算" ? "B" : "A"); // 单位换算方向
        materialInfoVo.put("modelnum", bizData.getString("F0000010")); // 规格型号
        commonInfoVo.put("materialtype", mapMaterialType(bizData.getString("F0000011"))); // 物料类型
        commonInfoVo.put("materialattr", mapMaterialAttr(bizData.getString("F0000012"))); // 物料属性
        materialInfoVo.put("creator_number", bizData.getString("UserID") == "" ? "43007523" : bizData.getString("UserID"));//创建人ID 为空默认金小蝶
// 4.2 构建 entry_groupstandard 数组
        List<Map<String, Object>> groupStandardList = new ArrayList<>();
        Map<String, Object> groupStandard = new LinkedHashMap<>();
        groupStandard.put("groupStrandardNumber", "JBFLBZ"); // 组内编码
//        groupStandard.put("id", bizData.getString("F0000015")); // 组内标准ID
//        groupStandard.put("groupStrandardCreateOrg", bizData.getString("F0000016")); // 组内标准创建组织
        groupStandard.put("groupNumber", extractGroupNumber(bizData.getString("F0000028"))); // 组合号
        groupStandardList.add(groupStandard);
        materialInfoVo.put("entry_groupstandard", groupStandardList);
        commonInfoVo.put("controlpur", "是".equals(bizData.getString("F0000015")));//可采购
        commonInfoVo.put("controlsale", "是".equals(bizData.getString("F0000016")));//可销售
        commonInfoVo.put("enablesale", "是".equals(bizData.getString("F0000016")));//可销售

        commonInfoVo.put("controlinv", "是".equals(bizData.getString("F0000017")));//可库存
        commonInfoVo.put("enableself", "是".equals(bizData.getString("F0000018")));//可自制
        commonInfoVo.put("enableoutsource", "是".equals(bizData.getString("F0000019")));//可委外
        commonInfoVo.put("controlplan", "是".equals(bizData.getString("F0000020")));//可计划
        commonInfoVo.put("controlinspect", "是".equals(bizData.getString("F0000021")));//可质检
        commonInfoVo.put("enablebom", "是".equals(bizData.getString("F0000022")));//可BOM
        commonInfoVo.put("enablevmi", "是".equals(bizData.getString("F0000023")));//可VMI
        commonInfoVo.put("enableconsign", "是".equals(bizData.getString("F0000024")));//可委托代销
        commonInfoVo.put("enableqtyctrl", "是".equals(bizData.getString("F0000025")));//可发量控制

//        commonInfoVo.put("enableplan", "是".equals(bizData.getString("F0000016")));
//
//
//        commonInfoVo.put("controlsale", "是".equals(bizData.getString("F0000016")));//可销售
//        commonInfoVo.put("controlsale", "是".equals(bizData.getString("F0000016")));//可销售
//        commonInfoVo.put("controlsale", "是".equals(bizData.getString("F0000016")));//可销售


//        materialInfoVo.put("isversionaffectplan", false);
//        materialInfoVo.put("volumnunit", bizData.getString("F0000018")); // 体积单位
//        materialInfoVo.put("isversionaffectinv", false);
//        materialInfoVo.put("auxptyunit", bizData.getString("F0000019")); // 辅助单位
//        materialInfoVo.put("length", bizData.getDouble("F0000021")); // 长度
//        materialInfoVo.put("lengthunit", bizData.getString("F0000022")); // 长度单位
//        materialInfoVo.put("isenablematerialversion", false);
//        materialInfoVo.put("weightunit", bizData.getString("F0000023")); // 重量单位
//        materialInfoVo.put("volume", bizData.getDouble("F0000025")); // 体积
//
//        materialInfoVo.put("isuseauxpty", false);
//        materialInfoVo.put("grossweight", bizData.getDouble("F0000026")); // 毛重
//        materialInfoVo.put("netweight", bizData.getDouble("F0000027")); // 净重
//
//        materialInfoVo.put("width", bizData.getDouble("F0000028")); // 宽度
//
//        materialInfoVo.put("auxptyunit2", bizData.getString("F0000030")); // 辅助单位2
//        materialInfoVo.put("height", bizData.getDouble("F0000031")); // 高度


        // 5. 组装最终结构
        materialItem.put("commonInfoVo", commonInfoVo);
        materialItem.put("materialInfoVo", materialInfoVo);

        return root;
    }

    /**
     * 映射物料类型
     * 物资->1, 费用->7, 资产->8, 服务->9
     */
    private String mapMaterialType(String type) {
        if (type == null) {
            return "1"; // 默认物资
        }
        switch (type.trim()) {
            case "物资":
                return "1";
            case "费用":
                return "7";
            case "资产":
                return "8";
            case "服务":
                return "9";
            default:
                return "1"; // 默认物资
        }
    }

    /**
     * 映射物料属性
     * 自制->10030, 外购->10040, 委外->10050, 虚拟->10020
     */
    private String mapMaterialAttr(String attr) {
        if (attr == null) {
            return "10040"; // 默认外购
        }
        switch (attr.trim()) {
            case "自制":
                return "10030";
            case "外购":
                return "10040";
            case "委外":
                return "10050";
            case "虚拟":
                return "10020";
            default:
                return "10040"; // 默认外购
        }
    }

    /**
     * 提取组内编码
     * 格式如 "资产-05" -> "05"，"物资-01" -> "01"
     * 为空时默认 "05"
     */
    private String extractGroupNumber(String groupStrandardNumber) {
        if (groupStrandardNumber == null || groupStrandardNumber.trim().isEmpty()) {
            return "05"; // 默认值
        }
        // 按 "-" 分割，取后半部分
        int index = groupStrandardNumber.indexOf("-");
        if (index >= 0 && index < groupStrandardNumber.length() - 1) {
            return groupStrandardNumber.substring(index + 1);
        }
        return "05"; // 默认值
    }


    /**
     * 提取供应商类型
     * 格式如 "法人企业-1" -> "1"，"个体工商户-2" -> "2"
     */
    private String extractSupplierType(String typeStr) {
        if (typeStr == null || typeStr.trim().isEmpty()) {
            return "1"; // 默认值
        }
        int index = typeStr.indexOf("-");
        if (index >= 0 && index < typeStr.length() - 1) {
            return typeStr.substring(index + 1);
        }
        return "1"; // 默认值
    }

    /**
     * 提取业务职能
     * 格式如 "采购-1;结算-2" -> ",1,2,"
     */
    private String extractBizFunction(String funcStr) {
        if (funcStr == null || funcStr.trim().isEmpty()) {
            return ",,"; // 默认空值
        }
        StringBuilder result = new StringBuilder(",");
        String[] parts = funcStr.split(";");
        for (String part : parts) {
            int index = part.lastIndexOf("-");
            if (index >= 0 && index < part.length() - 1) {
                result.append(part.substring(index + 1)).append(",");
            }
        }
        return result.toString();
    }

    /**
     * 提取仓库数据（金蝶API格式）
     * 返回格式: {"data":[{"number":"CK001","name":"仓库001",...}]}
     */
    @SuppressWarnings("unchecked")
    private Map<String, Object> extractStockData(JSONObject bizData) {
        Map<String, Object> data = new HashMap<>();
        List<Map<String, Object>> dataList = new ArrayList<>();
        Map<String, Object> stock = new LinkedHashMap<>();

        // 基础字段
        stock.put("number", bizData.getString("SeqNo")); // 仓库编码
        stock.put("name", bizData.getString("F0000003")); // 仓库名称
        stock.put("description", bizData.getString("F0000017")); // 描述

        // 组织相关
        stock.put("createorg_number", bizData.getString("F0000012") == "" ? "001" : bizData.getString("F0000012")); // 创建组织
        stock.put("principal_number", bizData.getString("F0000019") == "" ? "43007523" : bizData.getString("F0000019")); // 负责人

        // 地址相关
        //stock.put("address", bizData.getString("F0000007")); // 地址
        stock.put("detailaddress", bizData.getString("F0000011")); // 详细地址
        // stock.put("telephone", bizData.getString("F0000009")); // 电话

        // 仓库属性（布尔值）
        stock.put("isallowallneginv", "是".equals(bizData.getString("F0000013"))); // 允许全部物料负库存
        stock.put("isallowpartialneginv", "是".equals(bizData.getString("F0000014")));//仅允许部分物料负库存
        stock.put("isopenlocation", false); // 启用库位
        stock.put("isentrustverifyware", "是".equals(bizData.getString("F0000016"))); // 委托代销仓
        stock.put("issuptransvirtualware", "是".equals(bizData.getString("F0000015"))); // 直运虚拟仓

        // 货主信息
        // stock.put("ownerid", bizData.getString("F0000010")); // 货主

        dataList.add(stock);
        data.put("data", dataList);
        return data;
    }

    /**
     * 提取采购订单数据（金蝶API格式）
     * 返回格式: {"data":[{"supplier_number":"...","billentry":[...]}]}
     */
    @SuppressWarnings("unchecked")
    private Map<String, Object> extractPurchaseRequisitionData(JSONObject bizData) {
        Map<String, Object> data = new HashMap<>();
        List<Map<String, Object>> dataList = new ArrayList<>();
        Map<String, Object> purchaseOrder = new LinkedHashMap<>();

        // 头部信息

        String K3id = bizData.getString("K3id");
        if (K3id != null && !K3id.isEmpty()) {
            purchaseOrder.put("id", K3id); // 物料ID（仅在SeqNo不为空时设置）
        }

        purchaseOrder.put("billno", bizData.getString("SeqNo")); // 单据编号

        purchaseOrder.put("trdbillno", bizData.getString("SeqNo")); // 单据编号
        purchaseOrder.put("org_number", bizData.getString("F0000038") == "" ? "001" : bizData.getString("F0000038"));//#采购组织编码
        purchaseOrder.put("billtype_number", bizData.getString("F0000021") == "" ? "pm_PurOrderBill_STD_BT_S" : "pm_PurOrderBill_STD_BT_S"); // 单据类型
        purchaseOrder.put("biztype_number", bizData.getString("F0000022")); // 业务类型
        purchaseOrder.put("biztime", formatDate(bizData.getString("F0000023"))); // 订单日期
        purchaseOrder.put("supplier_number", bizData.getString("F0000039")); //订货供应商编码
        purchaseOrder.put("settlecurrency_number", bizData.getString("F0000040")); // 结算币别
        purchaseOrder.put("paycondition_number", h3yunService.getFieldValueById("D293655sxvsttpe7re2tep6gvsdg", bizData.getString("F0000025"), "F0000001")); // 付款条件
        purchaseOrder.put("settletype_number", h3yunService.getFieldValueById("D293655skrwqen4wv0g7je4itf", bizData.getString("F0000035"), "F0000001")); // 结算币别.货币代码
        purchaseOrder.put("operator_operatornumber", bizData.getString("F0000042"));//采购员
        purchaseOrder.put("comment", bizData.getString("F0000031")); // 备注


        // 付款方式: 现购->CASH, 赊购->CREDIT
        String paymodeValue = bizData.getString("F0000034");
        if ("现购".equals(paymodeValue)) {
            purchaseOrder.put("paymode", "CASH");
        } else if ("赊购".equals(paymodeValue)) {
            purchaseOrder.put("paymode", "CREDIT");
        } else {
            purchaseOrder.put("paymode", paymodeValue); // 其他值原样传递
        }
        purchaseOrder.put("exratetable_number", "ERT-01"); // 汇率表

        purchaseOrder.put("exchangerate", "1"); // 汇率


//        purchaseOrder.put("operator_operatornumber",  bizData.getString("F0000019") == "" ? "43007523" : bizData.getString("F0000019")  ); // 采购员.业务员编码
        // purchaseOrder.put("istax", true); // 是否含税
        //purchaseOrder.put("ispayrate", false); // 按比例(%)

        // 分录信息 billentry (D293655F1ba2412b43504c2cb5edc37874c75d2b)
        List<Map<String, Object>> entryList = new ArrayList<>();
        JSONArray billentryArray = bizData.getJSONArray("D293655F1ba2412b43504c2cb5edc37874c75d2b");
        if (billentryArray != null && !billentryArray.isEmpty()) {
            for (int i = 0; i < billentryArray.size(); i++) {
                JSONObject entryData = billentryArray.getJSONObject(i);
                Map<String, Object> entry = new LinkedHashMap<>();
                String uuidHex = entryData.getString("ObjectId").replace("-", "");
// 取后16位（64bit），解析为无符号long，避免溢出和负数问题
                long id = Long.parseUnsignedLong(uuidHex.substring(uuidHex.length() - 16), 16);

                entry.put("id", id); // id
                entry.put("linetype_number", entryData.getString("F0000026")); // 行类型.编码
                entry.put("material_number", entryData.getString("F0000005")); // 物料编码
                entry.put("unit_number", h3yunService.getFieldValueById("D293655248b1d9bf6c448f0a291341ec58bb943", entryData.getString("F0000027"), "F0000001")); // 单位
                entry.put("qty", entryData.getDouble("F0000012")); // 数量
                entry.put("price", entryData.getDouble("F0000013")); // 单价
                entry.put("priceandtax", entryData.getDouble("F0000013")); // 含税单价
                entry.put("discounttype", "NULL"); // 物料明细.折扣方式 A:折扣率(%), B:单位折扣额, NULL:无
                entry.put("entryrecorg_number", bizData.getString("F0000038") == "" ? "001" : bizData.getString("F0000038")); // 收料组织
                entry.put("entrysettleorg_number", bizData.getString("F0000038") == "" ? "001" : bizData.getString("F0000038")); // 结算组织
                entry.put("entryreqorg_number", bizData.getString("F0000038") == "" ? "001" : bizData.getString("F0000038")); // 要货组织

                entry.put("warehouse_number", entryData.getString("F0000044")); // #仓库编码
                entry.put("ownertype", "bos_org"); // 物料明细.货主类型 bos_org:业务组织, bd_supplier:供应商, bd_customer:客户
                entry.put("owner_number", bizData.getString("F0000038") == "" ? "001" : bizData.getString("F0000038"));
                entry.put("taxrateid_number", h3yunService.getFieldValueById(
                        "D293655sl91vt6h8d0qg1heqw5aq", entryData.getString("F0000045"), "F0000001"));//税率.编码
                entry.put("deliverdate", formatDate(entryData.getString("F0000015"))); // 交货日期
//                entry.put("deliveraddress", entryData.getString("F0000014")); // 交货地址
//                entry.put("entrycomment", entryData.getString("F0000007")); // 分录备注
//                entry.put("warehouse_number", entryData.getString("F0000027")); // 仓库
//                entry.put("location_number", entryData.getString("F0000010")); // 库位
//                entry.put("project_number", entryData.getString("F0000011")); // 项目

                entryList.add(entry);
            }
        }
        purchaseOrder.put("billentry", entryList);

        // 付款计划分录 purbillentry_pay (D293655F8151b3b1b0f345ba9a957cb57c7f5064)
        List<Map<String, Object>> payList = new ArrayList<>();
        JSONArray payArray = bizData.getJSONArray("D293655F8151b3b1b0f345ba9a957cb57c7f5064");
        if (payArray != null && !payArray.isEmpty()) {
            for (int i = 0; i < payArray.size(); i++) {
                JSONObject payData = payArray.getJSONObject(i);
                Map<String, Object> payEntry = new LinkedHashMap<>();
                // entry.put("id", entryData.getString("ObjectId").replace("-", ""));//id
                String uuidHex = payData.getString("ObjectId").replace("-", "");
// 取后16位（64bit），解析为无符号long，避免溢出和负数问题
                long id = Long.parseUnsignedLong(uuidHex.substring(uuidHex.length() - 16), 16);
                payEntry.put("id", id);
                payEntry.put("paydate", formatDate(payData.getString("F0000028"))); // 付款日期
                payEntry.put("payrate", payData.getDouble("F0000029")); // 付款比例
                payEntry.put("payamount", payData.getDouble("F0000030")); // 付款金额
                payEntry.put("planentrysettleorg_number", bizData.getString("F0000038") == "" ? "001" : bizData.getString("F0000038")); // 结算组织.编码
                String r_needrecadvance = payData.getString("F0000055");
                if ("是".equals(r_needrecadvance)) {
                    r_needrecadvance = "true";
                } else {
                    r_needrecadvance = "false";
                }
                payEntry.put("isprepay", r_needrecadvance);

                payList.add(payEntry);
            }
        }
        purchaseOrder.put("purbillentry_pay", payList);

        dataList.add(purchaseOrder);
        data.put("data", dataList);
        return data;
    }

    /**
     * 提取销售订单数据（金蝶API格式）
     * 返回格式: {"data":[{"billno":"...","customer_number":"...","salebillentry":[...]}]}
     */
    @SuppressWarnings("unchecked")
    private Map<String, Object> extractSaleOrderData(JSONObject bizData) {
        Map<String, Object> data = new HashMap<>();
        List<Map<String, Object>> dataList = new ArrayList<>();
        Map<String, Object> saleOrder = new LinkedHashMap<>();

        // ========== 头部信息 ==========
        saleOrder.put("billno", bizData.getString("SeqNo")); // 单据编号
        saleOrder.put("bizdate", formatDate(bizData.getString("F0000021"))); // 订单日期

        // 销售组织编码（复用查询结果）
        String saleOrgNumber = (String) h3yunService.getFieldValueById(
                "D29365537feb4e5e8644b21b7fd938dd322dab3", bizData.getString("F0000018"), "F0000002");
        saleOrder.put("org_number", saleOrgNumber); // 销售组织

        // 订货客户编码
        saleOrder.put("customer_number", h3yunService.getFieldValueById(
                "D293655shuyz9ttzgkgmhaa4rglr", bizData.getString("F0000024"), "SeqNo"));
        saleOrder.put("billtype_number", "sm_SalesOrder_STD_BT_S"); // 单据类型
        saleOrder.put("biztype_number", "210"); // 业务类型.编码


        saleOrder.put("al95_customer_number", h3yunService.getFieldValueById(
                "D293655shuyz9ttzgkgmhaa4rglr", bizData.getString("F0000023"), "SeqNo"));//店铺

        saleOrder.put("al95_assistantfield_number", h3yunService.getFieldValueById(
                "D293655sdfmyisqk1us9gqj1bljt", bizData.getString("F0000052"), "F0000001"));//物流公司.编码
        saleOrder.put("al95_assistantfield_name", h3yunService.getFieldValueById(
                "D293655sdfmyisqk1us9gqj1bljt", bizData.getString("F0000052"), "F0000011"));//物流公司.编码
        // 结算币别
        saleOrder.put("settlecurrency_number", h3yunService.getFieldValueById(
                "D293655f08d8524a8254d35b3681ea527ce2c59", bizData.getString("F0000025"), "F0000001"));

        saleOrder.put("comment", bizData.getString("F0000047")); // 备注
        saleOrder.put("istax", bizData.getString("F0000041")); // 是否含税

        // 操作员（默认43007523）
        String operator = (String) h3yunService.getFieldValueById(
                "D2936556a05fbb0350545cc9d8bd70901b1ed3b", bizData.getString("F0000048"), "F0000001");
        saleOrder.put("operator_operatornumber", cn.hutool.core.util.StrUtil.blankToDefault(operator, "43007523"));
        saleOrder.put("creator_number", bizData.getString("UserID") == "" ? "43007523" : bizData.getString("UserID"));//创建人ID 为空默认金小蝶


        saleOrder.put("reccondition_number", h3yunService.getFieldValueById(
                "D293655sv6bv8bozikwrkze3rk1", bizData.getString("F0000038"), "F0000001"));//收款条件.编号
        // ========== 分录信息 salebillentry ==========
        List<Map<String, Object>> entryList = new ArrayList<>();
        JSONArray billentryArray = bizData.getJSONArray("D293655Fb301a6f03145402d84f56d4493e6e764");
        if (billentryArray != null && !billentryArray.isEmpty()) {
            for (int i = 0; i < billentryArray.size(); i++) {
                JSONObject entryData = billentryArray.getJSONObject(i);
                Map<String, Object> entry = new LinkedHashMap<>();

                String uuidHex = entryData.getString("ObjectId").replace("-", "");
// 取后16位（64bit），解析为无符号long，避免溢出和负数问题
                long id = Long.parseUnsignedLong(uuidHex.substring(uuidHex.length() - 16), 16);
                entry.put("id", id); // id
                entry.put("linetype_number", "010"); // 行类型.编码
                // 物料编码（通过物料基础档案查询）
                entry.put("material_number", h3yunService.getFieldValueById(
                        "D293655fc1a38f7956f400a886f376911a54a30", entryData.getString("F0000027"), "SeqNo"));
                // 销售单位
                entry.put("unit_number", h3yunService.getFieldValueById(
                        "D293655248b1d9bf6c448f0a291341ec58bb943", entryData.getString("F0000030"), "F0000001"));
                entry.put("e_stockorg_number", saleOrgNumber); // 发货组织（复用）
                entry.put("entrysettleorg_number", saleOrgNumber); // 结算组织（复用）
             //entry.put("price", entryData.getDouble("F0000032")/(1+(entryData.getDouble("F0000078")/100)) ); // 单价
                entry.put("priceandtax", entryData.getDouble("F0000032")); // h含税单价
                entry.put("qty", entryData.getDouble("F0000031")); // 数量
                entry.put("amount", entryData.getDouble("F0000033")); // 金额
                entry.put("al95_textfield", entryData.getString("F0000053")); // 物料明细.收货人
                entry.put("al95_textfield1", entryData.getString("F0000054")); // 物料明细.收货人地址
                entry.put("al95_textfield2", entryData.getString("F0000055")); // 物料明细.收货人联系电话
                // 仓库编码
                entry.put("warehouse_number", h3yunService.getFieldValueById(
                        "D293655scvrhqr64jemxdkqk6gf", entryData.getString("F0000049"), "SeqNo"));
                // 税率
                entry.put("taxrateid_number", h3yunService.getFieldValueById(
                        "D293655sl91vt6h8d0qg1heqw5aq", entryData.getString("F0000077"), "F0000001"));

                entryList.add(entry);
            }
        }
        saleOrder.put("billentry", entryList);

        // ========== 收款计划分录 recplanentry ==========
        List<Map<String, Object>> recPlanList = new ArrayList<>();
        JSONArray recplanentryArray = bizData.getJSONArray("D293655F3becd42e6bc4432889c35589bcab20e7");
        if (recplanentryArray != null && !recplanentryArray.isEmpty()) {
            for (int i = 0; i < recplanentryArray.size(); i++) {
                JSONObject recData = recplanentryArray.getJSONObject(i);
                Map<String, Object> recPlan = new LinkedHashMap<>();
                // 销售组织编码（复用查询结果）
                Map<String, Object> entry = new LinkedHashMap<>();

                String uuidHex = recData.getString("ObjectId").replace("-", "");
// 取后16位（64bit），解析为无符号long，避免溢出和负数问题
                long id = Long.parseUnsignedLong(uuidHex.substring(uuidHex.length() - 16), 16);
                recPlan.put("id", id); // id
                String r_recsettleorg_number = (String) h3yunService.getFieldValueById(
                        "D29365537feb4e5e8644b21b7fd938dd322dab3", recData.getString("F0000051"), "F0000002");
                recPlan.put("r_recsettleorg_number", r_recsettleorg_number); // 结算组织


                String r_needrecadvance = recData.getString("F0000050");
                if ("是".equals(r_needrecadvance)) {
                    r_needrecadvance = "true";
                } else {
                    r_needrecadvance = "false";
                }
                recPlan.put("r_needrecadvance", r_needrecadvance);

                recPlan.put("r_duedate", formatDate(recData.getString("F0000037"))); // 到期日
                recPlan.put("r_recadvancerate", recData.getDouble("F0000035")); // 应收比例%
                recPlan.put("r_recadvanceamount", recData.getDouble("F0000036")); // 应收金额
                recPlanList.add(recPlan);
            }
        }
        saleOrder.put("recplanentry", recPlanList);

        dataList.add(saleOrder);
        data.put("data", dataList);
        return data;
    }

    /**
     * 提取收料通知单数据（金蝶API格式）
     * 返回格式: {"data":[{"billno":"...","supplier_number":"...","purbillentry":[...]}]}
     */
    @SuppressWarnings("unchecked")
    private Map<String, Object> extractPurchaseReceiveData(JSONObject bizData) {
        Map<String, Object> data = new HashMap<>();
        List<Map<String, Object>> dataList = new ArrayList<>();
        Map<String, Object> receiveNotice = new LinkedHashMap<>();

        // 头部信息
        receiveNotice.put("billno", bizData.getString("SeqNo")); // 单据编号
        receiveNotice.put("trdbillno", bizData.getString("SeqNo")); // 单据编号
        receiveNotice.put("biztype_number", "110"); // 业务类型.编码
        receiveNotice.put("biztype_name", "物料类采购");
        receiveNotice.put("billstatus", "C");//单据状态
        receiveNotice.put("biztime", formatDate(bizData.getString("F0000024"))); // 业务日期
        receiveNotice.put("bookdate", formatDate(bizData.getString("F0000040"))); // 记账日期
        receiveNotice.put("exchangerate", "1");//汇率
        receiveNotice.put("istax", "true");//含税
        receiveNotice.put("exratedate", new SimpleDateFormat("yyyy-MM-dd").format(new Date())); // 汇率日期（取今天）

        // 付款方式: 现购->CASH, 赊购->CREDIT
        String paymodeValue = bizData.getString("F0000044");
        if ("现购".equals(paymodeValue)) {
            receiveNotice.put("paymode", "CASH");
        } else if ("赊购".equals(paymodeValue)) {
            receiveNotice.put("paymode", "CREDIT");
        } else {
            receiveNotice.put("paymode", paymodeValue); // 其他值原样传递
        }

        receiveNotice.put("paycondition_number", h3yunService.getFieldValueById(
                "D293655sxvsttpe7re2tep6gvsdg", bizData.getString("F0000049"), "F0000001"));//付款条件
        receiveNotice.put("paycondition_name", h3yunService.getFieldValueById(
                "D293655sxvsttpe7re2tep6gvsdg", bizData.getString("F0000049"), "F0000002"));//付款条件.名称

        receiveNotice.put("supplier_name", h3yunService.getFieldValueById(
                "D293655b4a0a34e44914aee9613a7bd3957df83", bizData.getString("F0000035"), "F0000001")); // 供应商名称
        receiveNotice.put("supplier_number", h3yunService.getFieldValueById(
                "D293655b4a0a34e44914aee9613a7bd3957df83", bizData.getString("F0000035"), "SeqNo"));  // 供应商编码

//
//        receiveNotice.put("stockorg_number", bizData.getString("F0000005")); // 收料组织
//        receiveNotice.put("dept_number", bizData.getString("F0000006")); // 部门
//        receiveNotice.put("purchaser_number", bizData.getString("F0000007")); // 采购员
//        receiveNotice.put("billtype_number", bizData.getString("F0000008")); // 单据类型
//        receiveNotice.put("comment", bizData.getString("F0000009")); // 备注
//        receiveNotice.put("operator_operatornumber", bizData.getString("CreatedBy")); // 操作人
        String purorderbillnumber = bizData.getString("F0000046"); //物料明细.采购订单号
        //  String project_number = "001"; //项目编码.项目编码
        String r_recsettleorg_number = (String) h3yunService.getFieldValueById(
                "D29365537feb4e5e8644b21b7fd938dd322dab3", bizData.getString("F0000025"), "F0000002");
        receiveNotice.put("org_number", r_recsettleorg_number); // 收料组织.编码

        String bizorg_number = (String) h3yunService.getFieldValueById(
                "D29365537feb4e5e8644b21b7fd938dd322dab3", bizData.getString("F0000036"), "F0000002");
        String bizorg_name = (String) h3yunService.getFieldValueById(
                "D29365537feb4e5e8644b21b7fd938dd322dab3", bizData.getString("F0000036"), "F0000001");

        receiveNotice.put("bizorg_number", bizorg_number);// 采购组织.编码
        receiveNotice.put("bizorg_name", bizorg_name);// 采购组织.名称
        receiveNotice.put("org_name", bizorg_name);//收料组织.名称

        String currency_name = (String) h3yunService.getFieldValueById(
                "D293655f08d8524a8254d35b3681ea527ce2c59", bizData.getString("F0000028"), "F0000002");
        receiveNotice.put("currency_name", currency_name);//本位币.名称

        receiveNotice.put("settlecurrency_name", currency_name);//结算币种.名称


        String settlecurrency_number = (String) h3yunService.getFieldValueById(
                "D293655f08d8524a8254d35b3681ea527ce2c59", bizData.getString("F0000028"), "F0000001"); //结算币种.货币代码
        receiveNotice.put("settlecurrency_number", settlecurrency_number);//结算币种.货币代码
        receiveNotice.put("currency_number", settlecurrency_number);//本位币.货币代码


        receiveNotice.put("operatorgroup_name", "库管组");//库管组.名称
        receiveNotice.put("operatorgroup_number", "KG-01");//库管组.编码
        receiveNotice.put("billtype_name", "标准采购收料单");//单据类型.名称
        receiveNotice.put("settletype_number", h3yunService.getFieldValueById(
                "D293655skrwqen4wv0g7je4itf", bizData.getString("F0000050"), "F0000001"));//结算方式.编码
        receiveNotice.put("settletype_name", h3yunService.getFieldValueById(
                "D293655skrwqen4wv0g7je4itf", bizData.getString("F0000050"), "F0000002"));//结算方式.名称
        receiveNotice.put("bizoperator_operatornumber", h3yunService.getFieldValueById(
                "D2936556a05fbb0350545cc9d8bd70901b1ed3b", bizData.getString("F0000042"), "F0000001"));//采购员;
        receiveNotice.put("invscheme_name", "普通采购收料待检入库");//库存事务.名称
        receiveNotice.put("invscheme_number", "113");//库存事务.编码
        receiveNotice.put("bizdept_name", "采购部");//采购部门.名称
        receiveNotice.put("bizdept_number", "Org-00011");//	采购部门.编码
        receiveNotice.put("dept_name", "采购部");//库管部门.名称
        receiveNotice.put("dept_number", "Org-00011");//	库管部门.编码

        receiveNotice.put("billtype_number", "im_purreceivebill_STD_BT_S"); // 单据类型.编码
//        receiveNotice.put("billtype_name", "标准采购收料单");//单据类型.名称


        // 物料明细
        List<Map<String, Object>> entryList = new ArrayList<>();
        JSONArray billentryArray = bizData.getJSONArray("D293655sjorvnmku3t3cpdup");
        if (billentryArray != null && !billentryArray.isEmpty()) {
            for (int i = 1; i <= billentryArray.size(); i++) {
                JSONObject entryData = billentryArray.getJSONObject(i - 1);
                Map<String, Object> entry = new LinkedHashMap<>();
                String uuidHex = entryData.getString("ObjectId").replace("-", "");
// 取后16位（64bit），解析为无符号long，避免溢出和负数问题
                long id = Long.parseUnsignedLong(uuidHex.substring(uuidHex.length() - 16), 16);
                entry.put("id", id);
                // entry.put("seq", i);
                entry.put("qty", entryData.getDouble("F0000017")); // 数量
                entry.put("baseqty", entryData.getDouble("F0000017")); // 物料明细.基本数量
                entry.put("linetype_number", "010");
                entry.put("discounttype", "NULL"); //物料明细.折扣方式 A:折扣率(%), B:单位折扣额, NULL:无
                entry.put("ownertype", "bd_supplier");//物料明细.入库货主类型 bos_org:业务组织, bd_supplier:供应商, bd_customer:客户
                entry.put("keepertype", "bos_org");//物料明细.入库保管者类型 bos_org:库存组织, bd_supplier:供应商, bd_customer:客户
                entry.put("outownertype", "bd_supplier");//物料明细.出库货主库货主类型 bos_org:业务组织, bd_supplier:供应商, bd_customer:客户
                entry.put("outkeepertype", "bos_org");//物料明细.出库保管者类型 bos_org:库存组织, bd_supplier:供应商, bd_customer:客户
                entry.put("unit_number", h3yunService.getFieldValueById("D293655248b1d9bf6c448f0a291341ec58bb943", entryData.getString("F0000032"), "F0000001")); // 单位
                entry.put("baseunit_number", h3yunService.getFieldValueById(
                        "D293655248b1d9bf6c448f0a291341ec58bb943", entryData.getString("F0000032"), "F0000001"));//基本单位.编码
                entry.put("baseunit_name", h3yunService.getFieldValueById(
                        "D293655248b1d9bf6c448f0a291341ec58bb943", entryData.getString("F0000032"), "F0000002"));//基本单位.名称
               // entry.put("price", entryData.getDouble("F0000043")); // 物料明细.单价
                entry.put("priceandtax", entryData.getDouble("F0000043")); // 物料明细.含税单价
                //entry.put("taxrate", entryData.getDouble("F0000016"));//物料明细.税率%
//                entry.put("amount", entryData.getDouble("F0000018"));//物料明细.金额
//                entry.put("amountandtax", entryData.getDouble("F0000018"));//物料明细.价税合计
                // entry.put("taxamount", entryData.getDouble("F0000045"));//物料明细.税额

                entry.put("purorderbillnumber", purorderbillnumber); //物料明细.采购订单号
//                entry.put("project_number", project_number);//项目编码.项目编码invstatus_number
//                entry.put("mpmtaskno_number", project_number);
                ;//项目任务号.项目任务号

                entry.put("invtype_number", "112");//入库库存类型.编码
                entry.put("invstatus_number", "111");//入库库存状态.编码
                entry.put("invtype_name", "供应商待检");//入库库存类型.名称
                entry.put("invstatus_name", "待检");//入库库存状态.名称

                //        entry.put("location_number", "默认仓位");

                entry.put("owner_number", h3yunService.getFieldValueById(
                        "D293655b4a0a34e44914aee9613a7bd3957df83", bizData.getString("F0000035"), "SeqNo")); // 入库货主.编码
                entry.put("keeper_number", r_recsettleorg_number);//	入库保管者.编码
                // entry.put("ecostcenter_number", h3yunService.getFieldValueById(
                //   "D293655swtap3brxkofsiqxb8q7", bizData.getString("F0000052"), "F0000001"));//成本中心.编码
                entry.put("entrysettleorg_number", r_recsettleorg_number);//结算组织.编码
                entry.put("entryreqorg_number", r_recsettleorg_number);//需求组织.编码
                entry.put("outowner_number", h3yunService.getFieldValueById(
                        "D293655b4a0a34e44914aee9613a7bd3957df83", bizData.getString("F0000035"), "SeqNo"));//出库货主.编码
                entry.put("outkeeper_number", r_recsettleorg_number);//出库保管者.编码
//                entry.put("unit3rd_number", h3yunService.getFieldValueById(
//                        "D293655248b1d9bf6c448f0a291341ec58bb943", entryData.getString("F0000032"), "F0000001"));//辅助单位(2).编码

                entry.put("purunit_number", h3yunService.getFieldValueById(
                        "D293655248b1d9bf6c448f0a291341ec58bb943", entryData.getString("F0000032"), "F0000001"));//采购单位.编码
                entry.put("unit_number", h3yunService.getFieldValueById(
                        "D293655248b1d9bf6c448f0a291341ec58bb943", entryData.getString("F0000032"), "F0000001"));//库存单位.编码
                entry.put("warehouse_number", h3yunService.getFieldValueById(
                        "D293655scvrhqr64jemxdkqk6gf", entryData.getString("F0000033"), "SeqNo"));//仓库


                entry.put("taxrateid_number", h3yunService.getFieldValueById(
                        "D293655sl91vt6h8d0qg1heqw5aq", entryData.getString("F0000047"), "F0000001"));//税率.编码

                entry.put("providersupplier_number", h3yunService.getFieldValueById(
                        "D293655b4a0a34e44914aee9613a7bd3957df83", bizData.getString("F0000035"), "SeqNo"));//订货供应商.编码

                entry.put("invoicesupplier_number", h3yunService.getFieldValueById(
                        "D293655b4a0a34e44914aee9613a7bd3957df83", bizData.getString("F0000035"), "SeqNo"));//结算供应商.编码

                entry.put("receivesupplier_number", h3yunService.getFieldValueById(
                        "D293655b4a0a34e44914aee9613a7bd3957df83", bizData.getString("F0000035"), "SeqNo"));//收款供应商.编码
                entry.put("insporg_number", r_recsettleorg_number);//质检组织.编码
                entry.put("material_masterid_number", h3yunService.getFieldValueById(
                        "D293655fc1a38f7956f400a886f376911a54a30", entryData.getString("F0000030"), "SeqNo"));//物料编码.编码

//                entry.put("outkeeper_number", h3yunService.getFieldValueById(
//                        "D2936556a05fbb0350545cc9d8bd70901b1ed3b", entryData.getString("F0000051"), "F0000001"));//出库保管者.编码


                //收料通知单关联采购订单
                entry.put("srcbillentity", "pm_purorderbill");//物料明细.来源单据实体

                entry.put("srcbillid", h3yunService.getFieldValueById(
                        "D2936559700b1d66a0e4ee69a84e13da8dbbe95", bizData.getString("F0000037"), "K3id"));//物料明细.来源单据ID
                String uuidHexa = entryData.getString("F0000053").replace("-", "");
                // 取后16位（64bit），解析为无符号long，避免溢出和负数问题
                long ida = Long.parseUnsignedLong(uuidHexa.substring(uuidHexa.length() - 16), 16);

                entry.put("srcbillentryid", ida);//物料明细.来源系统单据分录ID
                entry.put("srcbillnumber", h3yunService.getFieldValueById(
                        "D2936559700b1d66a0e4ee69a84e13da8dbbe95", bizData.getString("F0000037"), "SeqNo"));//物料明细.来源单据编号
                //  entry.put("srcbillentryseq", i);//物料明细.来源单据分录序号 	"1"


                entry.put("mainbillentity", "pm_purorderbill");//物料明细.来源单据实体

                entry.put("mainbillid", h3yunService.getFieldValueById(
                        "D2936559700b1d66a0e4ee69a84e13da8dbbe95", bizData.getString("F0000037"), "K3id"));//物料明细.来源单据ID
                entry.put("mainbillentryid", ida);//物料明细.来源系统单据分录ID
                entry.put("mainbillnumber", h3yunService.getFieldValueById(
                        "D2936559700b1d66a0e4ee69a84e13da8dbbe95", bizData.getString("F0000037"), "SeqNo"));//物料明细.来源单据编号


//                entry.put("srcsystem", "8upAr");
//                entry.put("srcsysbillid", "pt08C");
//                entry.put("srcsysbillentryid", "sYtFo");
//                entry.put("srcsysbillno", "DyiB7");//物料明细.来源单据编号

                List<Map<String, Object>> lkList = new ArrayList<>();
                Map<String, Object> lkEntry = new LinkedHashMap<>();
                lkEntry.put("billentry_lk_stableid", "602924326097811460");
                lkEntry.put("billentry_lk_sbillid", h3yunService.getFieldValueById(
                        "D2936559700b1d66a0e4ee69a84e13da8dbbe95", bizData.getString("F0000037"), "K3id"));
                lkEntry.put("billentry_lk_sid", ida);
                lkList.add(lkEntry);
                entry.put("billentry_lk", lkList);


                entryList.add(entry);


            }
        }
        receiveNotice.put("billentry", entryList);

        dataList.add(receiveNotice);
        data.put("data", dataList);
        return data;
    }

    /**
     * 提取采购退料申请数据（金蝶API格式）
     * 返回格式: {"data":[{"billno":"...","supplier_number":"...","purreturnentry":[...]}]}
     */
    @SuppressWarnings("unchecked")
    private Map<String, Object> extractPurchaseReturnData(JSONObject bizData) {
        Map<String, Object> data = new HashMap<>();
        List<Map<String, Object>> dataList = new ArrayList<>();
        Map<String, Object> returnRequest = new LinkedHashMap<>();

        // 头部信息
        returnRequest.put("billno", bizData.getString("SeqNo")); // 单据编号
        returnRequest.put("trdbillno", bizData.getString("SeqNo")); // 单据编号
        returnRequest.put("org_number", bizData.getString("F0000049")); // 采购组织编码

        returnRequest.put("billtype_number", bizData.getString("F0000023")); // 单据类型.编码
        returnRequest.put("biztype_number", bizData.getString("F0000022")); // 业务类型.编码
        returnRequest.put("supplier_number", bizData.getString("F0000050")); // 订货供应商.编码
        String paymodeValue = bizData.getString("F0000055");// 付款方式 CASH:现购, CREDIT:赊购
        if ("现购".equals(paymodeValue)) {
            returnRequest.put("paymode", "CASH");
        } else if ("赊购".equals(paymodeValue)) {
            returnRequest.put("paymode", "CREDIT");
        } else {
            returnRequest.put("paymode", paymodeValue); // 其他值原样传递
        }

        returnRequest.put("settlecurrency_number", bizData.getString("F0000057")); // 结算币别.货币代码
        returnRequest.put("exratetable_number", "ERT-01"); // 汇率表.编码
        returnRequest.put("exchangerate", "1"); // 汇率
        returnRequest.put("biztime", formatDate(bizData.getString("F0000024"))); // 申请日期
        returnRequest.put("comment", bizData.getString("F0000054")); // 备注


        // 分录信息 purreturnentry
        List<Map<String, Object>> entryList = new ArrayList<>();
        JSONArray billentryArray = bizData.getJSONArray("D293655slxu6vngtqkcopxf6fl");
        if (billentryArray != null && !billentryArray.isEmpty()) {
            for (int i = 0; i < billentryArray.size(); i++) {
                JSONObject entryData = billentryArray.getJSONObject(i);
                Map<String, Object> entry = new LinkedHashMap<>();
                entry.put("linetype_number", "010");
                String returnmaterialtype = entryData.getString("F0000046");
                if ("退料".equals(returnmaterialtype)) {
                    entry.put("returnmaterialtype", "1");
                } else if ("退补料".equals(returnmaterialtype)) {
                    entry.put("returnmaterialtype", "2");
                }

                entry.put("discounttype", "NULL"); // 物料明细.折扣方式 A:折扣率(%), B:单位折扣额, NULL:无
                entry.put("qty", entryData.getDouble("F0000060")); // 退料数量
                entry.put("material_number", entryData.getString("F0000031")); // 商品编码
                entry.put("unit_number", entryData.getString("F0000058")); // 采购单位.编码
                entry.put("entryinvcorg_number", bizData.getString("F0000049")); // 库存组织.编码
                entry.put("entrysettleorg_number", bizData.getString("F0000049")); // 库存组织.编码
                entry.put("entryreqorg_number", bizData.getString("F0000049")); // 库存组织.编码


                //退料申请单关联采购入库单
                entry.put("srcbillentity", "im_purinbill");//物料明细.来源单据实体

                entry.put("srcbillid", h3yunService.getFieldValueById(
                        "D293655srqj5uui3keso9oraeqm", bizData.getString("F0000044"), "F0000038"));//物料明细.来源单据ID
                entry.put("srcbillnumber", h3yunService.getFieldValueById(
                        "D293655srqj5uui3keso9oraeqm", bizData.getString("F0000044"), "F0000041"));//物料明细.来源单据编号

                long ida = Long.parseUnsignedLong(entryData.getString("F0000061"));

                entry.put("srcbillentryid", ida);//物料明细.来源系统单据分录ID
                entry.put("mainbillentity", "im_purinbill");
                entry.put("mainbillid", h3yunService.getFieldValueById(
                        "D293655srqj5uui3keso9oraeqm", bizData.getString("F0000044"), "F0000038"));

                entry.put("mainbillnumber", ida);
                entry.put("mainbillentryid", h3yunService.getFieldValueById(
                        "D293655srqj5uui3keso9oraeqm", bizData.getString("F0000044"), "F0000041"));//物料明细.来源单据编号

                entry.put("price", entryData.getDouble("F0000066"));//单价
              entry.put("priceandtax", entryData.getDouble("F0000066"));//含税单价

                entry.put("taxrateid_number", h3yunService.getFieldValueById(
                        "D293655sl91vt6h8d0qg1heqw5aq", entryData.getString("F0000065"), "F0000001"));//F0000065

                List<Map<String, Object>> lkList = new ArrayList<>();
                Map<String, Object> lkEntry = new LinkedHashMap<>();
                lkEntry.put("billentry_lk_stableid", "602924315385558018");
                lkEntry.put("billentry_lk_sbillid", h3yunService.getFieldValueById(
                        "D293655srqj5uui3keso9oraeqm", bizData.getString("F0000044"), "F0000038"));
                lkEntry.put("billentry_lk_sid", ida);
                lkList.add(lkEntry);
                entry.put("billentry_lk", lkList);

                entryList.add(entry);
            }
        }
        returnRequest.put("billentry", entryList);

        dataList.add(returnRequest);
        data.put("data", dataList);
        return data;
    }

    /**
     * 提取发货通知单数据（金蝶API格式）
     * 返回格式: {"data":[{"billno":"...","customer_number":"...","deliverynoticeentry":[...]}]}
     */
    @SuppressWarnings("unchecked")
    private Map<String, Object> extractDeliveryNoticeData(JSONObject bizData) {
        Map<String, Object> data = new HashMap<>();
        List<Map<String, Object>> dataList = new ArrayList<>();
        Map<String, Object> deliveryNotice = new LinkedHashMap<>();

        // 头部信息
        deliveryNotice.put("billno", bizData.getString("SeqNo")); // 单据编号
        //  deliveryNotice.put("trdbillno", bizData.getString("SeqNo"));

        deliveryNotice.put("deliverorg_number", h3yunService.getFieldValueById(
                "D29365537feb4e5e8644b21b7fd938dd322dab3", bizData.getString("F0000018"), "F0000002")); // 发货组织.编码
        deliveryNotice.put("billtype_number", "sm_delivernotice_STD_BT_S"); // 单据类型.编码
        deliveryNotice.put("bizdate", formatDate(bizData.getString("F0000021"))); // 通知日期
        deliveryNotice.put("customer_number", h3yunService.getFieldValueById(
                "D293655shuyz9ttzgkgmhaa4rglr", bizData.getString("F0000024"), "SeqNo")); // 订货客户.编码
        deliveryNotice.put("org_number", h3yunService.getFieldValueById(
                "D29365537feb4e5e8644b21b7fd938dd322dab3", bizData.getString("F0000049"), "F0000002")); // 销售组织.编码
        deliveryNotice.put("al95_customer_number", h3yunService.getFieldValueById(//店铺.编码
                "D293655shuyz9ttzgkgmhaa4rglr", bizData.getString("F0000023"), "SeqNo"));
        deliveryNotice.put("al95_customer_name", h3yunService.getFieldValueById(//店铺.名称
                "D293655shuyz9ttzgkgmhaa4rglr", bizData.getString("F0000023"), "F0000001"));
        deliveryNotice.put("al95_assistantfield_number", h3yunService.getFieldValueById(//物流公司.编码
                "D293655sdfmyisqk1us9gqj1bljt", bizData.getString("F0000053"), "F0000001"));
        deliveryNotice.put("al95_assistantfield_name", h3yunService.getFieldValueById(//物流公司.名称
                "D293655sdfmyisqk1us9gqj1bljt", bizData.getString("F0000053"), "F0000001"));

        deliveryNotice.put("al95_textfield2", bizData.getString("F0000060"));//收货人联系电话
        deliveryNotice.put("al95_textfield1", bizData.getString("F0000058"));//收货人
        deliveryNotice.put("al95_textfield", bizData.getString("F0000059"));//收货人地址

        deliveryNotice.put("reccondition_number", h3yunService.getFieldValueById(//物流公司.名称
                "D293655sv6bv8bozikwrkze3rk1", bizData.getString("F0000067"), "F0000001"));//收款条件.编号


//        deliveryNotice.put("saleser_number", bizData.getString("F0000007")); // 销售员
//        deliveryNotice.put("srcbillno", bizData.getString("F0000008")); // 源单编号
//        deliveryNotice.put("comment", bizData.getString("F0000009")); // 备注
//        deliveryNotice.put("operator_operatornumber", bizData.getString("CreatedBy")); // 操作人

        // 分录信息 deliverynoticeentry
        List<Map<String, Object>> entryList = new ArrayList<>();
        JSONArray billentryArray = bizData.getJSONArray("D293655sbvihadlhlkeoi30zoi8n");
        if (billentryArray != null && !billentryArray.isEmpty()) {
            for (int i = 0; i < billentryArray.size(); i++) {
                JSONObject entryData = billentryArray.getJSONObject(i);
                Map<String, Object> entry = new LinkedHashMap<>();
                entry.put("qty", entryData.getDouble("F0000031")); // 数量
                entry.put("producttype", "standard");//物料明细.产品类别 standard:标准产品, kitparent:套件父项, kitchild:套件子项

                entry.put("linetype_number", "010"); // 物料编码

                entry.put("deliverydate1", formatDate(entryData.getString("F0000052")));//物料明细.要货日期
                entry.put("material_number", h3yunService.getFieldValueById(
                        "D293655fc1a38f7956f400a886f376911a54a30", entryData.getString("F0000027"), "SeqNo"));//物料编码.编码
                entry.put("unit_number", h3yunService.getFieldValueById(
                        "D293655248b1d9bf6c448f0a291341ec58bb943", entryData.getString("F0000030"), "F0000001"));//单位编码.编码

                entry.put("warehouse_number", h3yunService.getFieldValueById(
                        "D293655scvrhqr64jemxdkqk6gf", entryData.getString("F0000061"), "SeqNo"));//仓库.编码

                entry.put("price", entryData.getDouble("F0000062"));//
                entry.put("priceandtax", entryData.getDouble("F0000062"));//
                entry.put("discounttype", "NULL");

                //发货通知单关联销售订单
                String uuidHex = entryData.getString("F0000054").replace("-", "");
                long ida = Long.parseUnsignedLong(uuidHex.substring(uuidHex.length() - 16), 16);
                entry.put("srcbillentity", "sm_salorder");//物料明细.来源单据实体
                entry.put("srcbillid", h3yunService.getFieldValueById(
                        "D29365523b214414c2b4e50b9bdca110a9a5951", bizData.getString("F0000050"), "K3id"));//物料明细.来源单据ID
                entry.put("srcbillnumber", h3yunService.getFieldValueById(
                        "D29365523b214414c2b4e50b9bdca110a9a5951", bizData.getString("F0000050"), "SeqNo"));//物料明细.来源单据编号
                entry.put("srcbillentryid", ida);//物料明细.来源系统单据分录ID

                entry.put("mainbillentity", "sm_salorder");
                entry.put("mainbillid", h3yunService.getFieldValueById(
                        "D29365523b214414c2b4e50b9bdca110a9a5951", bizData.getString("F0000050"), "K3id"));
                entry.put("mainbillentryid", ida);
                entry.put("mainbillnumber", h3yunService.getFieldValueById(
                        "D29365523b214414c2b4e50b9bdca110a9a5951", bizData.getString("F0000050"), "SeqNo"));//物料明细.来源单据编号
                List<Map<String, Object>> lkList = new ArrayList<>();
                Map<String, Object> lkEntry = new LinkedHashMap<>();
                lkEntry.put("billentry_lk_stableid", "602924332909361155");
                lkEntry.put("billentry_lk_sbillid", h3yunService.getFieldValueById(
                        "D29365523b214414c2b4e50b9bdca110a9a5951", bizData.getString("F0000050"), "K3id"));
                lkEntry.put("billentry_lk_sid", ida);
                lkList.add(lkEntry);
                entry.put("billentry_lk", lkList);


//
//                entry.put("deliverydate", formatDate(entryData.getString("F0000014"))); // 交货日期
//                entry.put("deliveryaddress", entryData.getString("F0000015")); // 交货地址
//                entry.put("warehouse_number", entryData.getString("F0000016")); // 仓库
//                entry.put("entrycomment", entryData.getString("F0000017")); // 分录备注
                entryList.add(entry);
            }
        }
        deliveryNotice.put("billentry", entryList);

        dataList.add(deliveryNotice);
        data.put("data", dataList);
        return data;
    }

    /**
     * 提取退货申请单数据（金蝶API格式）
     * 返回格式: {"data":[{"billno":"...","customer_number":"...","returnrequestentry":[...]}]}
     */
    @SuppressWarnings("unchecked")
    private Map<String, Object> extractReturnRequestData(JSONObject bizData) {
        Map<String, Object> data = new HashMap<>();
        List<Map<String, Object>> dataList = new ArrayList<>();
        Map<String, Object> returnRequest = new LinkedHashMap<>();

        // 头部信息
        returnRequest.put("billno", bizData.getString("SeqNo")); // 单据编号
        returnRequest.put("trdbillno", bizData.getString("SeqNo")); // 单据编号
        returnRequest.put("billtype_number", "sm_returnapply_BT_S"); // 单据类型.编码
        returnRequest.put("bizdate", formatDate(bizData.getString("F0000021"))); // 申请日期
        returnRequest.put("org_number", h3yunService.getFieldValueById(
                "D29365537feb4e5e8644b21b7fd938dd322dab3", bizData.getString("F0000018"), "F0000002")); // 销售组织.编码

        returnRequest.put("biztype_number", "2101"); //业务类型.编码  物料类销售退货-2101
        returnRequest.put("settlecurrency_number", h3yunService.getFieldValueById(
                "D293655f08d8524a8254d35b3681ea527ce2c59", bizData.getString("F0000025"), "F0000001")); // 结算币别.货币代码
        returnRequest.put("customer_number", h3yunService.getFieldValueById(
                "D293655shuyz9ttzgkgmhaa4rglr", bizData.getString("F0000024"), "SeqNo")); //退货客户.编码
//        returnRequest.put("reason", bizData.getString("F0000008")); // 退货原因
//        returnRequest.put("comment", bizData.getString("F0000009")); // 备注
//        returnRequest.put("operator_operatornumber",


        returnRequest.put("al95_assistantfield_number", h3yunService.getFieldValueById(
                "D293655sdfmyisqk1us9gqj1bljt", bizData.getString("F0000063"), "F0000001")); //物流公司.编码
        returnRequest.put("al95_assistantfield_name", h3yunService.getFieldValueById(
                "D293655sdfmyisqk1us9gqj1bljt", bizData.getString("F0000063"), "F0000011"));//物流公司.名称
        returnRequest.put("al95_customer_number", h3yunService.getFieldValueById(
                "D293655shuyz9ttzgkgmhaa4rglr", bizData.getString("F0000023"), "SeqNo")); //退货店铺.编码
        returnRequest.put("al95_customer_name", h3yunService.getFieldValueById(
                "D293655shuyz9ttzgkgmhaa4rglr", bizData.getString("F0000023"), "F0000001"));//	退货店铺.名称
        // 分录信息 returnrequestentry
        List<Map<String, Object>> entryList = new ArrayList<>();
        JSONArray billentryArray = bizData.getJSONArray("D293655svwzidlwioks0vvylbsxl");
        if (billentryArray != null && !billentryArray.isEmpty()) {
            for (int i = 0; i < billentryArray.size(); i++) {
                JSONObject entryData = billentryArray.getJSONObject(i);
                Map<String, Object> entry = new LinkedHashMap<>();
                // entry.put("id", entryData.getString("ObjectId").replace("-", ""));//id
                String uuidHex = entryData.getString("ObjectId").replace("-", "");
// 取后16位（64bit），解析为无符号long，避免溢出和负数问题
                long id = Long.parseUnsignedLong(uuidHex.substring(uuidHex.length() - 16), 16);
                entry.put("id", id);

                entry.put("qty", entryData.getDouble("F0000031")); // 数量
                entry.put("linetype_number", entryData.getString("F0000026")); // 行类型-物资编码
                entry.put("material_number", h3yunService.getFieldValueById(
                        "D293655fc1a38f7956f400a886f376911a54a30", entryData.getString("F0000027"), "SeqNo")); // 物料编码.编码

                entry.put("unit_number", h3yunService.getFieldValueById(
                        "D293655248b1d9bf6c448f0a291341ec58bb943", entryData.getString("F0000030"), "F0000001")); //销售单位.编码

                entry.put("entryinvorg_number", h3yunService.getFieldValueById(
                        "D29365537feb4e5e8644b21b7fd938dd322dab3", bizData.getString("F0000049"), "F0000002")); // 库存组织.编码
                entry.put("entrysettleorg_number", h3yunService.getFieldValueById(
                        "D29365537feb4e5e8644b21b7fd938dd322dab3", bizData.getString("F0000049"), "F0000002")); // 结算组织.编码

                entry.put("al95_", entryData.getString("F0000069"));//物料明细.明细-订单号
                entry.put("al95_1", entryData.getString("F0000068"));
                ;//物料明细.明细-原始单号


                //退货申请单关联销售出库单
                entry.put("srcbillentity", "im_saloutbill");//物料明细.来源单据实体

                entry.put("srcbillid", h3yunService.getFieldValueById(
                        "D293655suomjudbplkoxrgs42dqj", bizData.getString("F0000058"), "K3id"));//物料明细.来源单据ID
                entry.put("srcbillnumber", h3yunService.getFieldValueById(
                        "D293655suomjudbplkoxrgs42dqj", bizData.getString("F0000058"), "F0000053"));//物料明细.来源单据编号

                long ida = Long.parseUnsignedLong(entryData.getString("F0000064"));

                entry.put("srcbillentryid", ida);//物料明细.来源系统单据分录ID
                entry.put("mainbillentity", "im_saloutbill");
                entry.put("mainbillid", h3yunService.getFieldValueById(
                        "D293655suomjudbplkoxrgs42dqj", bizData.getString("F0000058"), "K3id"));

                entry.put("mainbillnumber", ida);
                entry.put("mainbillentryid", h3yunService.getFieldValueById(
                        "D293655suomjudbplkoxrgs42dqj", bizData.getString("F0000058"), "F0000053"));//物料明细.来源单据编号
                List<Map<String, Object>> lkList = new ArrayList<>();
                Map<String, Object> lkEntry = new LinkedHashMap<>();
                lkEntry.put("billentry_lk_stableid", "602924300688717826");
                lkEntry.put("billentry_lk_sbillid", h3yunService.getFieldValueById(
                        "D293655suomjudbplkoxrgs42dqj", bizData.getString("F0000058"), "K3id"));
                lkEntry.put("billentry_lk_sid", ida);
                lkList.add(lkEntry);
                entry.put("billentry_lk", lkList);


                entryList.add(entry);
            }
        }
        returnRequest.put("billentry", entryList);

        dataList.add(returnRequest);
        data.put("data", dataList);
        return data;
    }

    /**
     * 提取付款申请单数据（金蝶API格式）
     * 返回格式: {"data":[{"billno":"...","payerorg_number":"...","cn_payableentry":[...]}]}
     */
    @SuppressWarnings("unchecked")
    private Map<String, Object> extractPaymentRequestData(JSONObject bizData) {
        Map<String, Object> data = new HashMap<>();
        List<Map<String, Object>> dataList = new ArrayList<>();
        Map<String, Object> paymentRequest = new LinkedHashMap<>();

        // 头部信息
        paymentRequest.put("billno", bizData.getString("SeqNo")); // 单据编号
        paymentRequest.put("trdbillno", bizData.getString("SeqNo"));//第三方业务编码（防止重复新增，每次新增需要传入唯一值）
        paymentRequest.put("bizdate", formatDate(bizData.getString("F0000016"))); // 业务日期

        // paymentRequest.put("applydate", formatDate(bizData.getString("F0000037"))); // 申请日期
        paymentRequest.put("payeetype", "bd_supplier"); // 收款单位类型：bos_org：公司，bd_supplier：供应商，bd_customer：客户，bos_user：人员，other：其他，cas_ot\

        paymentRequest.put("itempayeetype", "bd_supplier"); // 收款单位类型（多类别基础资料类型）：bos_org：公司，bd_supplier：供应商，bd_customer：客户，bos_user：人员，cas_other：其他，cas_othercontactunit：其他往来单位
        paymentRequest.put("billtype_number", "cas_paybill_pur_BT_S");//单据类型.编码
//        paymentRequest.put("applyorg_number", h3yunService.getFieldValueById(
//                "D29365537feb4e5e8644b21b7fd938dd322dab3", bizData.getString("F0000014"), "F0000002"));//结算组织.编码
        paymentRequest.put("settleorg_number", h3yunService.getFieldValueById(
                "D29365537feb4e5e8644b21b7fd938dd322dab3", bizData.getString("F0000019"), "F0000002"));//结算组织.编码

        paymentRequest.put("currency_number", h3yunService.getFieldValueById(
                "D293655f08d8524a8254d35b3681ea527ce2c59", bizData.getString("F0000031"), "F0000001"));//付款币别.id


        paymentRequest.put("payeebanknum", h3yunService.getFieldValueById(
                "D293655Fb2deb81ad33c41e4bac91630e399d141", bizData.getString("F0000042"), "F0000027"));//收款账号

        paymentRequest.put("usage", bizData.getString("F0000043"));//转账附言


        String exratetable_number = bizData.getString("F0000038");
        if ("预算汇率".equals(exratetable_number)) {
            exratetable_number = "BMERT-01_SYS";
        } else {
            exratetable_number = "ERT-01";
        }
        paymentRequest.put("exratetable_number", exratetable_number);

        paymentRequest.put("payeenumber", h3yunService.getFieldValueById(
                "D293655b4a0a34e44914aee9613a7bd3957df83", bizData.getString("F0000002"), "SeqNo"));//收款单位编码
        paymentRequest.put("itempayee_number", h3yunService.getFieldValueById(
                "D293655b4a0a34e44914aee9613a7bd3957df83", bizData.getString("F0000002"), "SeqNo"));//收款单位.编码

        paymentRequest.put("actpayamt", bizData.getDouble("F0000012")); // 付款金额
        paymentRequest.put("paymentidentify_id", "1307961534361723904");//FKBS01
        paymentRequest.put("exchangerate", "1");//付款汇率
        paymentRequest.put("settletype_number", h3yunService.getFieldValueById(
                "D293655skrwqen4wv0g7je4itf", bizData.getString("F0000028"), "F0000001"));//结算方式.编码
//        paymentRequest.put("settlecurrency_number", h3yunService.getFieldValueById(
//                "D293655f08d8524a8254d35b3681ea527ce2c59", bizData.getString("F0000031"), "F0000001"));//结算币别.货币代码
//        paymentRequest.put("paycurrency_number", h3yunService.getFieldValueById(
//                "D293655f08d8524a8254d35b3681ea527ce2c59", bizData.getString("F0000031"), "F0000001"));//付款币别.货币代码
//
        paymentRequest.put("description", bizData.getString("F0000018")); // 摘要-备注
//
//        paymentRequest.put("supplier_number", bizData.getString("F0000004")); // 供应商编码
//
//
//        paymentRequest.put("paymode", bizData.getString("F0000007")); // 付款方式
//        paymentRequest.put("bank_number", bizData.getString("F0000008")); // 银行编码
//        paymentRequest.put("bankaccount", bizData.getString("F0000009")); // 银行账号
//        paymentRequest.put("comment", bizData.getString("F0000010")); // 备注
//        paymentRequest.put("operator_operatornumber", bizData.getString("CreatedBy")); // 操作人


        // 分录信息 cn_payableentry
        List<Map<String, Object>> entryList = new ArrayList<>();
        JSONArray billentryArray = bizData.getJSONArray("D293655F51615cc524e746388f8ac7fe290b57a3");
        if (billentryArray != null && !billentryArray.isEmpty()) {
            for (int i = 0; i < billentryArray.size(); i++) {
                JSONObject entryData = billentryArray.getJSONObject(i);
                Map<String, Object> entry = new LinkedHashMap<>();
                // entry.put("id", i);
                // entry.put("e_paymenttype_number", "180908615723421696"); // 付款用途.id
                entry.put("e_paymenttype_number", "201"); // 付款用途.编码
                entry.put("e_actamt", entryData.getDouble("F0000024")); // 分录.实付金额
                entry.put("e_payableamt", entryData.getDouble("F0000024"));//分录.应付金额
//                entry.put("taxrate", h3yunService.getFieldValueById(
//                        "D293655sl91vt6h8d0qg1heqw5aq", entryData.getString("F0000044"), "F0000001"));//分录.税率（%）
                entry.put("taxrate", entryData.getDouble("F0000029"));//分录.税率（%）
                entry.put("taxamt", entryData.getDouble("F0000030"));//分录.税额
                entry.put("expectdate", formatDate(entryData.getString("F0000026")));//期望付款日期

                String uuidHex = entryData.getString("F0000034").replace("-", "");
                long id = Long.parseUnsignedLong(uuidHex.substring(uuidHex.length() - 16), 16);

                if ("货到付款".equals(bizData.getString("F0000032"))) {
                    List<Map<String, Object>> lkList = new ArrayList<>();
                    Map<String, Object> lkEntry = new LinkedHashMap<>();
                    lkEntry.put("entry_lk_stableid", "577639813562251264");
                    lkEntry.put("entry_lk_sbillid", h3yunService.getFieldValueById(
                            "D293655sykmx68818kivnjmwwgus", bizData.getString("F0000001"), "K3id"));
                    lkEntry.put("entry_lk_sid", id);
                    lkList.add(lkEntry);
                    entry.put("entry_lk", lkList);


                } else if ("预付款".equals(bizData.getString("F0000032"))) {

                    entry.put("e_corebilltype", "pm_purorderbill");//分录.核心单据类型 sctm_scpo:委外采购订单, ec_contract:建筑支出合同, conm_salcontract:销售合同, er_dailyloanbill:借款单, conm_purcontract:采购合同, sm_salorder:销售订单, pm_purorderbill:采购订单
                    entry.put("e_corebilltype_title", "采购订单");//固定
                    entry.put("e_corebillentryseq", 0);//固定
                    entry.put("e_corebillno", h3yunService.getFieldValueById(
                            "D2936559700b1d66a0e4ee69a84e13da8dbbe95", bizData.getString("F0000033"), "SeqNo"));//采购订单编号

                    entry.put("e_corebillid", h3yunService.getFieldValueById(
                            "D2936559700b1d66a0e4ee69a84e13da8dbbe95", bizData.getString("F0000033"), "K3id"));//采购订单主表ID

                    entry.put("e_corebillentryid", id);//采购订单明细ID
                    List<Map<String, Object>> lkList = new ArrayList<>();
                    Map<String, Object> lkEntry = new LinkedHashMap<>();
                    lkEntry.put("entry_lk_stableid", "602924326097811460");
                    lkEntry.put("entry_lk_sbillid", h3yunService.getFieldValueById(
                            "D2936559700b1d66a0e4ee69a84e13da8dbbe95", bizData.getString("F0000033"), "K3id"));
                    lkEntry.put("entry_lk_sid", id);
                    lkList.add(lkEntry);
                    entry.put("entry_lk", lkList);


                }


//                entry.put("e_asstacttype", "bd_supplier");//明细.往来单位类型 bd_supplier:供应商, bos_user:人员, bos_org:公司, bd_customer:客户, cas_othercontactunit:其他往来单位
//                entry.put("e_asstact_number",  h3yunService.getFieldValueById(
//                        "D293655b4a0a34e44914aee9613a7bd3957df83", bizData.getString("F0000002"), "SeqNo"));//明细.往来单位
//                entry.put("e_rectunittype", "bd_supplier");//明细.往来单位类型 bd_supplier:供应商, bos_user:人员, bos_org:公司, bd_customer:客户, cas_othercontactunit:其他往来单位
//                entry.put("e_rectunit_number",  h3yunService.getFieldValueById(
//                        "D293655b4a0a34e44914aee9613a7bd3957df83", bizData.getString("F0000002"), "SeqNo"));//明细.往来单位
//                entry.put("e_appseleamount", entryData.getDouble("F0000024"));//明细.申请金额
//                entry.put("e_approvedseleamt", entryData.getDouble("F0000024"));//明细.核准金额

//                String uuidHex = entryData.getString("F0000034").replace("-", "");
//                long id = Long.parseUnsignedLong(uuidHex.substring(uuidHex.length() - 16), 16);


//                if ("货到付款".equals(bizData.getString("F0000032"))) {
//                    List<Map<String, Object>> lkList = new ArrayList<>();
//                    Map<String, Object> lkEntry = new LinkedHashMap<>();
//                    lkEntry.put("entry_lk_stableid", "577639813562251264");
//
//                    lkEntry.put("entry_lk_sbillid", h3yunService.getFieldValueById("D293655sykmx68818kivnjmwwgus", bizData.getString("F0000074"), "K3id"));//
//                    lkEntry.put("entry_lk_sid", id);//
//
//                    lkList.add(lkEntry);
//                    entry.put("entry_lk", lkList);
//                    entry.put("e_corebilltype", "pm_purorderbill");
//                    entry.put("e_corebillno",h3yunService.getFieldValueById("D2936559700b1d66a0e4ee69a84e13da8dbbe95", bizData.getString("F0000001"), "K3id"));
//
//                } else if ("预付款".equals(bizData.getString("F0000032"))) {
//                    List<Map<String, Object>> lkList = new ArrayList<>();
//                    Map<String, Object> lkEntry = new LinkedHashMap<>();
//                    lkEntry.put("entry_lk_stableid", "602924326097811460");
//                    lkEntry.put("entry_lk_sbillid", h3yunService.getFieldValueById("D2936559700b1d66a0e4ee69a84e13da8dbbe95", bizData.getString("F0000001"), "K3id"));//
//                    lkEntry.put("entry_lk_sid", id);//
//
//                    lkList.add(lkEntry);
//                    entry.put("entry_lk", lkList);
//                    entry.put("e_corebilltype", "pm_purorderbill");
//                    entry.put("e_corebillno",h3yunService.getFieldValueById("D2936559700b1d66a0e4ee69a84e13da8dbbe95", bizData.getString("F0000033"), "SeqNo"));
//                }


                entryList.add(entry);
            }
        }
        paymentRequest.put("entry", entryList);


        dataList.add(paymentRequest);
        data.put("data", dataList);
        return data;
    }

    /**
     * 提取财务应付单数据（金蝶API格式）
     * 返回格式: {"data":[{"billno":"...","supplier_number":"...","ap_payableentry":[...]}]}
     */
    @SuppressWarnings("unchecked")
    private Map<String, Object> extractPayableBillData(JSONObject bizData) {
        Map<String, Object> data = new HashMap<>();
        List<Map<String, Object>> dataList = new ArrayList<>();
        Map<String, Object> payableBill = new LinkedHashMap<>();

        // ========== 头部信息 ==========
        payableBill.put("billno", bizData.getString("SeqNo")); // 单据编号
        payableBill.put("trdbillno", bizData.getString("SeqNo"));//第三方业务编码（防止重复新增，每次新增需要传入唯一值）
        payableBill.put("billtypeid_number", bizData.getString("F0000019")); // 单据类型编码

        // 结算组织（复用查询结果）
        String settleOrgNumber = (String) h3yunService.getFieldValueById(
                "D29365537feb4e5e8644b21b7fd938dd322dab3", bizData.getString("F0000018"), "F0000002");
        payableBill.put("org_number", settleOrgNumber);
        payableBill.put("isincludetax", true);//录入含税单价
        // 付款组织
        String payOrgNumber = (String) h3yunService.getFieldValueById(
                "D29365537feb4e5e8644b21b7fd938dd322dab3", bizData.getString("F0000049"), "F0000002");
        payableBill.put("payorg_number", payOrgNumber);

        payableBill.put("bizdate", formatDate(bizData.getString("F0000021"))); // 业务日期
        payableBill.put("bookdate", formatDate(bizData.getString("F0000048"))); // 记账日期

        // ========== 付款计划分录 planentity（先处理以获取最大日期） ==========
        List<Map<String, Object>> recPlanList = new ArrayList<>();
        JSONArray recplanentryArray = bizData.getJSONArray("D293655st5tmoistukggjookxut");
        String maxPlanDueDate = ""; // 记录明细中最大的到期日
        if (recplanentryArray != null && !recplanentryArray.isEmpty()) {
            for (int i = 0; i < recplanentryArray.size(); i++) {
                JSONObject recData = recplanentryArray.getJSONObject(i);
                Map<String, Object> recPlan = new LinkedHashMap<>();
                String uuidHex = recData.getString("ObjectId").replace("-", "");
// 取后16位（64bit），解析为无符号long，避免溢出和负数问题
                long id = Long.parseUnsignedLong(uuidHex.substring(uuidHex.length() - 16), 16);
                recPlan.put("id", id);
                String planDueDate = formatDate(recData.getString("F0000037"));
                recPlan.put("planduedate", planDueDate); // 到期日
                recPlan.put("planpricerate", recData.getDouble("F0000035")); // 应付比例%
                recPlan.put("planpricetax", recData.getDouble("F0000036")); // 应付金额
                recPlanList.add(recPlan);
                // 取最大日期
                if (maxPlanDueDate.isEmpty() || planDueDate.compareTo(maxPlanDueDate) > 0) {
                    maxPlanDueDate = planDueDate;
                }
            }
        }
        payableBill.put("planentity", recPlanList);

        // 最后到期日：取F0000047和明细中最大日期的较大值
        String dueDate = formatDate(bizData.getString("F0000047"));
        if (!maxPlanDueDate.isEmpty() && maxPlanDueDate.compareTo(dueDate) > 0) {
            dueDate = maxPlanDueDate;
        }
        payableBill.put("duedate", dueDate); // 最后到期日

        payableBill.put("asstacttype", "bd_supplier"); // 往来类型

        // 往来供应商单位
        payableBill.put("asstact_number", h3yunService.getFieldValueById(
                "D293655b4a0a34e44914aee9613a7bd3957df83", bizData.getString("F0000024"), "SeqNo"));
        // 结算币别
        payableBill.put("currency_number", h3yunService.getFieldValueById(
                "D293655f08d8524a8254d35b3681ea527ce2c59", bizData.getString("F0000052"), "F0000001"));
        payableBill.put("al95__number", h3yunService.getFieldValueById(
                "D293655skiralyrkoearso23dgyg", bizData.getString("F0000081"), "F0000001"));//发票类型.编码
        payableBill.put("al95__name", h3yunService.getFieldValueById(
                "D293655skiralyrkoearso23dgyg", bizData.getString("F0000081"), "F0000002"));//发票类型.名称
        payableBill.put("ivnumber", bizData.getString("F0000082"));//发票号码


        // 汇率表（格式如 "预算汇率-BMERT-01_SYS" -> "BMERT-01_SYS"）
        String exratetable_number = bizData.getString("F0000053");
        if ("预算汇率".equals(exratetable_number)) {
            exratetable_number = "BMERT-01_SYS";
        } else {
            exratetable_number = "ERT-01";
        }
        payableBill.put("exratetable_number", exratetable_number);
        // 付款条件
        payableBill.put("paycond_number", h3yunService.getFieldValueById(
                "D293655sxvsttpe7re2tep6gvsdg", bizData.getString("F0000050"), "F0000001"));

        payableBill.put("remark", bizData.getString("F0000051")); // 备注

        // ========== 明细分录 detailentry ==========
        List<Map<String, Object>> entryList = new ArrayList<>();
        JSONArray billentryArray = bizData.getJSONArray("D293655sgomjaqmtouk80lfxhwlk");
        // detailentry_lk 关联子表（D293655sdetailentrylkxxx 需根据实际编码替换）

        if (billentryArray != null && !billentryArray.isEmpty()) {
            for (int i = 0; i < billentryArray.size(); i++) {
                JSONObject entryData = billentryArray.getJSONObject(i);
                Map<String, Object> entry = new LinkedHashMap<>();
                // 物料编码
                entry.put("material_number", h3yunService.getFieldValueById(
                        "D293655fc1a38f7956f400a886f376911a54a30", entryData.getString("F0000027"), "SeqNo"));
                entry.put("quantity", entryData.getDouble("F0000031")); // 数量
                entry.put("price", entryData.getDouble("F0000032")); // 单价
                entry.put("pricetax", entryData.getDouble("F0000080"));//明细.含税单价
              entry.put("e_amount", entryData.getDouble("F0000084")); // 金额
                entry.put("e_pricetaxtotal", entryData.getDouble("F0000033"));//价税合计
                entry.put("discountmode", "NULL"); // 折扣方式默认写死无
                // 单位
                entry.put("measureunit_number", h3yunService.getFieldValueById(
                        "D293655248b1d9bf6c448f0a291341ec58bb943", entryData.getString("F0000030"), "F0000001"));

                entry.put("taxrateid_number", h3yunService.getFieldValueById(
                        "D293655sl91vt6h8d0qg1heqw5aq", entryData.getString("F0000078"), "F0000001"));//明细.税率.编码（为空时，默认取物料组织公共信息下的默认税率）
                entry.put("e_tax", entryData.getDouble("F0000079"));//税额
                String F0000085 = entryData.getString("F0000085");
                if (F0000085.equals("是")) {
                    entry.put("ispresent", true);
                } else {
                    entry.put("ispresent", false);
                }


                List<Map<String, Object>> lkList = new ArrayList<>();
                Map<String, Object> lkEntry = new LinkedHashMap<>();
                lkEntry.put("detailentry_lk_stableid", "602924315385558018");
//                lkEntry.put("detailentry_lk_sbillid","2474808901552334848" );//h3yunService.getFieldValueById( "D293655srqj5uui3keso9oraeqm", bizData.getString("F0000074"), "F0000038")
//                lkEntry.put("detailentry_lk_sid", "2474809546787280896" );//entryData.getString("F0000075")
                lkEntry.put("detailentry_lk_sbillid", h3yunService.getFieldValueById("D293655srqj5uui3keso9oraeqm", bizData.getString("F0000074"), "F0000038"));//
                lkEntry.put("detailentry_lk_sid", entryData.getString("F0000075"));//


                lkList.add(lkEntry);
                entry.put("detailentry_lk", lkList);


                entryList.add(entry);
            }
        }
        payableBill.put("detailentry", entryList);

//        // ========== 付款计划分录 planentity ==========
//        List<Map<String, Object>> recPlanList = new ArrayList<>();
//        JSONArray recplanentryArray = bizData.getJSONArray("D293655st5tmoistukggjookxut");
//        if (recplanentryArray != null && !recplanentryArray.isEmpty()) {
//            for (int i = 0; i < recplanentryArray.size(); i++) {
//                JSONObject recData = recplanentryArray.getJSONObject(i);
//                Map<String, Object> recPlan = new LinkedHashMap<>();
//                recPlan.put("planduedate", formatDate(recData.getString("F0000037"))); // 到期日
//                recPlan.put("planpricerate", recData.getDouble("F0000035")); // 应付比例%
//                recPlan.put("planpricetax", recData.getDouble("F0000036")); // 应付金额
//                recPlanList.add(recPlan);
//            }
//        }
//        payableBill.put("planentity", recPlanList);

        dataList.add(payableBill);
        data.put("data", dataList);
        return data;
    }

    /**
     * 提取采购发票数据（金蝶API格式）
     * 返回格式: {"data":[{"billno":"...","supplier_number":"...","iv_purchaseentry":[...]}]}
     */
    @SuppressWarnings("unchecked")
    private Map<String, Object> extractPurchaseInvoiceData(JSONObject bizData) {
        Map<String, Object> data = new HashMap<>();
        List<Map<String, Object>> dataList = new ArrayList<>();
        Map<String, Object> purchaseInvoice = new LinkedHashMap<>();

        // 头部信息
        purchaseInvoice.put("billno", bizData.getString("SeqNo")); // 单据编号
        purchaseInvoice.put("supplier_number", bizData.getString("F0000002")); // 供应商编码
        purchaseInvoice.put("supplier_name", bizData.getString("F0000003")); // 供应商名称
        purchaseInvoice.put("biztime", formatDate(bizData.getString("F0000004"))); // 业务日期
        purchaseInvoice.put("invoice_no", bizData.getString("F0000005")); // 发票号
        purchaseInvoice.put("invoice_date", formatDate(bizData.getString("F0000006"))); // 发票日期
        purchaseInvoice.put("settleorg_number", bizData.getString("F0000007")); // 结算组织
        purchaseInvoice.put("billtype_number", bizData.getString("F0000008")); // 单据类型
        purchaseInvoice.put("settlecurrency_number", bizData.getString("F0000009")); // 结算币别
        purchaseInvoice.put("exchangerate", bizData.getDouble("F0000010")); // 汇率
        purchaseInvoice.put("istax", true); // 是否含税
        purchaseInvoice.put("comment", bizData.getString("F0000011")); // 备注
        purchaseInvoice.put("operator_operatornumber", bizData.getString("CreatedBy")); // 操作人

        // 分录信息 iv_purchaseentry
        List<Map<String, Object>> entryList = new ArrayList<>();
        JSONArray billentryArray = bizData.getJSONArray("F0000012");
        if (billentryArray != null && !billentryArray.isEmpty()) {
            for (int i = 0; i < billentryArray.size(); i++) {
                JSONObject entryData = billentryArray.getJSONObject(i);
                Map<String, Object> entry = new LinkedHashMap<>();
                entry.put("material_number", entryData.getString("F0000013")); // 物料编码
                entry.put("qty", entryData.getDouble("F0000014")); // 数量
                entry.put("unit_number", entryData.getString("F0000015")); // 单位
                entry.put("price", entryData.getDouble("F0000016")); // 单价
                entry.put("taxprice", entryData.getDouble("F0000017")); // 含税单价
                entry.put("taxrate", entryData.getDouble("F0000018")); // 税率
                entry.put("amount", entryData.getDouble("F0000019")); // 金额
                entry.put("taxamount", entryData.getDouble("F0000020")); // 税额
                entry.put("entrycomment", entryData.getString("F0000021")); // 分录备注
                entryList.add(entry);
            }
        }
        purchaseInvoice.put("iv_purchaseentry", entryList);

        dataList.add(purchaseInvoice);
        data.put("data", dataList);
        return data;
    }

    /**
     * 提取销售发票数据（金蝶API格式）
     * 返回格式: {"data":[{"billno":"...","customer_number":"...","iv_salesentry":[...]}]}
     */
    @SuppressWarnings("unchecked")
    private Map<String, Object> extractSalesInvoiceData(JSONObject bizData) {
        Map<String, Object> data = new HashMap<>();
        List<Map<String, Object>> dataList = new ArrayList<>();
        Map<String, Object> salesInvoice = new LinkedHashMap<>();

        // 头部信息
        salesInvoice.put("billno", bizData.getString("SeqNo")); // 单据编号
        salesInvoice.put("customer_number", bizData.getString("F0000002")); // 客户编码
        salesInvoice.put("customer_name", bizData.getString("F0000003")); // 客户名称
        salesInvoice.put("biztime", formatDate(bizData.getString("F0000004"))); // 业务日期
        salesInvoice.put("invoice_no", bizData.getString("F0000005")); // 发票号
        salesInvoice.put("invoice_date", formatDate(bizData.getString("F0000006"))); // 发票日期
        salesInvoice.put("saleorg_number", bizData.getString("F0000007")); // 销售组织
        salesInvoice.put("billtype_number", bizData.getString("F0000008")); // 单据类型
        salesInvoice.put("settlecurrency_number", bizData.getString("F0000009")); // 结算币别
        salesInvoice.put("exchangerate", bizData.getDouble("F0000010")); // 汇率
        salesInvoice.put("istax", true); // 是否含税
        salesInvoice.put("comment", bizData.getString("F0000011")); // 备注
        salesInvoice.put("operator_operatornumber", bizData.getString("CreatedBy")); // 操作人

        // 分录信息 iv_salesentry
        List<Map<String, Object>> entryList = new ArrayList<>();
        JSONArray billentryArray = bizData.getJSONArray("F0000012");
        if (billentryArray != null && !billentryArray.isEmpty()) {
            for (int i = 0; i < billentryArray.size(); i++) {
                JSONObject entryData = billentryArray.getJSONObject(i);
                Map<String, Object> entry = new LinkedHashMap<>();
                entry.put("material_number", entryData.getString("F0000013")); // 物料编码
                entry.put("qty", entryData.getDouble("F0000014")); // 数量
                entry.put("unit_number", entryData.getString("F0000015")); // 单位
                entry.put("price", entryData.getDouble("F0000016")); // 单价
                entry.put("taxprice", entryData.getDouble("F0000017")); // 含税单价
                entry.put("taxrate", entryData.getDouble("F0000018")); // 税率
                entry.put("amount", entryData.getDouble("F0000019")); // 金额
                entry.put("taxamount", entryData.getDouble("F0000020")); // 税额
                entry.put("entrycomment", entryData.getString("F0000021")); // 分录备注
                entryList.add(entry);
            }
        }
        salesInvoice.put("iv_salesentry", entryList);

        dataList.add(salesInvoice);
        data.put("data", dataList);
        return data;
    }

    /**
     * 提取收款单数据（金蝶API格式）
     * 返回格式: {"data":[{"billno":"...","receiveorg_number":"...","ar_receivableentry":[...]}]}
     */
    @SuppressWarnings("unchecked")
    private Map<String, Object> extractReceiveBillData(JSONObject bizData) {
        Map<String, Object> data = new HashMap<>();
        List<Map<String, Object>> dataList = new ArrayList<>();
        Map<String, Object> receiveBill = new LinkedHashMap<>();

        // 头部信息
        // ========== 头部信息 ==========
        receiveBill.put("billno", bizData.getString("SeqNo")); // 单据编号
        receiveBill.put("trdbillno", bizData.getString("SeqNo"));//第三方业务编码（防止重复新增，每次新增需要传入唯一值）
        receiveBill.put("payertype", "bd_customer"); // 付款单位类型：bos_org：公司，bd_supplier：供应商，bd_customer：客户，bos_user：人员，other：其他，cas_othercontactunit：其他往来单位
        receiveBill.put("actrecamt", bizData.getDouble("F0000034")); // 收款金额
        receiveBill.put("exchangerate", bizData.getDouble("F0000051")); // 汇率
        receiveBill.put("localamt", bizData.getDouble("F0000052")); // 汇率
        receiveBill.put("currency_number", h3yunService.getFieldValueById("D293655f08d8524a8254d35b3681ea527ce2c59", bizData.getString("F0000048"), "F0000001"));// 收款币别.货币代码
        receiveBill.put("accountbank_number", h3yunService.getFieldValueById("D293655sat05benxoeg1hhgy81h", bizData.getString("F0000055"), "F0000001"));//收款账号
        String exratetable_number = bizData.getString("F0000035");
        if ("预算汇率".equals(exratetable_number)) {
            exratetable_number = "BMERT-01_SYS";
        } else {
            exratetable_number = "ERT-01";
        }
        receiveBill.put("exratetable_number", exratetable_number);//	汇率表.编码

//        receiveBill.put("customer_name", bizData.getString("F0000004")); // 客户名称
        receiveBill.put("bizdate", formatDate(bizData.getString("F0000021"))); // 业务日期
        receiveBill.put("payername", h3yunService.getFieldValueById("D293655shuyz9ttzgkgmhaa4rglr", bizData.getString("F0000058"), "F0000001")); // 付款单位名称
        receiveBill.put("bizdate", formatDate(bizData.getString("F0000021"))); // 业务日期
        receiveBill.put("settletype_number", h3yunService.getFieldValueById("D293655skrwqen4wv0g7je4itf", bizData.getString("F0000049"), "F0000001")); // 结算方式.编码
//        receiveBill.put("bankaccount", bizData.getString("F0000009")); // 银行账号
//        receiveBill.put("settlecurrency_number", bizData.getString("F0000010")); // 结算币别
//        receiveBill.put("comment", bizData.getString("F0000012")); // 备注
//        receiveBill.put("operator_operatornumber", bizData.getString("CreatedBy")); // 操作人
        // 分录信息 ar_receivableentry
        List<Map<String, Object>> entryList = new ArrayList<>();
        JSONArray billentryArray = bizData.getJSONArray("D293655stemflt5ee0gjvlbvvj5n");
        if (billentryArray != null && !billentryArray.isEmpty()) {
            for (int i = 0; i < billentryArray.size(); i++) {
                JSONObject entryData = billentryArray.getJSONObject(i);
                Map<String, Object> entry = new LinkedHashMap<>();
//                String uuidHex = entryData.getString("ObjectId").replace("-", "");
//                long id = Long.parseUnsignedLong(uuidHex.substring(uuidHex.length() - 16), 16);
//                entry.put("id", id);
                entry.put("e_receivingtype_number", "100");
                entry.put("e_actamt", entryData.getDouble("F0000057")); // 实收金额
                entry.put("e_receivableamt", entryData.getDouble("F0000057"));//应收金额
                entry.put("e_localamt", entryData.getDouble("F0000059")); // 收款明细.实收折本币
                entry.put("e_sourcebillid", h3yunService.getFieldValueById("D29365523b214414c2b4e50b9bdca110a9a5951", bizData.getString("F0000060"), "K3id"));
                entry.put("e_settleorg_number", h3yunService.getFieldValueById("D29365537feb4e5e8644b21b7fd938dd322dab3", entryData.getString("F0000056"), "F0000002"));//收款明细.结算组织.编码
                entry.put("e_contactunittype", "bd_customer");//收款明细.（必录）往来单位类型 bd_customer:客户, bd_supplier:供应商, bos_org:公司, bos_user:人员, cas_othercontactunit:其他往来单位, cas_other:其他
                entry.put("e_contactunit_number", h3yunService.getFieldValueById("D293655shuyz9ttzgkgmhaa4rglr", entryData.getString("F0000030"), "SeqNo"));//收款明细.结算组织.编码
/////////收款单关联销售订单
                String uuidHex = entryData.getString("F0000061").replace("-", "");
                long id = Long.parseUnsignedLong(uuidHex.substring(uuidHex.length() - 16), 16);
                entry.put("e_corebilltype", "sm_salorder");// 收款明细.核心单据类型 ar_finarbill:财务应收单, fr_glreim_paybill:总账付款单, conm_salcontract:销售合同, ec_contract:建筑收入合同, er_repaymentbill:还款单, fr_glreim_recbill:总账收款单, sm_salorder:销售订单, PO:采购订单, cas_paybill:付款单
                entry.put("e_corebilltype_title", "销售订单");//固定
                entry.put("e_corebillentryseq", 1);//固定
                entry.put("e_corebillno", h3yunService.getFieldValueById(
                        "D29365523b214414c2b4e50b9bdca110a9a5951", bizData.getString("F0000060"), "SeqNo"));//销售订单编号

                entry.put("e_corebillid", h3yunService.getFieldValueById(
                        "D29365523b214414c2b4e50b9bdca110a9a5951", bizData.getString("F0000060"), "K3id"));//销售订单主表ID
                entry.put("e_corebillentryid", id);//销售订单应付行明细ID

                List<Map<String, Object>> lkList = new ArrayList<>();
                Map<String, Object> lkEntry = new LinkedHashMap<>();
                lkEntry.put("entry_lk_stableid", "602924332909361152");
                lkEntry.put("entry_lk_sbillid", h3yunService.getFieldValueById("D29365523b214414c2b4e50b9bdca110a9a5951", bizData.getString("F0000060"), "K3id"));//
                lkEntry.put("entry_lk_sid", id);//
                lkList.add(lkEntry);
                entry.put("entry_lk", lkList);


                entryList.add(entry);
            }
        }
        receiveBill.put("entry", entryList);//收款明细

        dataList.add(receiveBill);
        data.put("data", dataList);
        return data;
    }

    /**
     * 提取
     * 开票申请@财务应收单 数据（金蝶API格式）
     * 返回格式: {"data":[{"billno":"...","customer_number":"...","iv_invoiceapplyentry":[...]}]}
     */
    @SuppressWarnings("unchecked")
    private Map<String, Object> extractInvoiceApplyData(JSONObject bizData) {
        Map<String, Object> data = new HashMap<>();
        List<Map<String, Object>> dataList = new ArrayList<>();
        Map<String, Object> invoiceApply = new LinkedHashMap<>();

        // 头部信息
        invoiceApply.put("billno", bizData.getString("SeqNo")); // 单据编号
        invoiceApply.put("trdbillno", bizData.getString("SeqNo"));//第三方业务编码（防止重复新增，每次新增需要传入唯一值）
        invoiceApply.put("billtype_number", "arfin_standard_BT_S");//单据类型.编码（arfin_borrowar_BT_S-应收款项调整、arfin_other_BT_S-其他应收、arfin_project_BT_S-项目应收、arfin_salefee_BT_S-销售费用应收、arfin_sersal_BT_S-服务销售应收、arfin_standard_BT_S-标准销售应收、arfin_transfer_BT_S-资产调拨应收）
        invoiceApply.put("org_number", h3yunService.getFieldValueById("D29365537feb4e5e8644b21b7fd938dd322dab3", bizData.getString("F0000003"), "F0000002")); // 结算组织.编码
        invoiceApply.put("bizdate", formatDate(bizData.getString("F0000005"))); // 业务日期
        invoiceApply.put("bookdate", formatDate(bizData.getString("F0000007")));//记账日期
        //  invoiceApply.put("duedate", formatDate(bizData.getString("F0000006")));//最后到期日

        invoiceApply.put("paycond_number", h3yunService.getFieldValueById("D293655sv6bv8bozikwrkze3rk1", bizData.getString("F0000010"), "F0000001"));//收款条件.编码
        invoiceApply.put("settlementtype_number", h3yunService.getFieldValueById("D293655skrwqen4wv0g7je4itf", bizData.getString("F0000011"), "F0000001"));//结算方式.编码
        invoiceApply.put("asstacttype", "bd_customer"); // 往来类型 bd_supplier:供应商, bos_user:人员, bd_customer:客户, cas_othercontactunit:其他往来单位

        invoiceApply.put("asstact_number", h3yunService.getFieldValueById("D293655shuyz9ttzgkgmhaa4rglr", bizData.getString("F0000002"), "SeqNo")); // 往来单位.编码（结合往来类型动态改变，显示的名称有：结算客户、往来单位）

        invoiceApply.put("recorg_number", h3yunService.getFieldValueById("D29365537feb4e5e8644b21b7fd938dd322dab3", bizData.getString("F0000009"), "F0000002"));//收款组织.编码
        invoiceApply.put("currency_number", h3yunService.getFieldValueById("D293655f08d8524a8254d35b3681ea527ce2c59", bizData.getString("F0000013"), "F0000001"));//结算币别.货币代码
        String exratetable_number = bizData.getString("F0000014");
        if ("预算汇率".equals(exratetable_number)) {
            exratetable_number = "BMERT-01_SYS";
        } else {
            exratetable_number = "ERT-01";
        }
        invoiceApply.put("exratetable_number", exratetable_number);//汇率表.编码

        //开票类型
        invoiceApply.put("al95_fp_number", h3yunService.getFieldValueById("D293655sdzbyn4yqt0ub0k8e9euc", bizData.getString("F0000032"), "F0000001"));


//
//
//        invoiceApply.put("invoicetype", bizData.getString("F0000006")); // 发票类型
//        invoiceApply.put("taxnum", bizData.getString("F0000007")); // 税号
//        invoiceApply.put("bank_number", bizData.getString("F0000008")); // 开户银行
//        invoiceApply.put("bankaccount", bizData.getString("F0000009")); // 银行账号
//        invoiceApply.put("address", bizData.getString("F0000010")); // 地址
//        invoiceApply.put("phone", bizData.getString("F0000011")); // 电话
        invoiceApply.put("remark", bizData.getString("F0000012")); // 备注
//        invoiceApply.put("operator_operatornumber", bizData.getString("CreatedBy")); // 操作人

        // 分录信息 iv_invoiceapplyentry
        List<Map<String, Object>> entryList = new ArrayList<>();
        JSONArray billentryArray = bizData.getJSONArray("D293655F95117110d28044aa81b904ec6bafb8d9");
        if (billentryArray != null && !billentryArray.isEmpty()) {
            for (int i = 0; i < billentryArray.size(); i++) {
                JSONObject entryData = billentryArray.getJSONObject(i);
                Map<String, Object> entry = new LinkedHashMap<>();

                entry.put("e_quantity", entryData.getDouble("F0000022")); // 数量
                entry.put("e_unitprice", entryData.getDouble("F0000027")); // 单价
                // entry.put("e_unitprice", entryData.getDouble("F0000027")); // 含税单价
                entry.put("e_amount", entryData.getDouble("F0000028")); // 金额
                entry.put("e_discountmode", "NULL"); // 明细.折扣方式 PERCENT:折扣率(%), PERUNIT:单位折扣额, NULL:无, TOTAL:固定折扣额


                entry.put("e_material_number", entryData.getString("F0000026")); // 物料编码


                /////这里


                /////////应收单关联销售出库单

                String uuidHex = entryData.getString("F0000030").replace("-", "");
                long id = Long.parseUnsignedLong(uuidHex.substring(uuidHex.length() - 16), 16);
//                entry.put("e_corebilltype", "sm_salorder");// 收款明细.核心单据类型 ar_finarbill:财务应收单, fr_glreim_paybill:总账付款单, conm_salcontract:销售合同, ec_contract:建筑收入合同, er_repaymentbill:还款单, fr_glreim_recbill:总账收款单, sm_salorder:销售订单, PO:采购订单, cas_paybill:付款单
//                entry.put("e_corebilltype_title", "销售订单");//固定
//                entry.put("e_corebillentryseq", 1);//固定
//                entry.put("e_corebillno", h3yunService.getFieldValueById(
//                        "D29365523b214414c2b4e50b9bdca110a9a5951", bizData.getString("F0000060"), "SeqNo"));//销售订单编号
//
//                entry.put("e_corebillid", h3yunService.getFieldValueById(
//                        "D29365523b214414c2b4e50b9bdca110a9a5951", bizData.getString("F0000060"), "K3id"));//销售订单主表ID
//                 entry.put("e_corebillentryid", id);//销售订单应付行明细ID

                List<Map<String, Object>> lkList = new ArrayList<>();
                Map<String, Object> lkEntry = new LinkedHashMap<>();
                lkEntry.put("entry_lk_stableid", "602924300688717826");
                lkEntry.put("entry_lk_sbillid", h3yunService.getFieldValueById("D293655suomjudbplkoxrgs42dqj", bizData.getString("F0000029"), "K3id"));//

                lkEntry.put("entry_lk_sid", id);//
                lkList.add(lkEntry);
                entry.put("entry_lk", lkList);


//
//                entry.put("taxrate", entryData.getDouble("F0000018")); // 税率
//
//                entry.put("taxamount", entryData.getDouble("F0000020")); // 税额
//                entry.put("entrycomment", entryData.getString("F0000021")); // 分录备注
                entryList.add(entry);
            }
        }
        invoiceApply.put("entry", entryList);

        dataList.add(invoiceApply);
        data.put("data", dataList);
        return data;
    }

    /**
     * 提取通用单据数据
     */
    private Map<String, Object> extractBillData(JSONObject bizData, String idField1, String idField2) {
        Map<String, Object> data = new HashMap<>();
        if (idField1 != null) {
            data.put(idField1, bizData.getString("F0000002"));
        }
        if (idField2 != null) {
            data.put(idField2, bizData.getString("F0000003"));
        }
        // 提取明细数据
        JSONArray entityList = bizData.getJSONArray("F0000010");
        if (entityList != null && !entityList.isEmpty()) {
            JSONObject firstItem = entityList.getJSONObject(0);
            data.put("materialId", firstItem.getString("F0000011")); // 明细物料
            data.put("qty", firstItem.getDouble("F0000012")); // 明细数量
        }
        return data;
    }
}