package com.ruoyi.api.third.controller;

import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.cwgl.domain.*;
import com.ruoyi.cwgl.domain.dto.BillAuditDto;
import com.ruoyi.cwgl.domain.dto.PayableBillApiDto;
import com.ruoyi.cwgl.domain.dto.ReceivableBillApiDto;
import com.ruoyi.cwgl.service.IPayableBillManagementService;
import com.ruoyi.cwgl.service.IPayableFeeDetailService;
import com.ruoyi.cwgl.service.IPayableFeeManagementService;
import com.ruoyi.cwgl.service.IReceivableBillManagementService;
import com.ruoyi.cwgl.service.IReceivableFeeDetailService;
import com.ruoyi.cwgl.service.IReceivableFeeManagementService;
import com.ruoyi.system.service.ISystemDataNoService;
import com.ruoyi.common.enums.SystemDataNoEnum;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;
import java.math.BigDecimal;
import java.util.*;

/**
 * 应收账单API接口
 * @author wjw
 */
@RestController
@RequestMapping("/api/third/receivable")
public class ReceivableBillApiController {

    private static Logger logger = LoggerFactory.getLogger(ReceivableBillApiController.class);

    @Autowired
    private IReceivableBillManagementService receivableBillManagementService;

    @Autowired
    private IReceivableFeeManagementService receivableFeeManagementService;

    @Autowired
    private IReceivableFeeDetailService receivableFeeDetailService;

    @Autowired
    private IPayableBillManagementService payableBillManagementService;

    @Autowired
    private IPayableFeeManagementService payableFeeManagementService;

    @Autowired
    private IPayableFeeDetailService payableFeeDetailService;

    @Autowired
    private ISystemDataNoService systemDataNoService;

    /**
     * 添加应收账单接口
     * 其他系统调用此接口添加应收账单、应收账单明细、应收账单费用
     * @param receivableBillApiDto 应收账单API数据传输对象
     * @return 操作结果
     */
    @PostMapping("/addBill")
    public Map<String, String> addReceivableBill(@Valid @RequestBody ReceivableBillApiDto receivableBillApiDto) {
        logger.info("接收应收账单添加请求：{}", receivableBillApiDto);

        Map<String, String> result = new HashMap<>();
        
        try {
            // 1. 验证数据
//            validateReceivableBillData(receivableBillApiDto);
            
            // 2. 保存应收账单管理信息
            ReceivableBillManagement billManagement = saveReceivableBillManagement(receivableBillApiDto.getBill());
            
            // 3. 保存应收费用管理信息和明细
            saveReceivableFeeManagementAndDetails(receivableBillApiDto.getFees(), billManagement.getSystemNo());
            
            result.put("status", "0000");
            result.put("message", "应收账单添加成功");
            result.put("billNo", billManagement.getSystemNo());
            
            logger.info("应收账单添加成功，账单编号：{}", billManagement.getSystemNo());
            
        } catch (Exception e) {
            logger.error("应收账单添加失败：", e);
            result.put("status", "9999");
            result.put("message", "应收账单添加失败：" + e.getMessage());
        }
        
        return result;
    }

    /**
     * 验证应收账单数据
     */
    private void validateReceivableBillData(ReceivableBillApiDto receivableBillApiDto) {
        if (receivableBillApiDto == null) {
            throw new IllegalArgumentException("请求数据不能为空");
        }
        
        if (receivableBillApiDto.getBill() == null) {
            throw new IllegalArgumentException("应收账单信息不能为空");
        }
        
        if (receivableBillApiDto.getFees() == null || receivableBillApiDto.getFees().isEmpty()) {
            throw new IllegalArgumentException("应收费用信息不能为空");
        }
        
        // 验证总金额与费用明细金额是否匹配
        BigDecimal totalAmount = receivableBillApiDto.getBill().getTotalAmount();
        BigDecimal feeTotalAmount = BigDecimal.ZERO;
        
        for (ReceivableBillApiDto.ReceivableFeeDto fee : receivableBillApiDto.getFees()) {
            feeTotalAmount = feeTotalAmount.add(fee.getReceivableAmount());
            
            // 验证费用明细
            if (fee.getFeeDetails() != null) {
                BigDecimal detailTotalAmount = BigDecimal.ZERO;
                for (ReceivableBillApiDto.ReceivableFeeDetailDto detail : fee.getFeeDetails()) {
                    detailTotalAmount = detailTotalAmount.add(detail.getBillingAmount());
                }
                
                if (fee.getReceivableAmount().compareTo(detailTotalAmount) != 0) {
                    throw new IllegalArgumentException("费用金额与明细金额不匹配，费用金额：" + fee.getReceivableAmount() + 
                            "，明细金额：" + detailTotalAmount);
                }
            }
        }
        
        if (totalAmount.compareTo(feeTotalAmount) != 0) {
            throw new IllegalArgumentException("账单总金额与费用总金额不匹配，账单金额：" + totalAmount + 
                    "，费用金额：" + feeTotalAmount);
        }
    }

