package com.ruoyi.tms.service.impl;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.enums.SystemDataNoEnum;
import com.ruoyi.common.utils.DateUtils;
import javax.annotation.Resource;

import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.system.service.ISysConfigService;
import com.ruoyi.system.service.ISystemDataNoService;
import com.ruoyi.tms.domain.*;
import com.ruoyi.tms.mapper.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.stereotype.Service;
import org.springframework.scheduling.annotation.Async;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.ruoyi.common.utils.PageUtils;
import com.ruoyi.common.constant.Constants;
import com.ruoyi.common.annotation.DataSource;
import com.ruoyi.common.enums.DataSourceType;
import com.ruoyi.common.core.service.BaseService;

import com.ruoyi.tms.service.ITmsReceivableFeeService;
import com.ruoyi.common.core.text.Convert;

/**
 * 应收费用Service业务层处理
 *
 * @author ruoyi
 * @date 2025-12-12
 */
@Service
@Transactional(rollbackFor = Exception.class)
public class TmsReceivableFeeServiceImpl  extends BaseService<TmsReceivableFeeMapper, TmsReceivableFee> implements ITmsReceivableFeeService
{
    protected final Logger logger = LoggerFactory.getLogger(getClass());
    @Resource
    private TmsReceivableFeeMapper tmsReceivableFeeMapper;
    @Resource
    private TmsReceivableFeeItemMapper tmsReceivableFeeItemMapper;
    @Resource
    private TmsDispatchOrderMapper tmsDispatchOrderMapper;
    @Resource
    ISysConfigService sysConfigService;
    @Autowired
    ISystemDataNoService systemDataNoService;
    @Resource
    private TmsArBillMapper tmsArBillMapper;
    @Resource
    private TmsArBillItemMapper tmsArBillItemMapper;

    /**
     * 查询应收费用
     *
     * @param id 应收费用ID
     * @return 应收费用
     */
    @DataSource(DataSourceType.SLAVE)
    @Override
    public TmsReceivableFee selectTmsReceivableFeeById(Integer id)
    {
        TmsReceivableFee tmsReceivableFee = tmsReceivableFeeMapper.selectTmsReceivableFeeById(id);
        List<TmsReceivableFeeItem> tmsReceivableFeeItems = tmsReceivableFeeItemMapper.selectTmsReceivableFeeItemList(new TmsReceivableFeeItem() {{
            setHeadId(id);
        }});
        tmsReceivableFee.setItems(tmsReceivableFeeItems);
        return tmsReceivableFee;
    }


    @Override
    public TmsReceivableFee selectTmsReceivableFeeByDispatchNo(String dispatchNo) {
        TmsReceivableFee tmsReceivableFee = tmsReceivableFeeMapper.selectOne(new LambdaUpdateWrapper<TmsReceivableFee>()
                .eq(TmsReceivableFee::getDispatchNo, dispatchNo)
                .ne(TmsReceivableFee::getStatus, 2)
                .last("limit 1")
        );
        if(tmsReceivableFee != null){
            List<TmsReceivableFeeItem> tmsReceivableFeeItems = tmsReceivableFeeItemMapper.selectTmsReceivableFeeItemList(new TmsReceivableFeeItem() {{
                setHeadId(tmsReceivableFee.getId());
            }});
            tmsReceivableFee.setItems(tmsReceivableFeeItems);
            return tmsReceivableFee;
        }
        return null;
    }

    /**
     * 查询应收费用 记录数
     *
     * @param tmsReceivableFee 应收费用
     * @return 应收费用集合
     */
    @DataSource(DataSourceType.SLAVE)
    @Override
    public int selectTmsReceivableFeeCount(TmsReceivableFee tmsReceivableFee)
    {
        return tmsReceivableFeeMapper.selectTmsReceivableFeeCount(tmsReceivableFee);
    }

