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.query.LambdaQueryWrapper;
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.ITmsPayableFeeService;
import com.ruoyi.common.core.text.Convert;

/**
 * 应付费用Service业务层处理
 *
 * @author ruoyi
 * @date 2026-01-12
 */
@Service
@Transactional(rollbackFor = Exception.class)
public class TmsPayableFeeServiceImpl  extends BaseService<TmsPayableFeeMapper, TmsPayableFee> implements ITmsPayableFeeService
{
    protected final Logger logger = LoggerFactory.getLogger(getClass());
    @Resource
    private TmsPayableFeeMapper tmsPayableFeeMapper;
    @Resource
    private TmsDispatchOrderMapper tmsDispatchOrderMapper;

    @Resource
    private TmsPayableFeeItemMapper tmsPayableFeeItemMapper;
    @Resource
    private TmsApBillMapper tmsApBillMapper;
    @Resource
    private TmsApBillItemMapper tmsApBillItemMapper;


    @Resource
    ISysConfigService sysConfigService;
    @Autowired
    ISystemDataNoService systemDataNoService;

    /**
     * 查询应付费用
     *
     * @param id 应付费用ID
     * @return 应付费用
     */
    @DataSource(DataSourceType.SLAVE)
    @Override
    public TmsPayableFee selectTmsPayableFeeById(Integer id)
    {
        TmsPayableFee tmsPayableFee = tmsPayableFeeMapper.selectTmsPayableFeeById(id);
        List<TmsPayableFeeItem> tmsPayableFeeItems = tmsPayableFeeItemMapper.selectTmsPayableFeeItemList(
                new TmsPayableFeeItem() {{
                    setHeadId(id);
                }}
        );
        tmsPayableFee.setPayableFeeItems(tmsPayableFeeItems);
        return tmsPayableFee;
    }

    @DataSource(DataSourceType.SLAVE)
    @Override
    public List<TmsPayableFee> selectTmsPayableFeeByDispatchNo(String dispatchNo)
    {
        List<TmsPayableFee> tmsPayableFeeList = tmsPayableFeeMapper.selectList(new LambdaQueryWrapper<TmsPayableFee>()
                .eq(TmsPayableFee::getDispatchNo, dispatchNo)
                .ne(TmsPayableFee::getStatus, 2)
        );

        if (tmsPayableFeeList != null && !tmsPayableFeeList.isEmpty()){
            tmsPayableFeeList.forEach(tmsPayableFee -> {
                List<TmsPayableFeeItem> tmsPayableFeeItems = tmsPayableFeeItemMapper.selectTmsPayableFeeItemList(
                        new TmsPayableFeeItem() {{
                            setHeadId(tmsPayableFee.getId());
                        }}
                );
                tmsPayableFee.setPayableFeeItems(tmsPayableFeeItems);
            });
        }
        return tmsPayableFeeList;
    }

    /**
     * 查询应付费用 记录数
     *
     * @param tmsPayableFee 应付费用
     * @return 应付费用集合
     */
    @DataSource(DataSourceType.SLAVE)
    @Override
    public int selectTmsPayableFeeCount(TmsPayableFee tmsPayableFee)
    {
        return tmsPayableFeeMapper.selectTmsPayableFeeCount(tmsPayableFee);
    }

    /**
     * 查询应付费用列表
     *
     * @param tmsPayableFee 应付费用
     * @return 应付费用
     */
    @DataSource(DataSourceType.SLAVE)
    @Override
    public List<TmsPayableFee> selectTmsPayableFeeList(TmsPayableFee tmsPayableFee)
    {
        return tmsPayableFeeMapper.selectTmsPayableFeeList(tmsPayableFee);
    }

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