    /**
     * 保存应收账单管理信息
     */
    private ReceivableBillManagement saveReceivableBillManagement(ReceivableBillApiDto.ReceivableBillDto billDto) {
        ReceivableBillManagement billManagement = new ReceivableBillManagement();
        
        // 生成系统编号
        String systemNo = systemDataNoService.getNoByKey(SystemDataNoEnum.YSZD);
        
        // 设置基本信息
        billManagement.setSystemNo(systemNo);
        billManagement.setBillName(billDto.getBillName());
        billManagement.setCustomerName(billDto.getCustomerName());
        billManagement.setPayee(billDto.getPayee());
        billManagement.setResponsiblePerson(billDto.getResponsiblePerson());
        billManagement.setResponsibleLeader(billDto.getResponsibleLeader());
        billManagement.setSettlementMethod(billDto.getSettlementMethod());
        billManagement.setBusinessType(billDto.getBusinessType());

        billManagement.setPromotionRequirement(billDto.getPromotionRequirement());
        billManagement.setIsInternalSettlement(billDto.getIsInternalSettlement());
        billManagement.setInternalSettlementUnit(billDto.getInternalSettlementUnit());
        
        // 设置金额信息
        billManagement.setDocumentCount(billDto.getDocumentCount());
        billManagement.setTotalAmount(billDto.getTotalAmount());
        billManagement.setCurrency(billDto.getCurrency());
        billManagement.setDiscountAmount(billDto.getDiscountAmount());
        billManagement.setReceivedAmount(billDto.getReceivedAmount() != null ? billDto.getReceivedAmount() : BigDecimal.ZERO);
        billManagement.setPendingAmount(billDto.getPendingAmount() != null ? billDto.getPendingAmount() : billDto.getTotalAmount());
        billManagement.setExchangeRate(billDto.getExchangeRate());
        billManagement.setCnyAmount(billDto.getCnyAmount());
        
        // 设置日期信息
        billManagement.setPeriodType(billDto.getPeriodType());
        billManagement.setBusinessStartDate(billDto.getBusinessStartDate());
        billManagement.setBusinessEndDate(billDto.getBusinessEndDate());
        billManagement.setBillingStartDate(billDto.getBillingStartDate());
        billManagement.setBillingEndDate(billDto.getBillingEndDate());
        billManagement.setBillGenerateDate(billDto.getBillGenerateDate());
        billManagement.setBillSendDate(billDto.getBillSendDate());
        billManagement.setBillDueDate(billDto.getBillDueDate());
        
        // 设置其他信息
        billManagement.setSettlementCategory(billDto.getSettlementCategory());
        billManagement.setSettlementPeriod(billDto.getSettlementPeriod());
        billManagement.setStatus(billDto.getStatus() != null ? billDto.getStatus() : "draft");
        billManagement.setAuditStatus(billDto.getAuditStatus() != null ? billDto.getAuditStatus() : 0);
        billManagement.setSourceSystemId(billDto.getSourceSystemId());
        billManagement.setRemark(billDto.getRemark());
        billManagement.setCreateTime(DateUtils.getNowDate());
        billManagement.setCreateBy("api_system");
        
        // 保存账单管理信息
        int rows = receivableBillManagementService.insertReceivableBillManagement(billManagement);
        if (rows <= 0) {
            throw new RuntimeException("保存应收账单管理信息失败");
        }
        
        return billManagement;
    }