    /**
     * 查询应收费用列表
     *
     * @param tmsReceivableFee 应收费用
     * @return 应收费用
     */
    @DataSource(DataSourceType.SLAVE)
    @Override
    public List<TmsReceivableFee> selectTmsReceivableFeeList(TmsReceivableFee tmsReceivableFee)
    {
        return tmsReceivableFeeMapper.selectTmsReceivableFeeList(tmsReceivableFee);
    }

    /**
     * 查询应收费用列表 异步 导出
     *
     * @param tmsReceivableFee 应收费用
     * @param exportKey 导出功能的唯一标识
     * @return 应收费用集合
     */
    @DataSource(DataSourceType.SLAVE)
    @Async
    @Override
    public void export(TmsReceivableFee tmsReceivableFee,String exportKey) {

        super.export(TmsReceivableFee.class,exportKey,"tmsReceivableFeeData",(pageNum)->{
            PageUtils.startPage(pageNum, Constants.EXPORT_PATE_SIZE);
            return selectTmsReceivableFeeList(tmsReceivableFee);
        });
    }


    /**
     * 新增应收费用
     *
     * @param tmsReceivableFee 应收费用
     * @return 结果
     */
    @Override
    public int insertTmsReceivableFee(TmsReceivableFee tmsReceivableFee)
    {
        tmsReceivableFee.setCreateTime(DateUtils.getNowDate());
        return tmsReceivableFeeMapper.insertTmsReceivableFee(tmsReceivableFee);
    }

    /**
     * 新增应收费用[批量]
     *
     * @param tmsReceivableFees 应收费用
     * @return 结果
     */
    @Override
    public int insertTmsReceivableFeeBatch(List<TmsReceivableFee> tmsReceivableFees)
    {
        int rows = tmsReceivableFeeMapper.insertTmsReceivableFeeBatch(tmsReceivableFees);
        return rows;
    }

    /**
     * 修改应收费用
     *
     * @param tmsReceivableFee 应收费用
     * @return 结果
     */
    @Override
    public int updateTmsReceivableFee(TmsReceivableFee tmsReceivableFee)
    {
        tmsReceivableFee.setUpdateTime(DateUtils.getNowDate());
        return tmsReceivableFeeMapper.updateTmsReceivableFee(tmsReceivableFee);
    }

    /**
     * 修改应收费用[批量]
     *
     * @param tmsReceivableFees 应收费用
     * @return 结果
     */
    @Override
    public int updateTmsReceivableFeeBatch(List<TmsReceivableFee> tmsReceivableFees){
        return tmsReceivableFeeMapper.updateTmsReceivableFeeBatch(tmsReceivableFees);
    }

    @Override
    public int closeTmsReceivableFeeById(Integer id) {
        TmsReceivableFee tmsReceivableFee = selectTmsReceivableFeeById(id);
        if(tmsReceivableFee != null){
            tmsReceivableFee.setStatus(2);
            updateTmsReceivableFee(tmsReceivableFee);
            tmsDispatchOrderMapper.update(new LambdaUpdateWrapper<TmsDispatchOrder>()
                    .eq(TmsDispatchOrder::getId,tmsReceivableFee.getDispatchId())
                    .set(TmsDispatchOrder::getAccountsReceivableStatus,0)
            );
        }else{
            throw new RuntimeException("数据不存在");
        }

        return 1;
    }

    /**
     * 删除应收费用对象
     *
     * @param ids 需要删除的数据ID
     * @return 结果
     */
    @Override
    public int deleteTmsReceivableFeeByIds(String ids)
    {
        return deleteTmsReceivableFeeByIds(Convert.toIntArray(ids));
    }

    /**
     * 删除应收费用对象
     *
     *
     * @param ids 需要删除的数据ID
     * @return 结果
     */
    @Override
    public int deleteTmsReceivableFeeByIds(Integer[] ids)
    {
        return tmsReceivableFeeMapper.deleteTmsReceivableFeeByIds(ids);
    }

