package com.ruoyi.system.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.ruoyi.common.basic.PageInfo;
import com.ruoyi.common.core.domain.BaseModel;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.dto.AddProcurementDto;
import com.ruoyi.system.export.PlatformLedgerReportExport;
import com.ruoyi.system.export.ProcurementReportClinicExport;
import com.ruoyi.system.export.ProcurementReportDetailExport;
import com.ruoyi.system.export.ProcurementReportPlatformExport;
import com.ruoyi.system.export.ProcurementReportSupplierExport;
import com.ruoyi.system.mapper.*;
import com.ruoyi.system.model.*;
import com.ruoyi.system.query.ClinicProcurementReportQuery;
import com.ruoyi.system.query.PerformanceReportQuery;
import com.ruoyi.system.query.TErpGoodsQuery;
import com.ruoyi.system.query.TErpProcurementQuery;
import com.ruoyi.system.service.ISysUserService;
import com.ruoyi.system.service.TErpProcurementGoodsService;
import com.ruoyi.system.service.TErpProcurementService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.system.vo.*;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * <p>
 * erp采购 服务实现类
 * </p>
 *
 * @author xiaochen
 * @since 2025-08-20
 */
@Service
public class TErpProcurementServiceImpl extends ServiceImpl<TErpProcurementMapper, TErpProcurement> implements TErpProcurementService {

    @Resource
    private TErpProcurementGoodsMapper erpProcurementGoodsMapper;

    @Resource
    private TSysCommissionMapper sysCommissionMapper;

    @Resource
    private TCrmClinicMapper crmClinicMapper;

    @Resource
    private TCrmSupplierMapper crmSupplierMapper;

    @Resource
    private SysUserMapper sysUserMapper;

    @Resource
    private TErpGoodsMapper erpGoodsMapper;

    @Resource
    private TErpGoodsTypeMapper erpGoodsTypeMapper;

    @Resource
    private TErpGoodsUnitMapper erpGoodsUnitMapper;

    @Autowired
    private TErpProcurementGoodsService erpProcurementGoodsService;

    @Resource
    private TErpSupplierWarehousingMapper erpSupplierWarehousingMapper;

    @Resource
    private TErpSupplierWarehousingBatchMapper erpSupplierWarehousingBatchMapper;

    @Resource
    private TErpSupplierOutboundMapper erpSupplierOutboundMapper;

    @Resource
    private TErpSupplierOutboundGoodsMapper erpSupplierOutboundGoodsMapper;

    @Resource
    private TCrmWarehouseMapper crmWarehouseMapper;
    @Resource
    private TCrmBranchMapper crmBranchMapper;
    @Resource
    private TCrmSalespersonMapper crmSalespersonMapper;
    @Resource
    private TCrmChangePointsMapper crmChangePointsMapper;
    @Resource
    private TErpProcurementCommissionMapper erpProcurementCommissionMapper;

    @Autowired
    private ISysUserService sysUserService;
    @Autowired
    private TCrmBranchAreaMapper crmBranchAreaMapper;


    @Override
    public PageInfo<TErpProcurementVo> pageList(TErpProcurementQuery query, SysUser user) {


        Integer roleType = user.getRoleType();
        String supplierClinicId = null;
        if (roleType == 4) {
            // 供应商
            TCrmSupplier crmSupplier = crmSupplierMapper.selectOne(Wrappers.lambdaQuery(TCrmSupplier.class)
                    .eq(TCrmSupplier::getUserId, user.getUserId())
                    .last("LIMIT 1"));
            // ***
            if(Objects.isNull(crmSupplier)){
                SysUser sysUser = sysUserService.selectUserById(user.getUserId());
                crmSupplier = crmSupplierMapper.selectById(sysUser.getObjectId());
            }
            supplierClinicId = crmSupplier.getId();
        }
        if (roleType == 5) {
            // 诊所
            TCrmClinic crmClinic = crmClinicMapper.selectOne(Wrappers.lambdaQuery(TCrmClinic.class)
                    .eq(TCrmClinic::getUserId, user.getUserId())
                    .last("LIMIT 1"));
            // ***
            if(Objects.isNull(crmClinic)){
                SysUser sysUser = sysUserService.selectUserById(user.getUserId());
                crmClinic = crmClinicMapper.selectById(sysUser.getObjectId());
            }
            supplierClinicId = crmClinic.getId();
        }

        String sTime = null;
        String eTime = null;
        if (query.getTime() != null && !query.getTime().isEmpty()) {
            String[] split = query.getTime().split(" - ");
            sTime = split[0] + " 00:00:00";
            eTime = split[1] + " 23:59:59";
        }
        PageInfo<TErpProcurementVo> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());
        List<TErpProcurementVo> list = this.baseMapper.pageList(query, pageInfo, user, sTime, eTime, supplierClinicId);
        if (list.isEmpty()) {
            return pageInfo;
        }
        List<String> ids = list.stream().map(TErpProcurementVo::getId).collect(Collectors.toList());
        List<TErpProcurementGoods> tErpProcurementGoods = erpProcurementGoodsMapper.selectList
                (new LambdaQueryWrapper<TErpProcurementGoods>().in(TErpProcurementGoods::getProcurementId, ids));
////        List<TSysCommission> tSysCommissions = new ArrayList<>();
//        if (!tErpProcurementGoods.isEmpty()) {
////            List<String> collect = tErpProcurementGoods.stream().map(TErpProcurementGoods::getId).collect(Collectors.toList());
////            tSysCommissions = sysCommissionMapper.selectList(new LambdaQueryWrapper<TSysCommission>().in(TSysCommission::getTErpProcurementGoodsId, collect));
//        }
        for (TErpProcurementVo tErpProcurementVo : list) {
            List<TErpProcurementGoods> collect = tErpProcurementGoods.stream().filter(e -> e.getProcurementId().equals(tErpProcurementVo.getId())).collect(Collectors.toList());
            int size = collect.stream().map(TErpProcurementGoods::getGoodsId).collect(Collectors.toSet()).size();
            tErpProcurementVo.setTypeNum(size);
            BigDecimal reduce = collect.stream().map(TErpProcurementGoods::getTotalPrice).reduce(BigDecimal.ZERO, BigDecimal::add);
            tErpProcurementVo.setTotalPrice(reduce);
//            if (!collect.isEmpty()) {
////                List<String> collect1 = collect.stream().map(TErpProcurementGoods::getId).collect(Collectors.toList());
////                List<TSysCommission> collect2 = tSysCommissions.stream().filter(e -> collect1.contains(e.getTErpProcurementGoodsId())).collect(Collectors.toList());
////                BigDecimal reduce1 = collect2.stream().filter(e -> e.getType() == 1).map(TSysCommission::getMoney).reduce(BigDecimal.ZERO, BigDecimal::add);
////                BigDecimal reduce2 = collect2.stream().filter(e -> e.getType() == 2).map(TSysCommission::getMoney).reduce(BigDecimal.ZERO, BigDecimal::add);
////                tErpProcurementVo.setPlatformMoney(reduce1);
////                tErpProcurementVo.setSupplierMoney(reduce2);
//            }

        }