    /**
     * 保存应收费用管理信息和明细
     */
    private void saveReceivableFeeManagementAndDetails(List<ReceivableBillApiDto.ReceivableFeeDto> fees, String billSystemNo) {
        List<ReceivableFeeManagement> feeManagementList = new ArrayList<>();
        List<ReceivableFeeDetail> feeDetailList = new ArrayList<>();
        
        for (ReceivableBillApiDto.ReceivableFeeDto feeDto : fees) {
            // 生成费用管理记录
            ReceivableFeeManagement feeManagement = new ReceivableFeeManagement();
            
            // 生成系统编号
            String feeSystemNo = systemDataNoService.getNoByKey(SystemDataNoEnum.YS);
            
            // 设置费用管理信息
            feeManagement.setSystemNo(feeSystemNo);
            feeManagement.setSerialNumber(feeDto.getSerialNumber());
            feeManagement.setRelatedBillNo(billSystemNo);
            feeManagement.setSourceSystem(feeDto.getSourceSystem());
            feeManagement.setBusinessSector(feeDto.getBusinessSector());
            feeManagement.setDocumentType(feeDto.getDocumentType());
            feeManagement.setDocumentNo(feeDto.getDocumentNo());
            feeManagement.setIsInternalSettlement(feeDto.getIsInternalSettlement());
            feeManagement.setInternalSettlementUnit(feeDto.getInternalSettlementUnit());
            feeManagement.setCustomerName(feeDto.getCustomerName());
            feeManagement.setProjectName(feeDto.getProjectName());
            feeManagement.setBusinessTime(feeDto.getBusinessTime());
            feeManagement.setReceivableConfirmTime(feeDto.getReceivableConfirmTime());
            feeManagement.setReceivableAmount(feeDto.getReceivableAmount());
            feeManagement.setReceivableAmountStr(feeDto.getReceivableAmountStr());
            feeManagement.setStatus(feeDto.getStatus() != null ? feeDto.getStatus() : "confirmed");
            feeManagement.setRemark(feeDto.getRemark());
            feeManagement.setCreateTime(DateUtils.getNowDate());
            feeManagement.setCreateBy("api_system");
            
            feeManagementList.add(feeManagement);
            
            // 保存费用明细
            if (feeDto.getFeeDetails() != null && !feeDto.getFeeDetails().isEmpty()) {
                for (ReceivableBillApiDto.ReceivableFeeDetailDto detailDto : feeDto.getFeeDetails()) {
                    ReceivableFeeDetail feeDetail = new ReceivableFeeDetail();
                    
                    feeDetail.setSerialNumber(detailDto.getSerialNumber());
                    feeDetail.setFeeType(detailDto.getFeeType());
                    feeDetail.setFeeName(detailDto.getFeeName());
                    feeDetail.setBillingUnit(detailDto.getBillingUnit());
                    feeDetail.setUnitPrice(detailDto.getUnitPrice());
                    feeDetail.setBillingQuantity(detailDto.getBillingQuantity());
                    feeDetail.setBillingAmount(detailDto.getBillingAmount());
                    feeDetail.setActualAmount(detailDto.getActualAmount() != null ? detailDto.getActualAmount() : BigDecimal.ZERO);
                    feeDetail.setCurrency(detailDto.getCurrency());
                    feeDetail.setFeeRegTime(detailDto.getFeeRegTime());
                    feeDetail.setRemark(detailDto.getRemark());
                    feeDetail.setCreateTime(DateUtils.getNowDate());
                    feeDetail.setCreateBy("api_system");
                    
                    // 注意：这里需要先保存feeManagement获取ID，然后再设置关联关系
                    // 由于是批量保存，这里先收集，后续再处理关联关系
                    feeDetailList.add(feeDetail);
                }
            }
        }
        
        // 批量保存费用管理信息
        int feeRows = receivableFeeManagementService.insertReceivableFeeManagementBatch(feeManagementList);
        if (feeRows <= 0) {
            throw new RuntimeException("保存应收费用管理信息失败");
        }
        
        // 处理费用明细的关联关系并保存
        if (!feeDetailList.isEmpty()) {
            // 使用Map存储系统编号和ID的映射关系
            Map<String, Integer> systemNoToIdMap = new HashMap<>();
            
            // 批量插入后，ID已经自动设置到对象的id属性中
            for (ReceivableFeeManagement feeManagement : feeManagementList) {
                systemNoToIdMap.put(feeManagement.getSystemNo(), feeManagement.getId());
            }
            
            // 重新构建费用明细列表，正确设置关联ID
            List<ReceivableFeeDetail> finalFeeDetailList = new ArrayList<>();
            int detailIndex = 0;
            
            for (ReceivableFeeManagement feeManagement : feeManagementList) {
                Integer feeId = systemNoToIdMap.get(feeManagement.getSystemNo());
                
                if (feeId != null) {
                    // 获取该费用管理记录对应的费用明细数量
                    int detailCount = 0;
                    for (ReceivableBillApiDto.ReceivableFeeDto feeDto : fees) {
                        if (feeDto.getDocumentNo().equals(feeManagement.getDocumentNo())) {
                            detailCount = feeDto.getFeeDetails() != null ? feeDto.getFeeDetails().size() : 0;
                            break;
                        }
                    }
                    
                    // 设置对应数量的费用明细的关联ID
                    for (int i = 0; i < detailCount && detailIndex < feeDetailList.size(); i++) {
                        ReceivableFeeDetail feeDetail = feeDetailList.get(detailIndex);
                        feeDetail.setReceivableFeeId(feeId);
                        finalFeeDetailList.add(feeDetail);
                        detailIndex++;
                    }
                }
            }
            
            // 批量保存费用明细
            int detailRows = receivableFeeDetailService.insertReceivableFeeDetailBatch(finalFeeDetailList);
            if (detailRows <= 0) {
                throw new RuntimeException("保存应收费用明细信息失败");
            }
        }
    }