    @Override
    public TmsArBill initArGenerate(Integer[] ids) {

        List<TmsReceivableFee> tmsReceivableFees = tmsReceivableFeeMapper.
                selectBatchIds(Arrays.asList(ids));
        // 判断是否有不同的客户
        boolean hasDifferentCustomers = tmsReceivableFees.stream()
                .map(TmsReceivableFee::getCustomerId)
                .distinct()
                .count() > 1;
        if (hasDifferentCustomers) {
            throw new RuntimeException("所选费用包含不同客户，无法合并生成应收账单");
        }

        TmsArBill tmsArBill = new TmsArBill();
        tmsArBill.setDispatchCount(tmsReceivableFees.size());
        String s = sysConfigService.selectConfigByKey("sys.hk.rmb.rate");
        BigDecimal exchangeRate = new BigDecimal(s);
        tmsArBill.setSettleRate(exchangeRate);
        TmsReceivableFee tmsReceivableFee = tmsReceivableFees.get(0);
        tmsArBill.setCustomerId(tmsReceivableFee.getCustomerId());
        tmsArBill.setCustomerName(tmsReceivableFee.getCustomerName());
        tmsArBill.setBillName(DateUtils.dateTime()+tmsArBill.getCustomerName()+"账单");

        tmsArBill.setSettleAmount(BigDecimal.ZERO);
        tmsReceivableFees.forEach(item ->{

            BigDecimal rmbAmount = item.getReceivableHKBAmount()
                    .multiply(exchangeRate)
                    .setScale(2, RoundingMode.HALF_UP);
            item.setReceivableRmbSumAmount( item.getReceivableRMBAmount().add(rmbAmount));
            tmsArBill.setSettleAmount(tmsArBill.getSettleAmount().add(item.getReceivableRmbSumAmount()));

        });
        tmsArBill.setTmsReceivableFees(tmsReceivableFees);
        tmsArBill.setActualSettlementAmount(tmsArBill.getSettleAmount());


        return tmsArBill;
    }


    @Override
    public AjaxResult arGenerate(Integer[] ids) {

        TmsArBill tmsArBill = initArGenerate(ids);

        tmsArBill.setSystemNo(systemDataNoService.getNoByKey(SystemDataNoEnum.ZD));
        tmsArBill.setSettledAmount(BigDecimal.ZERO);
        tmsArBill.setInvoiceStatus(0);
        tmsArBill.setStatus(0);
        tmsArBill.setCreateBy(SecurityUtils.getUsername());
        tmsArBillMapper.insertTmsArBill(tmsArBill);

        tmsReceivableFeeMapper.update(new LambdaUpdateWrapper<TmsReceivableFee>()
                .set(TmsReceivableFee::getStatus,1)
                        .set( TmsReceivableFee::getBillRelationId,tmsArBill.getId())
                 .set(TmsReceivableFee::getBillRelationNo ,tmsArBill.getSystemNo())
                .in(TmsReceivableFee::getId, ids)
        );

        List<TmsReceivableFee> tmsReceivableFees = tmsArBill.getTmsReceivableFees();
        List<TmsArBillItem> rmb = tmsReceivableFees.stream().map(item -> {
            TmsArBillItem billItem = new TmsArBillItem();
            billItem.setBillId(tmsArBill.getId());
            billItem.setProjectName(item.getProjectName());
            billItem.setDispatchNo(item.getDispatchNo());
            billItem.setOrderTime(item.getCreateTime());
            billItem.setEstimateAmount(item.
                    getReceivableRmbSumAmount());
            billItem.setCurrency("RMB");
            billItem.setArFeeId(item.getId());
            billItem.setStatus(0);

            return billItem;
        }).collect(Collectors.toList());
        tmsArBillItemMapper.insertTmsArBillItemBatch(rmb);
        return AjaxResult.success();
    }

    /**
     * 删除应收费用信息
     *
     * @param id 应收费用ID
     * @return 结果
     */
    @Override
    public int deleteTmsReceivableFeeById(Integer id)
    {
        return tmsReceivableFeeMapper.deleteTmsReceivableFeeById(id);
    }
}