        pageInfo.setRecords(list);
        return pageInfo;
    }

    @Override
    public PageInfo<TErpProcurementVo> pageListWarehouse(TErpProcurementQuery query, SysUser user) {


        Integer roleType = user.getRoleType();
        List<String> supplierClinicId = null;
        if (roleType == 6) {

            TCrmWarehouse warehouse = crmWarehouseMapper.selectOne(Wrappers.lambdaQuery(TCrmWarehouse.class)
                    .eq(TCrmWarehouse::getUserId, user.getUserId())
                    .last("LIMIT 1"));
            // 供应商
            supplierClinicId = crmSupplierMapper.selectList(Wrappers.lambdaQuery(TCrmSupplier.class)
                    .eq(TCrmSupplier::getWarehouseId, warehouse.getId())).stream().map(TCrmSupplier::getId).collect(Collectors.toList());
            String sTime = null;
            String eTime = null;
            if (query.getTime() != null && !query.getTime().isEmpty()) {
                String[] split = query.getTime().split(" - ");
                sTime = split[0] + " 00:00:00";
                eTime = split[1] + " 23:59:59";
            }

            PageInfo<TErpProcurementVo> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());
            if(CollectionUtils.isEmpty(supplierClinicId)){
                return pageInfo;
            }
            List<TErpProcurementVo> list = this.baseMapper.pageListWarehouse(query, pageInfo, user, sTime, eTime, supplierClinicId);
//            if (list.isEmpty()) {
//                return pageInfo;
//            }
//            List<String> ids = list.stream().map(TErpProcurementVo::getId).collect(Collectors.toList());
//            List<TErpProcurementGoods> tErpProcurementGoods = erpProcurementGoodsMapper.selectList
//                    (new LambdaQueryWrapper<TErpProcurementGoods>().in(TErpProcurementGoods::getProcurementId, ids));
//            List<TSysCommission> tSysCommissions = new ArrayList<>();
//            if (!tErpProcurementGoods.isEmpty()) {
//                List<String> collect = tErpProcurementGoods.stream().map(TErpProcurementGoods::getId).collect(Collectors.toList());
//                tSysCommissions = sysCommissionMapper.selectList(new LambdaQueryWrapper<TSysCommission>().in(TSysCommission::getTErpProcurementGoodsId, collect));
//            }
//            for (TErpProcurementVo tErpProcurementVo : list) {
//                List<TErpProcurementGoods> collect = tErpProcurementGoods.stream().filter(e -> e.getProcurementId().equals(tErpProcurementVo.getId())).collect(Collectors.toList());
//                int size = collect.stream().map(TErpProcurementGoods::getGoodsId).collect(Collectors.toSet()).size();
//                tErpProcurementVo.setTypeNum(size);
//                BigDecimal reduce = collect.stream().map(TErpProcurementGoods::getTotalPrice).reduce(BigDecimal.ZERO, BigDecimal::add);
//                tErpProcurementVo.setTotalPrice(reduce);
//                if (!collect.isEmpty()) {
//                    List<String> collect1 = collect.stream().map(TErpProcurementGoods::getId).collect(Collectors.toList());
//                    List<TSysCommission> collect2 = tSysCommissions.stream().filter(e -> collect1.contains(e.getTErpProcurementGoodsId())).collect(Collectors.toList());
//                    BigDecimal reduce1 = collect2.stream().filter(e -> e.getType() == 1).map(TSysCommission::getMoney).reduce(BigDecimal.ZERO, BigDecimal::add);
//                    BigDecimal reduce2 = collect2.stream().filter(e -> e.getType() == 2).map(TSysCommission::getMoney).reduce(BigDecimal.ZERO, BigDecimal::add);
//                    tErpProcurementVo.setPlatformMoney(reduce1);
//                    tErpProcurementVo.setSupplierMoney(reduce2);
//                }
//
//            }


            pageInfo.setRecords(list);
            return pageInfo;
        }
        return null;
    }

    @Override
    public TErpProcurementDetailVo detail(String id, SysUser user, String goodsName) {

        Integer roleType = user.getRoleType();
        String supplierClinicId = null;
        if (roleType == 4) {
            // 供应商
            TCrmSupplier crmSupplier = crmSupplierMapper.selectOne(Wrappers.lambdaQuery(TCrmSupplier.class)
                    .eq(TCrmSupplier::getUserId, user.getUserId())
                    .last("LIMIT 1"));
            // ***
            if(Objects.isNull(crmSupplier)){
                SysUser sysUser = sysUserService.selectUserById(user.getUserId());
                crmSupplier = crmSupplierMapper.selectById(sysUser.getObjectId());
            }
            supplierClinicId = crmSupplier.getId();
        }
        if (roleType == 5) {
            // 诊所
            TCrmClinic crmClinic = crmClinicMapper.selectOne(Wrappers.lambdaQuery(TCrmClinic.class)
                    .eq(TCrmClinic::getUserId, user.getUserId())
                    .last("LIMIT 1"));
            // ***
            if(Objects.isNull(crmClinic)){
                SysUser sysUser = sysUserService.selectUserById(user.getUserId());
                crmClinic = crmClinicMapper.selectById(sysUser.getObjectId());
            }
            supplierClinicId = crmClinic.getId();
        }

        TErpProcurementDetailVo tErpProcurementVo = new TErpProcurementDetailVo();

        TErpProcurement tErpProcurement = this.getById(id);
        tErpProcurementVo.setId(id);
        tErpProcurementVo.setProcurementCode(tErpProcurement.getProcurementCode());
        tErpProcurementVo.setClinicId(tErpProcurement.getClinicId());

        TCrmClinic tCrmClinic = crmClinicMapper.selectById(tErpProcurement.getClinicId());
        tErpProcurementVo.setClinicName(tCrmClinic.getClinicName());
        tErpProcurementVo.setUserName(tCrmClinic.getPersonChargeName());
        SysUser sysUser = sysUserMapper.selectUserById(Long.valueOf(tErpProcurement.getCreateId()));

        tErpProcurementVo.setUserName(sysUser.getNickName());
        tErpProcurementVo.setCreateTime(tErpProcurement.getCreateTime());
        tErpProcurementVo.setUpdateTime(tErpProcurement.getUpdateTime());
        if (tErpProcurement.getWarehousingUserId() != null) {
            SysUser sysUser1 = sysUserMapper.selectUserById(Long.valueOf(tErpProcurement.getWarehousingUserId()));
            tErpProcurementVo.setOperName(sysUser1.getNickName());
        }
        tErpProcurementVo.setStatus(tErpProcurement.getStatus());
        tErpProcurementVo.setSendTime(tErpProcurement.getSendTime());

        tErpProcurementVo.setMoney(tErpProcurement.getMoney());
        tErpProcurementVo.setTotalPrice(tErpProcurement.getPayMoney());

        List<TErpProcurementGoods> tErpProcurementGoods = erpProcurementGoodsMapper.selectList
                (new LambdaQueryWrapper<TErpProcurementGoods>().eq(TErpProcurementGoods::getProcurementId, id)
                        .like(goodsName != null && !goodsName.isEmpty(), TErpProcurementGoods::getGoodsName, goodsName)
                        .eq(TErpProcurementGoods::getSupplierId, supplierClinicId));
        if (tErpProcurementGoods.isEmpty()) {
            return tErpProcurementVo;
        }

        ArrayList<TErpProcurementDetailNextVo> tErpProcurementDetailNextVos = new ArrayList<>();
        for (TErpProcurementGoods tErpProcurementGood : tErpProcurementGoods) {
            TErpProcurementDetailNextVo tErpProcurementDetailNextVo = new TErpProcurementDetailNextVo();
            BeanUtils.copyProperties(tErpProcurementGood, tErpProcurementDetailNextVo);
            tErpProcurementDetailNextVo.setGoodsName(tErpProcurementGood.getGoodsName());
            tErpProcurementDetailNextVo.setUnitName(tErpProcurementGood.getUnitName());
            tErpProcurementDetailNextVo.setNum(tErpProcurementGood.getPurchaseCount());
            tErpProcurementDetailNextVo.setTotalPrice(tErpProcurementGood.getTotalPrice());
            tErpProcurementDetailNextVo.setQuasiNumber(tErpProcurementGood.getQuasiNumber());
            tErpProcurementDetailNextVo.setPurchasePrice(tErpProcurementGood.getSalesAmount());


            List<TSysCommission> tSysCommissions = sysCommissionMapper.selectList(new LambdaQueryWrapper<TSysCommission>().eq(TSysCommission::getTErpProcurementGoodsId, tErpProcurementGood.getId()));
            if (!tSysCommissions.isEmpty()) {
                BigDecimal reduce = tSysCommissions.stream().filter(e -> e.getType() == 1).map(TSysCommission::getMoney).reduce(BigDecimal.ZERO, BigDecimal::add);
                tErpProcurementDetailNextVo.setPlatformMoney(reduce);
                BigDecimal reduce1 = tSysCommissions.stream().filter(e -> e.getType() == 2).map(TSysCommission::getMoney).reduce(BigDecimal.ZERO, BigDecimal::add);
                tErpProcurementDetailNextVo.setSupplierMoney(reduce1);
            }
            tErpProcurementDetailNextVos.add(tErpProcurementDetailNextVo);

        }
        tErpProcurementVo.setList(tErpProcurementDetailNextVos);
        return tErpProcurementVo;
    }

    @Override
    public PageInfo<TErpGoods> pageGoodsPageList(TErpGoodsQuery query, SysUser user) {
        PageInfo<TErpGoods> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());

        // 获取未禁用的供应商
        List<TCrmSupplier> suppliers = crmSupplierMapper.selectList(new LambdaQueryWrapper<TCrmSupplier>().eq(TCrmSupplier::getStatus, 1));
        if(suppliers.isEmpty()){
            return pageInfo;
        }
        PageInfo<TErpGoods> p = erpGoodsMapper.selectPage(pageInfo, new LambdaQueryWrapper<TErpGoods>()
                .like(StringUtils.isNotBlank(query.getGoodsName()), TErpGoods::getGoodsName, query.getGoodsName())
                .like(StringUtils.isNotBlank(query.getGoodsIdCode()), TErpGoods::getGoodsIdCode, query.getGoodsIdCode())
                .like(StringUtils.isNotBlank(query.getQuasiNumber()), TErpGoods::getQuasiNumber, query.getQuasiNumber())
                .eq(StringUtils.isNotBlank(query.getTypeId()),TErpGoods::getTypeId, query.getTypeId())
                .eq(TErpGoods::getState,1)
                .eq(TErpGoods::getGoodsSource, 1)
                .in(TErpGoods::getSupplierClinicId, suppliers.stream().map(TCrmSupplier::getId).collect(Collectors.toList()))
                .isNotNull(TErpGoods::getClinicPurchasePrice)
                .orderByDesc(BaseModel::getCreateTime));
        List<TErpGoods> list = p.getRecords();

        List<String> typeIds = list.stream().map(TErpGoods::getTypeId).collect(Collectors.toList());
        if (!typeIds.isEmpty()) {
            List<TErpGoodsType> typeList = erpGoodsTypeMapper.selectBatchIds(typeIds);
            for (TErpGoods tErpGoodsVO : list) {
                typeList.stream().filter(t -> t.getId().equals(tErpGoodsVO.getTypeId())).findFirst().ifPresent(t -> tErpGoodsVO.setTypeName(t.getTypeName()));
                tErpGoodsVO.setTypeName(tErpGoodsVO.getTypeName());
            }
        }
        List<String> supplierClinicId = list.stream().filter(e -> e.getGoodsSource() == 1).map(TErpGoods::getSupplierClinicId).collect(Collectors.toList());
        if (!supplierClinicId.isEmpty()) {
            List<TCrmSupplier> crmClinics = crmSupplierMapper.selectBatchIds(supplierClinicId);
            for (TErpGoods tErpGoodsVO : list) {
                crmClinics.stream().filter(t -> t.getId().equals(tErpGoodsVO.getSupplierClinicId())).findFirst().ifPresent(t -> tErpGoodsVO.setSupplierName(t.getSupplierName()));
            }
        }
        pageInfo.setRecords(list);
        return pageInfo;
    }

    @Override
    public List<TErpGoodsVO> inventoryNotEnoughList(SysUser user) {
        // 查询诊所
        TCrmClinic crmClinic = crmClinicMapper.selectOne(new LambdaQueryWrapper<TCrmClinic>().eq(TCrmClinic::getUserId, user.getUserId())
                .last("limit 1"));
        if (Objects.isNull(crmClinic)) {
            SysUser sysUser = sysUserService.selectUserById(user.getUserId());
            crmClinic = crmClinicMapper.selectById(sysUser.getObjectId());
        }
        List<TErpGoodsVO> list = this.baseMapper.inventoryNotEnoughList(user,crmClinic.getId());
        List<String> typeIds = list.stream().map(TErpGoodsVO::getTypeId).collect(Collectors.toList());
        if (!typeIds.isEmpty()) {
            List<TErpGoodsType> typeList = erpGoodsTypeMapper.selectBatchIds(typeIds);
            for (TErpGoodsVO tErpGoodsVO : list) {
                typeList.stream().filter(t -> t.getId().equals(tErpGoodsVO.getTypeId())).findFirst().ifPresent(t -> tErpGoodsVO.setTypeName(t.getTypeName()));
            }
        }
        List<String> supplierClinicId = list.stream().filter(e -> e.getGoodsSource() == 1).map(TErpGoodsVO::getSupplierClinicId).collect(Collectors.toList());
        if (!supplierClinicId.isEmpty()) {
            List<TCrmSupplier> crmSuppliers = crmSupplierMapper.selectBatchIds(supplierClinicId);
            for (TErpGoodsVO tErpGoodsVO : list) {
                crmSuppliers.stream().filter(t -> t.getId().equals(tErpGoodsVO.getSupplierClinicId())).findFirst().ifPresent(t -> tErpGoodsVO.setSupplierName(t.getSupplierName()));
            }
        }

        return list;
    }

    @Override
    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
    public void addProcurement(String clinicSupplierId, SysUser user, List<AddProcurementDto> dtos) {
        List<String> goodsIds = dtos.stream().map(AddProcurementDto::getGoodsId).collect(Collectors.toList());
        List<TErpGoods> tErpGoods = erpGoodsMapper.selectBatchIds(goodsIds);
        for (AddProcurementDto dto : dtos) {
            TErpGoods tErpGoodsVO = tErpGoods.stream().filter(t -> t.getId().equals(dto.getGoodsId())).findFirst().get();
            dto.setPlatformCommissionPrice(tErpGoodsVO.getPlatformCommissionPrice());
            dto.setSupplierId(tErpGoodsVO.getSupplierClinicId());
            dto.setGoodsSalesAmount(tErpGoodsVO.getClinicPurchasePrice());
            if (dto.getSalesAmount() == null) {
                dto.setSalesAmount(tErpGoodsVO.getClinicPurchasePrice());
            }
        }
        // 供应商分组
        Map<String, List<AddProcurementDto>> supplierClinicIdListMap = dtos.stream().collect(Collectors.groupingBy(AddProcurementDto::getSupplierId));
        for (Map.Entry<String, List<AddProcurementDto>> entry : supplierClinicIdListMap.entrySet()) {
            String supplierClinicId = entry.getKey();
            TCrmSupplier supplier = crmSupplierMapper.selectById(supplierClinicId);
            List<AddProcurementDto> value = entry.getValue();
            TErpProcurement tErpProcurement = new TErpProcurement();
            tErpProcurement.setClinicId(clinicSupplierId);

            tErpProcurement.setSupplierId(supplierClinicId);

            tErpProcurement.setTermNo(supplier.getTermNo());
            tErpProcurement.setMerchantNo(supplier.getRecvMerchantNo());
            tErpProcurement.setCreateId(user.getUserId().toString());

            BigDecimal all = BigDecimal.ZERO;

            for (AddProcurementDto addProcurementDto : value) {
                if(addProcurementDto.getGoodsSalesAmount()!= null && addProcurementDto.getPurchaseCount()!=null){
                    BigDecimal multiply = addProcurementDto.getGoodsSalesAmount().multiply(BigDecimal.valueOf(addProcurementDto.getPurchaseCount()));
                    all = all.add(multiply);
                }

            }
            tErpProcurement.setPayMoney(all);
            AddProcurementDto addProcurementDto = value.get(0);
            if (addProcurementDto.getState() != null && addProcurementDto.getState() == 1) {
                tErpProcurement.setStatus(1);
            } else {
                tErpProcurement.setStatus(2);
            }
            ArrayList<TErpProcurementGoods> tErpProcurementGoods1 = new ArrayList<>();

            BigDecimal add = BigDecimal.ZERO;


            BigDecimal supplierCommissionPrice = BigDecimal.ZERO;

            for (AddProcurementDto dto : value) {
                TErpProcurementGoods tErpProcurementGoods = new TErpProcurementGoods();
                tErpProcurementGoods.setProcurementId(tErpProcurement.getId());
                TErpGoods goods = tErpGoods.stream().filter(e -> e.getId().equals(dto.getGoodsId())).findFirst().get();

                BeanUtils.copyProperties(goods, tErpProcurementGoods);
                if (goods.getContentState()==null || goods.getContentState()!=1) {
                    tErpProcurementGoods.setContent(null);

                }

                tErpProcurementGoods.setGoodsId(dto.getGoodsId());
                tErpProcurementGoods.setGoodsName(goods.getGoodsName());
                tErpProcurementGoods.setSupplierName(supplier.getSupplierName());
                tErpProcurementGoods.setQuasiNumber(goods.getQuasiNumber());

                TErpGoodsUnit tErpGoodsUnit = erpGoodsUnitMapper.selectById(goods.getPackingUnitId());
                if(tErpGoodsUnit!=null){
                    tErpProcurementGoods.setUnitName(tErpGoodsUnit.getUnitName());
                }
                tErpProcurementGoods.setPurchasePrice(dto.getGoodsSalesAmount());
                tErpProcurementGoods.setSalesAmount(dto.getSalesAmount());
                if(dto.getPurchaseCount()!=null && dto.getGoodsSalesAmount()!=null){
                    tErpProcurementGoods.setTotalPrice(dto.getGoodsSalesAmount().multiply(new BigDecimal(dto.getPurchaseCount())));
                }

                tErpProcurementGoods.setPurchaseCount(dto.getPurchaseCount());
                tErpProcurementGoods.setSupplierId(supplierClinicId);
                tErpProcurementGoods.setRecvMerchantNo(supplier.getRecvMerchantNo());
                tErpProcurementGoods.setSupplierMoney(dto.getGoodsSalesAmount().subtract(dto.getPlatformCommissionPrice()));
                if(dto.getPurchaseCount()!=null){
                    supplierCommissionPrice = supplierCommissionPrice.add(tErpProcurementGoods.getSupplierMoney().multiply(BigDecimal.valueOf(dto.getPurchaseCount())));
                }
                if (tErpProcurementGoods.getSupplierMoney().doubleValue() < 0) {
                    throw new RuntimeException("平台抽成不能大于售卖价格");
                }
                if(dto.getPurchaseCount()!=null){
                    add = add.add(dto.getPlatformCommissionPrice().multiply(BigDecimal.valueOf(dto.getPurchaseCount())));
                }
                tErpProcurementGoods1.add(tErpProcurementGoods);
            }
            BigDecimal bigDecimal = tErpProcurement.getPayMoney().multiply(BigDecimal.valueOf(0.0038)).setScale(2, RoundingMode.HALF_UP);

            tErpProcurement.setMoney(add.subtract(bigDecimal));
            if (tErpProcurement.getMoney().doubleValue() < 0) {
                throw new RuntimeException("金额设置错误，请联系平台管理员");
            }
            tErpProcurement.setSupplierMoney(supplierCommissionPrice);


            // 获取上一条最新的数据
            TErpProcurement tErpProcurement1 = this.baseMapper.selectOne(new QueryWrapper<TErpProcurement>()
                    .orderByDesc("create_time")
                    .orderByDesc("procurement_code").last("limit 1"));
            if(tErpProcurement1==null){
                tErpProcurement.setProcurementCode("C" + DateUtils.dateTimeNow()+"00001");
            }else {
                String lastProcurementCode = tErpProcurement1.getProcurementCode();
                String datePart = "C" + DateUtils.dateTimeNow();

                // 直接获取后五位数字并+1，不考虑是否同一天
                try {
                    String numberPart = lastProcurementCode.substring(Math.max(0, lastProcurementCode.length() - 5));
                    int number = Integer.parseInt(numberPart);
                    if (number < 99999) {
                        number++;
                    } else {
                        number = 2; // 达到99999后重置为00002
                    }
                    tErpProcurement.setProcurementCode(datePart + String.format("%05d", number));
                } catch (NumberFormatException e) {
                    // 如果解析失败，默认从00001开始
                    tErpProcurement.setProcurementCode(datePart + "00001");
                }

            }
            try {
                this.save(tErpProcurement);
            }catch (Exception e){
                e.printStackTrace();
                throw new RuntimeException("网络繁忙，请重试");
            }
            for (TErpProcurementGoods tErpProcurementGoods : tErpProcurementGoods1) {
                tErpProcurementGoods.setId(null);
                tErpProcurementGoods.setProcurementId(tErpProcurement.getId());
            }
            erpProcurementGoodsService.saveBatch(tErpProcurementGoods1);
        }

    }

    @Override
    public DetailProcurementVO detailProcurement(String clinicSupplierId, SysUser user, String id) {
        DetailProcurementVO detailProcurementVO = new DetailProcurementVO();
        TErpProcurement tErpProcurement = this.getById(id);
        if (tErpProcurement.getWarehousingUserId()!=null && !tErpProcurement.getWarehousingUserId().isEmpty()) {
            SysUser sysUser = sysUserMapper.selectUserById(Long.valueOf(tErpProcurement.getWarehousingUserId()));
            detailProcurementVO.setWarehousingUserName(sysUser.getNickName());
        }
        detailProcurementVO.setWarehousingTime(tErpProcurement.getWarehousingTime());


        detailProcurementVO.setStatus(tErpProcurement.getStatus());
        detailProcurementVO.setCreateTime(tErpProcurement.getCreateTime());
        detailProcurementVO.setSendTime(tErpProcurement.getSendTime());
        TCrmSupplier supplier = crmSupplierMapper.selectById(tErpProcurement.getSupplierId());
        detailProcurementVO.setSupplierName(supplier.getSupplierName());
        detailProcurementVO.setUserName(sysUserMapper.selectUserById(Long.valueOf(tErpProcurement.getCreateId())).getNickName());
        TCrmClinic tCrmClinic = crmClinicMapper.selectById(tErpProcurement.getClinicId());
        detailProcurementVO.setClinicName(tCrmClinic.getClinicName());
        detailProcurementVO.setClinicAddress(tCrmClinic.getClinicAddress());
        detailProcurementVO.setLogisticsNumber(tErpProcurement.getLogisticsNumber());
        List<TErpProcurementGoods> list = erpProcurementGoodsService.list(new QueryWrapper<TErpProcurementGoods>().eq("procurement_id", id));
        ArrayList<DetailProcurementNextVO> detailProcurementNextVOS = new ArrayList<>();
        for (TErpProcurementGoods tErpProcurementGoods : list) {
            DetailProcurementNextVO detailProcurementNextVO = new DetailProcurementNextVO();
            BeanUtils.copyProperties(tErpProcurementGoods, detailProcurementNextVO);
            detailProcurementNextVO.setGoodsName(tErpProcurementGoods.getGoodsName());
            detailProcurementNextVO.setQuasiNumber(tErpProcurementGoods.getQuasiNumber());
            detailProcurementNextVO.setPackingUnitName(tErpProcurementGoods.getUnitName());
            detailProcurementNextVO.setSalesAmount(tErpProcurementGoods.getSalesAmount());
            detailProcurementNextVO.setNum(tErpProcurementGoods.getPurchaseCount());
            detailProcurementNextVO.setTotalPrice(tErpProcurement.getPayMoney());
            detailProcurementNextVO.setId(tErpProcurementGoods.getId());
            detailProcurementNextVO.setPurchasePrice(tErpProcurementGoods.getPurchasePrice());

            List<TErpSupplierOutboundGoods> tErpSupplierOutboundGoods = erpSupplierOutboundGoodsMapper.selectList(new LambdaQueryWrapper<TErpSupplierOutboundGoods>().eq(TErpSupplierOutboundGoods::getProcurementGoodsId, tErpProcurementGoods.getId()));
            if(!tErpSupplierOutboundGoods.isEmpty()){
                ArrayList<DetailProcurementNextThreeVO> detailProcurementNextThreeVOS = new ArrayList<>();
                List<String> collect = tErpSupplierOutboundGoods.stream().map(TErpSupplierOutboundGoods::getWarehousingBatchId).collect(Collectors.toList());
                List<TErpSupplierWarehousingBatch> tErpSupplierWarehousingBatches = erpSupplierWarehousingBatchMapper.selectBatchIds(collect);
                for (TErpSupplierOutboundGoods tErpSupplierOutboundGood : tErpSupplierOutboundGoods) {
                    List<TErpSupplierWarehousingBatch> collect1 = tErpSupplierWarehousingBatches.stream().filter(e -> e.getId().equals(tErpSupplierOutboundGood.getWarehousingBatchId())).collect(Collectors.toList());
                    for (TErpSupplierWarehousingBatch tErpSupplierWarehousingBatch : collect1) {
                        DetailProcurementNextThreeVO detailProcurementNextThreeVO = new DetailProcurementNextThreeVO();
                        detailProcurementNextThreeVO.setBatchNumber(tErpSupplierWarehousingBatch.getBatchNumber());
                        detailProcurementNextThreeVO.setProductionDate(tErpSupplierWarehousingBatch.getProductionDate());
                        detailProcurementNextThreeVO.setExpirationDate(tErpSupplierWarehousingBatch.getExpiryDate());
                        detailProcurementNextThreeVO.setNum(tErpSupplierOutboundGood.getOutboundCount());
                        detailProcurementNextThreeVOS.add(detailProcurementNextThreeVO);
                    }
                }
                detailProcurementNextVO.setDetailProcurementNextThreeVOS(detailProcurementNextThreeVOS);
            }
            detailProcurementNextVOS.add(detailProcurementNextVO);
        }
        detailProcurementVO.setList(detailProcurementNextVOS);
        return detailProcurementVO;
    }

    @Override
    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
    public void detailProcurementSend(List<String> clinicSupplierId, SysUser user, String id,String logisticsNumber) {
        // 查出这个采购的下级商品
        List<TErpProcurementGoods> list = erpProcurementGoodsService.list(new QueryWrapper<TErpProcurementGoods>().eq("procurement_id", id));
        List<TErpSupplierWarehousing> tErpSupplierWarehousings = erpSupplierWarehousingMapper.selectList(new LambdaQueryWrapper<TErpSupplierWarehousing>()
                .in(TErpSupplierWarehousing::getSupplierId, clinicSupplierId).in(TErpSupplierWarehousing::getGoodsId, list.stream().map(TErpProcurementGoods::getGoodsId).collect(Collectors.toList()))
                .orderByAsc(BaseModel::getCreateTime));

        if(tErpSupplierWarehousings.isEmpty()){
            throw new RuntimeException("商品供应商未入库，请先入库");
        }

        List<TErpSupplierWarehousingBatch> tErpSupplierWarehousingBatches = erpSupplierWarehousingBatchMapper.selectList(new LambdaQueryWrapper<TErpSupplierWarehousingBatch>().in(TErpSupplierWarehousingBatch::getWarehousingId, tErpSupplierWarehousings.stream().map(TErpSupplierWarehousing::getId).collect(Collectors.toList())));
        // 获取所有的出库记录
        List<TErpSupplierOutboundGoods> tErpSupplierOutboundGoodsLists = erpSupplierOutboundGoodsMapper.selectList(new LambdaQueryWrapper<TErpSupplierOutboundGoods>().in(TErpSupplierOutboundGoods::getWarehousingBatchId, tErpSupplierWarehousingBatches.stream().map(TErpSupplierWarehousingBatch::getId).collect(Collectors.toList())));


        outer:for (TErpProcurementGoods tErpProcurementGoods : list) {
            // 分别入库
            String goodsId = tErpProcurementGoods.getGoodsId();
            // 查询这个供应商的 该商品是否入过库 未入库提示  出库判断库存 先找先入库的
            List<TErpSupplierWarehousing> collect = tErpSupplierWarehousings.stream().filter(e -> e.getGoodsId().equals(goodsId)).collect(Collectors.toList());
            if(collect.isEmpty()){
                throw new RuntimeException("商品供应商未入库，请先入库");
            }
            // 需要出库的数量
            Integer purchaseCount = tErpProcurementGoods.getPurchaseCount();


            if(purchaseCount==0){
                continue;
            }

            for (TErpSupplierWarehousing tErpSupplierWarehousing : collect) {
                List<TErpSupplierWarehousingBatch> warehousingBatches = tErpSupplierWarehousingBatches.stream().filter(e -> e.getWarehousingId().equals(tErpSupplierWarehousing.getId())).collect(Collectors.toList());
                for (TErpSupplierWarehousingBatch warehousingBatch : warehousingBatches) {
                    // 已出库数量
                    int sum = tErpSupplierOutboundGoodsLists.stream().filter(e -> e.getWarehousingBatchId().equals(warehousingBatch.getId())).mapToInt(TErpSupplierOutboundGoods::getOutboundCount).sum();
                    // 该批次剩余的数量
                    int count = warehousingBatch.getWarehousingNumber() - sum;

                    // 该批次没有数量 找下个批次
                    if(count==0 ){
                        continue;
                    }
                    // 如果大于这个数量 则使用这个批次
                    if(count>=purchaseCount){
                        // 添加出库记录
                        TErpSupplierOutbound tErpSupplierOutbound= new TErpSupplierOutbound();
                        tErpSupplierOutbound.setGoodsId(tErpSupplierWarehousing.getGoodsId());
                        tErpSupplierOutbound.setSupplierId(tErpSupplierWarehousing.getSupplierId());
                        tErpSupplierOutbound.setWarehouseId(tErpSupplierWarehousing.getWarehouseId());
                        tErpSupplierOutbound.setOutboundType(7);
                        //TODO 确定这个是采购价还是销售价格
                        tErpSupplierOutbound.setTotalMoney(tErpProcurementGoods.getPurchasePrice().multiply(new BigDecimal(purchaseCount)));

                        TErpSupplierOutbound last = erpSupplierOutboundMapper.selectOne(new LambdaQueryWrapper<TErpSupplierOutbound>().orderByDesc(BaseModel::getCreateTime).orderByDesc(TErpSupplierOutbound::getOutboundNumber).last("limit 1"));
                        if(last==null){
                            tErpSupplierOutbound.setOutboundNumber("G" + DateUtils.dateTimeNow()+"00001");
                        }else {
                            String lastProcurementCode = last.getOutboundNumber();
                            String datePart = "G" + DateUtils.dateTimeNow();

                            // 直接获取后五位数字并+1，不考虑是否同一天
                            try {
                                String numberPart = lastProcurementCode.substring(Math.max(0, lastProcurementCode.length() - 5));
                                int number = Integer.parseInt(numberPart);
                                if (number < 99999) {
                                    number++;
                                } else {
                                    number = 2; // 达到99999后重置为00002
                                }
                                tErpSupplierOutbound.setOutboundNumber(datePart + String.format("%05d", number));
                            } catch (NumberFormatException e) {
                                // 如果解析失败，默认从00001开始
                                tErpSupplierOutbound.setOutboundNumber(datePart + "00001");
                            }
                        }
                        try {
                            erpSupplierOutboundMapper.insert(tErpSupplierOutbound);
                        }catch (Exception e){
                            throw new RuntimeException("网络繁忙，请重试");
                        }

                        TErpSupplierOutboundGoods tErpSupplierOutboundGoods = new TErpSupplierOutboundGoods();
                        tErpSupplierOutboundGoods.setOutboundId(tErpSupplierOutbound.getId());
                        tErpSupplierOutboundGoods.setWarehousingId(tErpSupplierWarehousing.getId());
                        tErpSupplierOutboundGoods.setWarehousingBatchId(warehousingBatch.getId());
                        tErpSupplierOutboundGoods.setOutboundCount(purchaseCount);
                        tErpSupplierOutboundGoods.setTotalPrice(tErpProcurementGoods.getPurchasePrice().multiply(new BigDecimal(purchaseCount)));
                        tErpSupplierOutboundGoods.setProcurementGoodsId(tErpProcurementGoods.getId());
                        erpSupplierOutboundGoodsMapper.insert(tErpSupplierOutboundGoods);
                        continue outer;
                    }

                    if(count<purchaseCount){
                        purchaseCount = purchaseCount - count;
                        // 添加出库记录
                        TErpSupplierOutbound tErpSupplierOutbound= new TErpSupplierOutbound();
                        tErpSupplierOutbound.setGoodsId(tErpSupplierWarehousing.getGoodsId());
                        tErpSupplierOutbound.setSupplierId(tErpSupplierWarehousing.getSupplierId());
                        tErpSupplierOutbound.setWarehouseId(tErpSupplierWarehousing.getWarehouseId());
                        tErpSupplierOutbound.setOutboundType(7);
                        //TODO 确定这个是采购价还是销售价格
                        tErpSupplierOutbound.setTotalMoney(tErpProcurementGoods.getPurchasePrice().multiply(new BigDecimal(purchaseCount)));
                        TErpSupplierOutbound last = erpSupplierOutboundMapper.selectOne(new LambdaQueryWrapper<TErpSupplierOutbound>().orderByDesc(BaseModel::getCreateTime).orderByDesc(TErpSupplierOutbound::getOutboundNumber).last("limit 1"));
                        if(last==null){
                            tErpSupplierOutbound.setOutboundNumber("G" + DateUtils.dateTimeNow()+"00001");
                        }else {
                            String lastProcurementCode = last.getOutboundNumber();
                            String datePart = "G" + DateUtils.dateTimeNow();

                            // 直接获取后五位数字并+1，不考虑是否同一天
                            try {
                                String numberPart = lastProcurementCode.substring(Math.max(0, lastProcurementCode.length() - 5));
                                int number = Integer.parseInt(numberPart);
                                if (number < 99999) {
                                    number++;
                                } else {
                                    number = 2; // 达到99999后重置为00002
                                }
                                tErpSupplierOutbound.setOutboundNumber(datePart + String.format("%05d", number));
                            } catch (NumberFormatException e) {
                                // 如果解析失败，默认从00001开始
                                tErpSupplierOutbound.setOutboundNumber(datePart + "00001");
                            }
                        }

                        try {

                            erpSupplierOutboundMapper.insert(tErpSupplierOutbound);
                        }catch (Exception e){
                            throw new RuntimeException("网络繁忙，请重试");
                        }

                        TErpSupplierOutboundGoods tErpSupplierOutboundGoods = new TErpSupplierOutboundGoods();
                        tErpSupplierOutboundGoods.setOutboundId(tErpSupplierOutbound.getId());
                        tErpSupplierOutboundGoods.setWarehousingId(tErpSupplierWarehousing.getId());
                        tErpSupplierOutboundGoods.setWarehousingBatchId(warehousingBatch.getId());
                        tErpSupplierOutboundGoods.setOutboundCount(purchaseCount);
                        tErpSupplierOutboundGoods.setTotalPrice(tErpProcurementGoods.getPurchasePrice().multiply(new BigDecimal(purchaseCount)));
                        tErpSupplierOutboundGoods.setProcurementGoodsId(tErpProcurementGoods.getId());
                        erpSupplierOutboundGoodsMapper.insert(tErpSupplierOutboundGoods);
                    }

                }

            }
            if(purchaseCount>0){
                throw new RuntimeException("商品供应商库存不足，请先入库");
            }


        }
        TErpProcurement byId = this.getById(id);
        byId.setStatus(4);
        byId.setSendTime(LocalDateTime.now());
        byId.setLogisticsNumber(logisticsNumber);
        this.updateById(byId);

    }

    @Override
    public List<SupplierThirtyProcurementStatisticsVO> supplierThirtyProcurementStatistics(String supplierAndClinicId, String startTime, String endTime,Integer roleType) {
        return this.baseMapper.supplierThirtyProcurementStatistics(supplierAndClinicId, startTime, endTime, roleType);
    }

    @Override
    public List<SupplierThirtyMoneyProcurementStatisticsVO> supplierThirtyMoneyProcurementStatistics(String supplierAndClinicId, String startTime, String endTime,Integer roleType) {
        return this.baseMapper.supplierThirtyMoneyProcurementStatistics(supplierAndClinicId, startTime, endTime, roleType);
    }

    @Override
    public Integer supplierSalesStatisticsTypeCount(String supplierId) {
        return this.baseMapper.supplierSalesStatisticsTypeCount(supplierId);
    }

    @Override
    public Integer supplierSalesStatisticsCount(String supplierId) {
        return this.baseMapper.supplierSalesStatisticsCount(supplierId);
    }

    @Override
    public BigDecimal supplierSalesStatisticsMoney(String supplierId, String startTime, String endTime) {
        return this.baseMapper.supplierSalesStatisticsMoney(supplierId,startTime, endTime);
    }

    @Override
    public List<SupplierSalesStatisticsGoodsTypeVO> supplierSalesStatisticsGoodsType(String supplierId, String startTime, String endTime) {
        return this.baseMapper.supplierSalesStatisticsGoodsType(supplierId,startTime, endTime);
    }

    @Override
    public List<SupplierSalesStatisticsGoodsCountVO> supplierSalesStatisticsGoodsCount(String supplierId, String startTime, String endTime, String goodsName) {
        return this.baseMapper.supplierSalesStatisticsGoodsCount(supplierId,startTime, endTime,goodsName);
    }

    @Override
    public List<SupplierSalesStatisticsGoodsCountVO> supplierSalesStatisticsGoodsCountMonth(String supplierId, String startTime, String endTime, String goodsName) {
        return this.baseMapper.supplierSalesStatisticsGoodsCountMonth(supplierId,startTime, endTime,goodsName);
    }

    @Override
    public List<TErpProcurementGoods> branchAdminStatisticsThree(List<String> clinicIds) {
        return this.baseMapper.branchAdminStatisticsThree(clinicIds);
    }

    @Override
    public PageInfo<ClinicProcurementReportVO> clinicProcurementReport(ClinicProcurementReportQuery query) {
        PageInfo<ClinicProcurementReportVO> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());
        List<ClinicProcurementReportVO> list = this.baseMapper.clinicProcurementReport(query, pageInfo);
        if(CollectionUtils.isEmpty(list)){
            return pageInfo;
        }
        List<String> procurementIds = list.stream().map(TErpProcurement::getId).collect(Collectors.toList());
        List<TErpProcurementGoods> erpProcurementGoods = erpProcurementGoodsMapper.selectList(new QueryWrapper<TErpProcurementGoods>().lambda().in(TErpProcurementGoods::getProcurementId, procurementIds));
        for (ClinicProcurementReportVO clinicProcurementReportVO : list) {
            List<TErpProcurementGoods> procurementGoods = erpProcurementGoods.stream().filter(tErpProcurementGoods -> tErpProcurementGoods.getProcurementId().equals(clinicProcurementReportVO.getId())).collect(Collectors.toList());
            if(!CollectionUtils.isEmpty(procurementGoods)){
                int sum = procurementGoods.stream().mapToInt(TErpProcurementGoods::getPurchaseCount).sum();
                clinicProcurementReportVO.setProcurementGoodsNum(sum);
            }
        }
        pageInfo.setRecords(list);
        return pageInfo;
    }

    @Override
    public List<ProcurementReportClinicExport> exportProcurementReportClinic(ClinicProcurementReportQuery query) {
        List<ProcurementReportClinicExport> list = this.baseMapper.exportProcurementReportClinic(query);
        if(CollectionUtils.isEmpty(list)){
            return new ArrayList<>();
        }
        List<String> procurementIds = list.stream().map(ProcurementReportClinicExport::getId).collect(Collectors.toList());
        List<TErpProcurementGoods> erpProcurementGoods = erpProcurementGoodsMapper.selectList(new QueryWrapper<TErpProcurementGoods>().lambda().in(TErpProcurementGoods::getProcurementId, procurementIds));
        for (ProcurementReportClinicExport procurementReportClinicExport : list) {
            List<TErpProcurementGoods> procurementGoods = erpProcurementGoods.stream().filter(tErpProcurementGoods -> tErpProcurementGoods.getProcurementId().equals(procurementReportClinicExport.getId())).collect(Collectors.toList());
            if(!CollectionUtils.isEmpty(procurementGoods)){
                int sum = procurementGoods.stream().mapToInt(TErpProcurementGoods::getPurchaseCount).sum();
                procurementReportClinicExport.setProcurementGoodsNum(sum);
            }
            if(Objects.nonNull(procurementReportClinicExport.getPayTime())){
                String payTimeStr = new SimpleDateFormat("yyyy-MM-dd").format(DateUtils.localDateTimeToDate(procurementReportClinicExport.getPayTime()));
                procurementReportClinicExport.setPayTimeStr(payTimeStr);
            }
        }
        return list;
    }

    @Override
    public List<ProcurementReportSupplierExport> exportProcurementReportSupplier(ClinicProcurementReportQuery query) {
        List<ProcurementReportSupplierExport> list = this.baseMapper.exportProcurementReportSupplier(query);
        if(CollectionUtils.isEmpty(list)){
            return new ArrayList<>();
        }
        for (ProcurementReportSupplierExport procurementReportSupplierExport : list) {
            if(Objects.nonNull(procurementReportSupplierExport.getPayTime())){
                String payTimeStr = new SimpleDateFormat("yyyy-MM-dd").format(DateUtils.localDateTimeToDate(procurementReportSupplierExport.getPayTime()));
                procurementReportSupplierExport.setPayTimeStr(payTimeStr);
            }
        }
        return list;
    }

    @Override
    public List<ProcurementReportPlatformExport> exportProcurementReportPlatform(ClinicProcurementReportQuery query) {
        List<ProcurementReportPlatformExport> list = this.baseMapper.exportProcurementReportPlatform(query);
        if(CollectionUtils.isEmpty(list)){
            return new ArrayList<>();
        }
        for (ProcurementReportPlatformExport procurementReportPlatformExport : list) {
            if(Objects.nonNull(procurementReportPlatformExport.getPayTime())){
                String payTimeStr = new SimpleDateFormat("yyyy-MM-dd").format(DateUtils.localDateTimeToDate(procurementReportPlatformExport.getPayTime()));
                procurementReportPlatformExport.setPayTimeStr(payTimeStr);
            }
        }
        return list;
    }

    @Override
    public PageInfo<ClinicProcurementReportVO> platformLedgerReport(ClinicProcurementReportQuery query) {
        PageInfo<ClinicProcurementReportVO> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());
        List<ClinicProcurementReportVO> list = this.baseMapper.platformLedgerReport(query, pageInfo);
        pageInfo.setRecords(list);
        return pageInfo;
    }

    @Override
    public List<PlatformLedgerReportExport> exportPlatformLedgerReport(ClinicProcurementReportQuery query) {
        List<PlatformLedgerReportExport> list = this.baseMapper.exportPlatformLedgerReport(query);
        if(CollectionUtils.isEmpty(list)){
            return new ArrayList<>();
        }
        for (PlatformLedgerReportExport platformLedgerReportExport : list) {
            if(Objects.nonNull(platformLedgerReportExport.getPayTime())){
                String payTimeStr = new SimpleDateFormat("yyyy-MM-dd").format(DateUtils.localDateTimeToDate(platformLedgerReportExport.getPayTime()));
                platformLedgerReportExport.setPayTimeStr(payTimeStr);
            }
        }
        return list;
    }

    @Override
    public PageInfo<BranchPerformanceReportVO> branchPerformanceReport(PerformanceReportQuery query) {

        List<String> clinicIds = new ArrayList<>();
        List<TCrmBranchArea> crmBranchAreas = new ArrayList<>();
        if(StringUtils.isNotEmpty(query.getCityCode())){
            crmBranchAreas = crmBranchAreaMapper.selectList(Wrappers.lambdaQuery(TCrmBranchArea.class)
                    .eq(TCrmBranchArea::getCityCode, query.getCityCode())
                    .eq(TCrmBranchArea::getAreaType, 2));
            if(CollectionUtils.isEmpty(crmBranchAreas)){
                return new PageInfo<>();
            }
        }

        if(StringUtils.isNotEmpty(query.getProvinceCode())){
            crmBranchAreas = crmBranchAreaMapper.selectList(Wrappers.lambdaQuery(TCrmBranchArea.class)
                    .eq(TCrmBranchArea::getProvinceCode, query.getProvinceCode())
                    .eq(TCrmBranchArea::getAreaType, 2));
            if(CollectionUtils.isEmpty(crmBranchAreas)){
                return new PageInfo<>();
            }
        }
        if(!CollectionUtils.isEmpty(crmBranchAreas)){
            List<String> branchIds = crmBranchAreas.stream().map(TCrmBranchArea::getBranchId).collect(Collectors.toList());
            List<TCrmClinic> crmClinics = crmClinicMapper.selectList(Wrappers.lambdaQuery(TCrmClinic.class)
                    .in(TCrmClinic::getBranchId, branchIds));
            if(CollectionUtils.isEmpty(crmClinics)){
                return new PageInfo<>();
            }
            List<String> ids = crmClinics.stream().map(TCrmClinic::getId).collect(Collectors.toList());
            clinicIds.addAll(ids);
        }

        if(StringUtils.isNotBlank(query.getBranchName())){
            // 查询分公司名称
            List<TCrmBranch> crmBranches = crmBranchMapper.selectList(Wrappers.lambdaQuery(TCrmBranch.class)
                    .like(TCrmBranch::getBranchName, query.getBranchName()));
            if(CollectionUtils.isEmpty(crmBranches)){
                return new PageInfo<>();
            }
            List<String> branchIds = crmBranches.stream().map(TCrmBranch::getId).collect(Collectors.toList());
            List<TCrmClinic> crmClinics = crmClinicMapper.selectList(Wrappers.lambdaQuery(TCrmClinic.class)
                    .in(TCrmClinic::getBranchId, branchIds));
            if(CollectionUtils.isEmpty(crmClinics)){
                return new PageInfo<>();
            }
            List<String> ids = crmClinics.stream().map(TCrmClinic::getId).collect(Collectors.toList());
            clinicIds.addAll(ids);
        }
        clinicIds = clinicIds.stream().distinct().collect(Collectors.toList());
        query.setClinicIds(clinicIds);
        PageInfo<BranchPerformanceReportVO> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());

        List<BranchPerformanceReportVO> list = this.baseMapper.branchPerformanceReport(query, pageInfo);
        if(CollectionUtils.isEmpty(list)){
            return pageInfo;
        }
        List<String> procurementIds = list.stream().map(BranchPerformanceReportVO::getId).collect(Collectors.toList());

        // 查询可获得积分
        List<TCrmChangePoints> crmChangePoints = crmChangePointsMapper.selectList(Wrappers.lambdaQuery(TCrmChangePoints.class)
                .in(TCrmChangePoints::getProcurementId, procurementIds)
                .eq(TCrmChangePoints::getUserType, 1)
                .eq(TCrmChangePoints::getChangeType, 1)
                .eq(TCrmChangePoints::getChangeReason, 1));
        // 查询业绩
        List<TErpProcurementCommission> erpProcurementCommissions = erpProcurementCommissionMapper.selectList(Wrappers.lambdaQuery(TErpProcurementCommission.class)
                .in(TErpProcurementCommission::getProcurementId, procurementIds)
                .eq(TErpProcurementCommission::getCommissionType, 1));
        for (BranchPerformanceReportVO branchPerformanceReportVO : list) {
            // 查询可获得积分
            List<TCrmChangePoints> changePoints = crmChangePoints.stream().filter(tCrmChangePoints -> branchPerformanceReportVO.getId().equals(tCrmChangePoints.getProcurementId())).collect(Collectors.toList());
            if(!CollectionUtils.isEmpty(changePoints)){
                branchPerformanceReportVO.setAvailablePoints(changePoints.stream().mapToInt(TCrmChangePoints::getChangeValue).sum());
            }
            // 查询业绩
            List<TErpProcurementCommission> commissions = erpProcurementCommissions.stream().filter(tErpProcurementCommission -> branchPerformanceReportVO.getId().equals(tErpProcurementCommission.getProcurementId())).collect(Collectors.toList());
            if(!CollectionUtils.isEmpty(commissions)){
                branchPerformanceReportVO.setPerformance(commissions.stream().map(TErpProcurementCommission::getMoney).reduce(BigDecimal.ZERO, BigDecimal::add));
            }
        }
        pageInfo.setRecords(list);
        return pageInfo;
    }

    @Override
    public PageInfo<SalespersonPerformanceReportVO> salespersonPerformanceReport(PerformanceReportQuery query) {
        List<String> clinicIds = new ArrayList<>();

        if(StringUtils.isNotBlank(query.getBranchName())){
            // 查询分公司名称
            List<TCrmBranch> crmBranches = crmBranchMapper.selectList(Wrappers.lambdaQuery(TCrmBranch.class)
                    .like(TCrmBranch::getBranchName, query.getBranchName()));
            if(CollectionUtils.isEmpty(crmBranches)){
                return new PageInfo<>();
            }
            List<String> branchIds = crmBranches.stream().map(TCrmBranch::getId).collect(Collectors.toList());
            List<TCrmClinic> crmClinics = crmClinicMapper.selectList(Wrappers.lambdaQuery(TCrmClinic.class)
                    .in(TCrmClinic::getBranchId, branchIds));
            if(CollectionUtils.isEmpty(crmClinics)){
                return new PageInfo<>();
            }
            List<String> ids = crmClinics.stream().map(TCrmClinic::getId).collect(Collectors.toList());
            clinicIds.addAll(ids);
        }
        if(StringUtils.isNotBlank(query.getSalespersonName())){
            // 查询业务员名称
            List<TCrmSalesperson> crmSalespeopleList = crmSalespersonMapper.selectList(Wrappers.lambdaQuery(TCrmSalesperson.class)
                    .like(TCrmSalesperson::getSalespersonName, query.getSalespersonName()));
            if(CollectionUtils.isEmpty(crmSalespeopleList)){
                return new PageInfo<>();
            }
            List<String> salespersonIds = crmSalespeopleList.stream().map(TCrmSalesperson::getId).collect(Collectors.toList());
            List<TCrmClinic> crmClinics = crmClinicMapper.selectList(Wrappers.lambdaQuery(TCrmClinic.class)
                    .in(TCrmClinic::getSalespersonId, salespersonIds));
            if(CollectionUtils.isEmpty(crmClinics)){
                return new PageInfo<>();
            }
            List<String> ids = crmClinics.stream().map(TCrmClinic::getId).collect(Collectors.toList());
            clinicIds.addAll(ids);
        }
        clinicIds = clinicIds.stream().distinct().collect(Collectors.toList());
        query.setClinicIds(clinicIds);
        PageInfo<SalespersonPerformanceReportVO> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());
        List<SalespersonPerformanceReportVO> list = this.baseMapper.salespersonPerformanceReport(query, pageInfo);
        if(CollectionUtils.isEmpty(list)){
            return pageInfo;
        }
        List<String> procurementIds = list.stream().map(SalespersonPerformanceReportVO::getId).collect(Collectors.toList());

        // 查询可获得积分
        List<TCrmChangePoints> crmChangePoints = crmChangePointsMapper.selectList(Wrappers.lambdaQuery(TCrmChangePoints.class)
                .in(TCrmChangePoints::getProcurementId, procurementIds)
                .eq(TCrmChangePoints::getUserType, 2)
                .eq(TCrmChangePoints::getChangeType, 1)
                .eq(TCrmChangePoints::getChangeReason, 1));
        // 查询业绩
        List<TErpProcurementCommission> erpProcurementCommissions = erpProcurementCommissionMapper.selectList(Wrappers.lambdaQuery(TErpProcurementCommission.class)
                .in(TErpProcurementCommission::getProcurementId, procurementIds)
                .eq(TErpProcurementCommission::getCommissionType, 2));
        for (SalespersonPerformanceReportVO salespersonPerformanceReportVO : list) {
            // 查询可获得积分
            List<TCrmChangePoints> changePoints = crmChangePoints.stream().filter(tCrmChangePoints -> salespersonPerformanceReportVO.getId().equals(tCrmChangePoints.getProcurementId())).collect(Collectors.toList());
            if(!CollectionUtils.isEmpty(changePoints)){
                salespersonPerformanceReportVO.setAvailablePoints(changePoints.stream().mapToInt(TCrmChangePoints::getChangeValue).sum());
            }
            // 查询业绩
            List<TErpProcurementCommission> commissions = erpProcurementCommissions.stream().filter(tErpProcurementCommission -> salespersonPerformanceReportVO.getId().equals(tErpProcurementCommission.getProcurementId())).collect(Collectors.toList());
            if(!CollectionUtils.isEmpty(commissions)){
                salespersonPerformanceReportVO.setPerformance(commissions.stream().map(TErpProcurementCommission::getMoney).reduce(BigDecimal.ZERO, BigDecimal::add));
            }
        }
        pageInfo.setRecords(list);
        return pageInfo;
    }

    @Override
    public List<BranchPerformanceReportVO> exportBranchPerformanceReport(PerformanceReportQuery query) {
        List<String> clinicIds = new ArrayList<>();
        List<TCrmBranchArea> crmBranchAreas = new ArrayList<>();
        if(StringUtils.isNotEmpty(query.getCityCode())){
            crmBranchAreas = crmBranchAreaMapper.selectList(Wrappers.lambdaQuery(TCrmBranchArea.class)
                    .eq(TCrmBranchArea::getCityCode, query.getCityCode())
                    .eq(TCrmBranchArea::getAreaType, 2));
        }

        if(StringUtils.isNotEmpty(query.getProvinceCode())){
            crmBranchAreas = crmBranchAreaMapper.selectList(Wrappers.lambdaQuery(TCrmBranchArea.class)
                    .eq(TCrmBranchArea::getProvinceCode, query.getProvinceCode())
                    .eq(TCrmBranchArea::getAreaType, 2));
        }
        if(!CollectionUtils.isEmpty(crmBranchAreas)){
            List<String> branchIds = crmBranchAreas.stream().map(TCrmBranchArea::getBranchId).collect(Collectors.toList());
            List<TCrmClinic> crmClinics = crmClinicMapper.selectList(Wrappers.lambdaQuery(TCrmClinic.class)
                    .in(TCrmClinic::getBranchId, branchIds));
            if(CollectionUtils.isEmpty(crmClinics)){
                return new ArrayList<>();
            }
            List<String> ids = crmClinics.stream().map(TCrmClinic::getId).collect(Collectors.toList());
            clinicIds.addAll(ids);
        }
        if(StringUtils.isNotBlank(query.getBranchName())){
            // 查询分公司名称
            List<TCrmBranch> crmBranches = crmBranchMapper.selectList(Wrappers.lambdaQuery(TCrmBranch.class)
                    .like(TCrmBranch::getBranchName, query.getBranchName()));
            if(CollectionUtils.isEmpty(crmBranches)){
                return new ArrayList<>();
            }
            List<String> branchIds = crmBranches.stream().map(TCrmBranch::getId).collect(Collectors.toList());
            List<TCrmClinic> crmClinics = crmClinicMapper.selectList(Wrappers.lambdaQuery(TCrmClinic.class)
                    .in(TCrmClinic::getBranchId, branchIds));
            if(CollectionUtils.isEmpty(crmClinics)){
                return new ArrayList<>();
            }
            List<String> ids = crmClinics.stream().map(TCrmClinic::getId).collect(Collectors.toList());
            clinicIds.addAll(ids);
        }
        query.setClinicIds(clinicIds);
        List<BranchPerformanceReportVO> list = this.baseMapper.exportBranchPerformanceReport(query);
        if(CollectionUtils.isEmpty(list)){
            return new ArrayList<>();
        }
        List<String> procurementIds = list.stream().map(BranchPerformanceReportVO::getId).collect(Collectors.toList());

        // 查询可获得积分
        List<TCrmChangePoints> crmChangePoints = crmChangePointsMapper.selectList(Wrappers.lambdaQuery(TCrmChangePoints.class)
                .in(TCrmChangePoints::getProcurementId, procurementIds)
                .eq(TCrmChangePoints::getUserType, 1)
                .eq(TCrmChangePoints::getChangeType, 1)
                .eq(TCrmChangePoints::getChangeReason, 1));
        // 查询业绩
        List<TErpProcurementCommission> erpProcurementCommissions = erpProcurementCommissionMapper.selectList(Wrappers.lambdaQuery(TErpProcurementCommission.class)
                .in(TErpProcurementCommission::getProcurementId, procurementIds)
                .eq(TErpProcurementCommission::getCommissionType, 1));
        for (BranchPerformanceReportVO branchPerformanceReportVO : list) {
            // 查询可获得积分
            List<TCrmChangePoints> changePoints = crmChangePoints.stream().filter(tCrmChangePoints -> branchPerformanceReportVO.getId().equals(tCrmChangePoints.getProcurementId())).collect(Collectors.toList());
            if(!CollectionUtils.isEmpty(changePoints)){
                branchPerformanceReportVO.setAvailablePoints(changePoints.stream().mapToInt(TCrmChangePoints::getChangeValue).sum());
            }
            // 查询业绩
            List<TErpProcurementCommission> commissions = erpProcurementCommissions.stream().filter(tErpProcurementCommission -> branchPerformanceReportVO.getId().equals(tErpProcurementCommission.getProcurementId())).collect(Collectors.toList());
            if(!CollectionUtils.isEmpty(commissions)){
                branchPerformanceReportVO.setPerformance(commissions.stream().map(TErpProcurementCommission::getMoney).reduce(BigDecimal.ZERO, BigDecimal::add));
            }
            if(Objects.nonNull(branchPerformanceReportVO.getPayTime())){
                String payTimeStr = new SimpleDateFormat("yyyy-MM-dd").format(DateUtils.localDateTimeToDate(branchPerformanceReportVO.getPayTime()));
                branchPerformanceReportVO.setPayTimeStr(payTimeStr);
            }
        }
        return list;
    }

    @Override
    public List<SalespersonPerformanceReportVO> exportSalespersonPerformanceReport(PerformanceReportQuery query) {
        List<String> clinicIds = new ArrayList<>();

        if(StringUtils.isNotBlank(query.getBranchName())){
            // 查询分公司名称
            List<TCrmBranch> crmBranches = crmBranchMapper.selectList(Wrappers.lambdaQuery(TCrmBranch.class)
                    .like(TCrmBranch::getBranchName, query.getBranchName()));
            if(CollectionUtils.isEmpty(crmBranches)){
                return new ArrayList<>();
            }
            List<String> branchIds = crmBranches.stream().map(TCrmBranch::getId).collect(Collectors.toList());
            List<TCrmClinic> crmClinics = crmClinicMapper.selectList(Wrappers.lambdaQuery(TCrmClinic.class)
                    .in(TCrmClinic::getBranchId, branchIds));
            if(CollectionUtils.isEmpty(crmClinics)){
                return new ArrayList<>();
            }
            List<String> ids = crmClinics.stream().map(TCrmClinic::getId).collect(Collectors.toList());
            clinicIds.addAll(ids);
        }
        if(StringUtils.isNotBlank(query.getSalespersonName())){
            // 查询业务员名称
            List<TCrmSalesperson> crmSalespeopleList = crmSalespersonMapper.selectList(Wrappers.lambdaQuery(TCrmSalesperson.class)
                    .like(TCrmSalesperson::getSalespersonName, query.getSalespersonName()));
            if(CollectionUtils.isEmpty(crmSalespeopleList)){
                return new ArrayList<>();
            }
            List<String> salespersonIds = crmSalespeopleList.stream().map(TCrmSalesperson::getId).collect(Collectors.toList());
            List<TCrmClinic> crmClinics = crmClinicMapper.selectList(Wrappers.lambdaQuery(TCrmClinic.class)
                    .in(TCrmClinic::getSalespersonId, salespersonIds));
            if(CollectionUtils.isEmpty(crmClinics)){
                return new ArrayList<>();
            }
            List<String> ids = crmClinics.stream().map(TCrmClinic::getId).collect(Collectors.toList());
            clinicIds.addAll(ids);
        }
        clinicIds = clinicIds.stream().distinct().collect(Collectors.toList());
        query.setClinicIds(clinicIds);
        List<SalespersonPerformanceReportVO> list = this.baseMapper.exportSalespersonPerformanceReport(query);
        if(CollectionUtils.isEmpty(list)){
            return new ArrayList<>();
        }
        List<String> procurementIds = list.stream().map(SalespersonPerformanceReportVO::getId).collect(Collectors.toList());

        // 查询可获得积分
        List<TCrmChangePoints> crmChangePoints = crmChangePointsMapper.selectList(Wrappers.lambdaQuery(TCrmChangePoints.class)
                .in(TCrmChangePoints::getProcurementId, procurementIds)
                .eq(TCrmChangePoints::getUserType, 2)
                .eq(TCrmChangePoints::getChangeType, 1)
                .eq(TCrmChangePoints::getChangeReason, 1));
        // 查询业绩
        List<TErpProcurementCommission> erpProcurementCommissions = erpProcurementCommissionMapper.selectList(Wrappers.lambdaQuery(TErpProcurementCommission.class)
                .in(TErpProcurementCommission::getProcurementId, procurementIds)
                .eq(TErpProcurementCommission::getCommissionType, 2));
        for (SalespersonPerformanceReportVO salespersonPerformanceReportVO : list) {
            // 查询可获得积分
            List<TCrmChangePoints> changePoints = crmChangePoints.stream().filter(tCrmChangePoints -> salespersonPerformanceReportVO.getId().equals(tCrmChangePoints.getProcurementId())).collect(Collectors.toList());
            if(!CollectionUtils.isEmpty(changePoints)){
                salespersonPerformanceReportVO.setAvailablePoints(changePoints.stream().mapToInt(TCrmChangePoints::getChangeValue).sum());
            }
            // 查询业绩
            List<TErpProcurementCommission> commissions = erpProcurementCommissions.stream().filter(tErpProcurementCommission -> salespersonPerformanceReportVO.getId().equals(tErpProcurementCommission.getProcurementId())).collect(Collectors.toList());
            if(!CollectionUtils.isEmpty(commissions)){
                salespersonPerformanceReportVO.setPerformance(commissions.stream().map(TErpProcurementCommission::getMoney).reduce(BigDecimal.ZERO, BigDecimal::add));
            }
            if(Objects.nonNull(salespersonPerformanceReportVO.getPayTime())){
                String payTimeStr = new SimpleDateFormat("yyyy-MM-dd").format(DateUtils.localDateTimeToDate(salespersonPerformanceReportVO.getPayTime()));
                salespersonPerformanceReportVO.setPayTimeStr(payTimeStr);
            }
        }
        return list;
    }

    @Override
    public List<ClinicProcurementReportDetailVO> clinicProcurementReportDetail(String id) {
        return this.baseMapper.clinicProcurementReportDetail(id);
    }

    @Override
    public List<ProcurementReportDetailExport> exportProcurementReportDetail(List<String> procurementIds) {
        return this.baseMapper.exportProcurementReportDetail(procurementIds);
    }

}