    /**
     * 添加应付账单接口
     * 其他系统调用此接口添加应付账单、应付账单明细、应付账单费用
     * @param payableBillApiDto 应付账单API数据传输对象
     * @return 操作结果
     */
    @PostMapping("/addPayableBill")
    public Map<String, String> addPayableBill(@Valid @RequestBody PayableBillApiDto payableBillApiDto) {
        logger.info("接收应付账单添加请求：{}", payableBillApiDto);

        Map<String, String> result = new HashMap<>();
        
        try {
            // 1. 验证数据
//            validatePayableBillData(payableBillApiDto);
            
            // 2. 保存应付账单管理信息
            PayableBillManagement billManagement = savePayableBillManagement(payableBillApiDto.getBill());
            
            // 3. 保存应付费用管理信息和明细
            savePayableFeeManagementAndDetails(payableBillApiDto.getFees(), billManagement.getSystemNo());
            
            result.put("status", "0000");
            result.put("message", "应付账单添加成功");
            result.put("billNo", billManagement.getSystemNo());
            
            logger.info("应付账单添加成功，账单编号：{}", billManagement.getSystemNo());
            
        } catch (Exception e) {
            logger.error("应付账单添加失败：", e);
            result.put("status", "9999");
            result.put("message", "应付账单添加失败：" + e.getMessage());
        }
        
        return result;
    }

    /**
     * 验证应付账单数据
     */
    private void validatePayableBillData(PayableBillApiDto payableBillApiDto) {
        if (payableBillApiDto == null) {
            throw new IllegalArgumentException("请求数据不能为空");
        }
        
        if (payableBillApiDto.getBill() == null) {
            throw new IllegalArgumentException("应付账单信息不能为空");
        }
        
        if (payableBillApiDto.getFees() == null || payableBillApiDto.getFees().isEmpty()) {
            throw new IllegalArgumentException("应付费用信息不能为空");
        }
        
        // 验证总金额与费用明细金额是否匹配
        BigDecimal totalAmount = payableBillApiDto.getBill().getTotalAmount();
        BigDecimal feeTotalAmount = BigDecimal.ZERO;
        
        for (PayableBillApiDto.PayableFeeDto fee : payableBillApiDto.getFees()) {
            feeTotalAmount = feeTotalAmount.add(fee.getPayableAmount());
            
            // 验证费用明细
            if (fee.getFeeDetails() != null) {
                BigDecimal detailTotalAmount = BigDecimal.ZERO;
                for (PayableBillApiDto.PayableFeeDetailDto detail : fee.getFeeDetails()) {
                    detailTotalAmount = detailTotalAmount.add(detail.getBillingAmount());
                }
                
                if (fee.getPayableAmount().compareTo(detailTotalAmount) != 0) {
                    throw new IllegalArgumentException("费用金额与明细金额不匹配，费用金额：" + fee.getPayableAmount() + 
                            "，明细金额：" + detailTotalAmount);
                }
            }
        }
        
        if (totalAmount.compareTo(feeTotalAmount) != 0) {
            throw new IllegalArgumentException("账单总金额与费用总金额不匹配，账单金额：" + totalAmount + 
                    "，费用金额：" + feeTotalAmount);
        }
    }