        super.export(TmsPayableFee.class,exportKey,"tmsPayableFeeData",(pageNum)->{
            PageUtils.startPage(pageNum, Constants.EXPORT_PATE_SIZE);
            return selectTmsPayableFeeList(tmsPayableFee);
        });
    }


    /**
     * 新增应付费用
     *
     * @param tmsPayableFee 应付费用
     * @return 结果
     */
    @Override
    public int insertTmsPayableFee(TmsPayableFee tmsPayableFee)
    {
        tmsPayableFee.setCreateTime(DateUtils.getNowDate());
        return tmsPayableFeeMapper.insertTmsPayableFee(tmsPayableFee);
    }

    /**
     * 新增应付费用[批量]
     *
     * @param tmsPayableFees 应付费用
     * @return 结果
     */
    @Override
    public int insertTmsPayableFeeBatch(List<TmsPayableFee> tmsPayableFees)
    {
        int rows = tmsPayableFeeMapper.insertTmsPayableFeeBatch(tmsPayableFees);
        return rows;
    }

    /**
     * 修改应付费用
     *
     * @param tmsPayableFee 应付费用
     * @return 结果
     */
    @Override
    public int updateTmsPayableFee(TmsPayableFee tmsPayableFee)
    {
        tmsPayableFee.setUpdateTime(DateUtils.getNowDate());
        return tmsPayableFeeMapper.updateTmsPayableFee(tmsPayableFee);
    }

    /**
     * 修改应付费用[批量]
     *
     * @param tmsPayableFees 应付费用
     * @return 结果
     */
    @Override
    public int updateTmsPayableFeeBatch(List<TmsPayableFee> tmsPayableFees){
        return tmsPayableFeeMapper.updateTmsPayableFeeBatch(tmsPayableFees);
    }

    @Override
    public int closeTmsPayableFeeById(Integer id) {
        TmsPayableFee tmsPayableFee = selectTmsPayableFeeById(id);
        if(tmsPayableFee != null){
            tmsPayableFee.setStatus(2);
            updateTmsPayableFee(tmsPayableFee);
            tmsDispatchOrderMapper.update(new LambdaUpdateWrapper<TmsDispatchOrder>()
                    .eq(TmsDispatchOrder::getId,tmsPayableFee.getDispatchId())
                    .set(TmsDispatchOrder::getAccountsPayableStatus,0)
            );
        }else{
            throw new RuntimeException("数据不存在");
        }

        return 1;
    }

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

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

    @Override
    public TmsApBill initApGenerate(Integer[] ids) {
        List<TmsPayableFee> tmsPayableFeeList = tmsPayableFeeMapper.selectBatchIds(Arrays.asList(ids));
        boolean hasDifferentCustomers = tmsPayableFeeList.stream()
                .map(item-> item.getServiceProviderType()+"_"+ item.getServiceProviderId())
                .distinct()
                .count() > 1;
        if (hasDifferentCustomers) {
            throw new RuntimeException("所选费用包含不同供应商，无法合并生成应收账单");
        }

        TmsApBill  tmsApBill = new TmsApBill();
        tmsApBill.setDispatchCount(tmsPayableFeeList.size());
        String s = sysConfigService.selectConfigByKey("sys.hk.rmb.rate");
        BigDecimal exchangeRate = new BigDecimal(s);
        tmsApBill.setSettleRate(exchangeRate);
        TmsPayableFee tmsPayableFee = tmsPayableFeeList.get(0);
        tmsApBill.setServiceProviderId(tmsPayableFee.getServiceProviderId());
        tmsApBill.setServiceProviderName(tmsPayableFee.getServiceProviderName());
        tmsApBill.setServiceProviderType(tmsPayableFee.getServiceProviderType());
        tmsApBill.setBillName(DateUtils.dateTime()+tmsApBill.getServiceProviderName()+"账单");

        tmsApBill.setSettleAmount(BigDecimal.ZERO);
        tmsPayableFeeList.forEach(item ->{

            BigDecimal rmbAmount = item.getPayableHkbAmount()
                    .multiply(exchangeRate)
                    .setScale(2, RoundingMode.HALF_UP);
            item.setPayableRmbSumAmount( item.getPayableRmbAmount().add(rmbAmount));
            tmsApBill.setSettleAmount(tmsApBill.getSettleAmount().add(item.getPayableRmbSumAmount()));

        });
        tmsApBill.setTmsPayableFeeList(tmsPayableFeeList);
        tmsApBill.setActualSettlementAmount(tmsApBill.getSettleAmount());
        return tmsApBill;
    }

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

        TmsApBill tmsApBill = initApGenerate(ids);
        tmsApBill.setSystemNo(systemDataNoService.getNoByKey(SystemDataNoEnum.YFZD));
        tmsApBill.setSettledAmount(BigDecimal.ZERO);
        tmsApBill.setInvoiceStatus(0);
        tmsApBill.setStatus(0);
        tmsApBill.setCreateBy(SecurityUtils.getUsername());
        tmsApBillMapper.insertTmsApBill(tmsApBill);

        tmsPayableFeeMapper.update(new LambdaUpdateWrapper<TmsPayableFee>()
                .set(TmsPayableFee::getBillPayableId,tmsApBill.getId())
                .set(TmsPayableFee::getBillPayableNo,tmsApBill.getSystemNo())
                .set(TmsPayableFee::getStatus,1)
                .in(TmsPayableFee::getId, ids)
        );
        List<TmsPayableFee> tmsPayableFeeList = tmsApBill.getTmsPayableFeeList();
        List<TmsApBillItem> rmb = tmsPayableFeeList.stream().map(item -> {
            TmsApBillItem billItem = new TmsApBillItem();
            billItem.setBillId(tmsApBill.getId());
            billItem.setProjectName(item.getProjectName());
            billItem.setDispatchNo(item.getDispatchNo());
            billItem.setOrderTime(item.getCreateTime());
            billItem.setEstimateAmount(item.
                    getPayableRmbSumAmount());
            billItem.setCurrency("RMB");
            billItem.setApFeeId(item.getId());
            billItem.setStatus(0);
            return billItem;
        }).collect(Collectors.toList());
        if (!rmb.isEmpty()){
            tmsApBillItemMapper.insertTmsApBillItemBatch(rmb);
        }
        return AjaxResult.success();
    }

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