    /**
     * 保存应付账单管理信息
     */
    private PayableBillManagement savePayableBillManagement(PayableBillApiDto.PayableBillDto billDto) {
        PayableBillManagement billManagement = new PayableBillManagement();
        
        // 生成系统编号
        String systemNo = systemDataNoService.getNoByKey(SystemDataNoEnum.YFZD);
        
        // 设置基本信息
        billManagement.setSystemNo(systemNo);
        billManagement.setBillName(billDto.getBillName());
        billManagement.setSupplierName(billDto.getSupplierName());
        billManagement.setIsInternalSettlement(billDto.getIsInternalSettlement());
        billManagement.setInternalSettlementUnit(billDto.getInternalSettlementUnit());
        
        // 设置金额信息
        billManagement.setDocumentCount(billDto.getDocumentCount());
        billManagement.setTotalAmount(billDto.getTotalAmount());
        billManagement.setCurrency(billDto.getCurrency());
        billManagement.setDiscountAmount(billDto.getDiscountAmount());
        billManagement.setPaidAmount(billDto.getPaidAmount() != null ? billDto.getPaidAmount() : BigDecimal.ZERO);
        billManagement.setPendingAmount(billDto.getPendingAmount() != null ? billDto.getPendingAmount() : billDto.getTotalAmount());
        billManagement.setExchangeRate(billDto.getExchangeRate());
        billManagement.setCnyAmount(billDto.getCnyAmount());
        
        // 设置日期信息
        billManagement.setPeriodType(billDto.getPeriodType());
        billManagement.setBusinessStartDate(billDto.getBusinessStartDate());
        billManagement.setBusinessEndDate(billDto.getBusinessEndDate());
        billManagement.setBillingStartDate(billDto.getBillingStartDate());
        billManagement.setBillingEndDate(billDto.getBillingEndDate());
        billManagement.setBillGenerateDate(billDto.getBillGenerateDate());
        billManagement.setBillSendDate(billDto.getBillSendDate());
        billManagement.setBillDueDate(billDto.getBillDueDate());
        
        // 设置其他信息
        billManagement.setStatus(billDto.getStatus() != null ? billDto.getStatus() : "draft");
        billManagement.setAuditStatus(billDto.getAuditStatus() != null ? billDto.getAuditStatus() : 0);
        billManagement.setSourceSystemId(billDto.getSourceSystemId());
        billManagement.setRemark(billDto.getRemark());
        billManagement.setCreateTime(DateUtils.getNowDate());
        billManagement.setCreateBy("api_system");
        
        // 保存账单管理信息
        int rows = payableBillManagementService.insertPayableBillManagement(billManagement);
        if (rows <= 0) {
            throw new RuntimeException("保存应付账单管理信息失败");
        }
        
        return billManagement;
    }

    /**
     * 保存应付费用管理信息和明细
     */
    private void savePayableFeeManagementAndDetails(List<PayableBillApiDto.PayableFeeDto> fees, String billSystemNo) {
        List<PayableFeeManagement> feeManagementList = new ArrayList<>();
        List<PayableFeeDetail> feeDetailList = new ArrayList<>();
        
        for (PayableBillApiDto.PayableFeeDto feeDto : fees) {
            // 生成费用管理记录
            PayableFeeManagement feeManagement = new PayableFeeManagement();
            
            // 生成系统编号
            String feeSystemNo = systemDataNoService.getNoByKey(SystemDataNoEnum.YF);
            
            // 设置费用管理信息
            feeManagement.setSystemNo(feeSystemNo);
            feeManagement.setRelatedBillNo(billSystemNo);
            feeManagement.setSourceSystem(feeDto.getSourceSystem());
            feeManagement.setBusinessSector(feeDto.getBusinessSector());
            feeManagement.setDocumentType(feeDto.getDocumentType());
            feeManagement.setDocumentNo(feeDto.getDocumentNo());
            feeManagement.setIsInternalSettlement(feeDto.getIsInternalSettlement());
            feeManagement.setInternalSettlementUnit(feeDto.getInternalSettlementUnit());
            feeManagement.setSupplierName(feeDto.getSupplierName());
            feeManagement.setProjectName(feeDto.getProjectName());
            feeManagement.setBusinessTime(feeDto.getBusinessTime());
            feeManagement.setPayableConfirmTime(feeDto.getPayableConfirmTime());
            feeManagement.setPayableAmount(feeDto.getPayableAmount());
            feeManagement.setPayableAmountStr(feeDto.getPayableAmountStr());
            feeManagement.setStatus(feeDto.getStatus() != null ? feeDto.getStatus() : "confirmed");
            feeManagement.setRemark(feeDto.getRemark());
            feeManagement.setCreateTime(DateUtils.getNowDate());
            feeManagement.setCreateBy("api_system");
            
            feeManagementList.add(feeManagement);
            
            // 保存费用明细
            if (feeDto.getFeeDetails() != null && !feeDto.getFeeDetails().isEmpty()) {
                for (PayableBillApiDto.PayableFeeDetailDto detailDto : feeDto.getFeeDetails()) {
                    PayableFeeDetail feeDetail = new PayableFeeDetail();
                    
                    feeDetail.setFeeType(detailDto.getFeeType());
                    feeDetail.setFeeName(detailDto.getFeeName());
                    feeDetail.setBillingUnit(detailDto.getBillingUnit());
                    feeDetail.setUnitPrice(detailDto.getUnitPrice());
                    feeDetail.setBillingQuantity(detailDto.getBillingQuantity());
                    feeDetail.setBillingAmount(detailDto.getBillingAmount());
                    feeDetail.setActualAmount(detailDto.getActualAmount() != null ? detailDto.getActualAmount() : BigDecimal.ZERO);
                    feeDetail.setCurrency(detailDto.getCurrency());
                    feeDetail.setFeeRegTime(detailDto.getFeeRegTime());
                    feeDetail.setRemark(detailDto.getRemark());
                    feeDetail.setCreateTime(DateUtils.getNowDate());
                    feeDetail.setCreateBy("api_system");
                    
                    // 注意：这里需要先保存feeManagement获取ID，然后再设置关联关系
                    // 由于是批量保存，这里先收集，后续再处理关联关系
                    feeDetailList.add(feeDetail);
                }
            }
        }
        
        // 批量保存费用管理信息
        int feeRows = payableFeeManagementService.insertPayableFeeManagementBatch(feeManagementList);
        if (feeRows <= 0) {
            throw new RuntimeException("保存应付费用管理信息失败");
        }
        
        // 处理费用明细的关联关系并保存
        if (!feeDetailList.isEmpty()) {
            // 使用Map存储系统编号和ID的映射关系
            Map<String, Integer> systemNoToIdMap = new HashMap<>();
            
            // 批量插入后，ID已经自动设置到对象的id属性中
            for (PayableFeeManagement feeManagement : feeManagementList) {
                systemNoToIdMap.put(feeManagement.getSystemNo(), feeManagement.getId());
            }
            
            // 重新构建费用明细列表，正确设置关联ID
            List<PayableFeeDetail> finalFeeDetailList = new ArrayList<>();
            int detailIndex = 0;
            
            for (PayableFeeManagement feeManagement : feeManagementList) {
                Integer feeId = systemNoToIdMap.get(feeManagement.getSystemNo());
                
                if (feeId != null) {
                    // 获取该费用管理记录对应的费用明细数量
                    int detailCount = 0;
                    for (PayableBillApiDto.PayableFeeDto feeDto : fees) {
                        if (feeDto.getDocumentNo().equals(feeManagement.getDocumentNo())) {
                            detailCount = feeDto.getFeeDetails() != null ? feeDto.getFeeDetails().size() : 0;
                            break;
                        }
                    }
                    
                    // 设置对应数量的费用明细的关联ID
                    for (int i = 0; i < detailCount && detailIndex < feeDetailList.size(); i++) {
                        PayableFeeDetail feeDetail = feeDetailList.get(detailIndex);
                        feeDetail.setPayableFeeId(feeId);
                        finalFeeDetailList.add(feeDetail);
                        detailIndex++;
                    }
                }
            }
            
            // 批量保存费用明细
            int detailRows = payableFeeDetailService.insertPayableFeeDetailBatch(finalFeeDetailList);
            if (detailRows <= 0) {
                throw new RuntimeException("保存应付费用明细信息失败");
            }
        }
    }

    /**
     * 健康检查接口
     * @return 健康状态
     */
    @GetMapping("/health")
    public Map<String, String> healthCheck() {
        Map<String, String> result = new HashMap<>();
        result.put("status", "0000");
        result.put("message", "应收应付账单API服务正常运行");
        result.put("timestamp", DateUtils.parseDateToStr("yyyy-MM-dd HH:mm:ss", new Date()));
        return result;
    }
}