package com.ruoyi.system.service.impl;

import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.basic.PageInfo;
import com.ruoyi.common.constant.OrderNumConstants;
import com.ruoyi.common.enums.BoardEnum;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.CodeGenerateUtils;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.domain.*;
import com.ruoyi.system.dto.*;
import com.ruoyi.system.export.SumGeneratorClient;
import com.ruoyi.system.export.SumGeneratorDetailClient;
import com.ruoyi.system.mapper.TOrderMealGoodsMapper;
import com.ruoyi.system.mapper.TOrderMealMapper;
import com.ruoyi.system.query.*;
import com.ruoyi.system.service.*;
import com.ruoyi.system.vo.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.stream.Collectors;

/**
 * <p>
 * 餐饮订单 服务实现类
 * </p>
 *
 * @author xiaochen
 * @since 2024-08-14
 */
@Service
public class TOrderMealServiceImpl extends ServiceImpl<TOrderMealMapper, TOrderMeal> implements TOrderMealService {

    @Autowired
    private TOrderMealGoodsService orderMealGoodsService;
    @Autowired
    private TOrderMealGoodsMapper orderMealGoodsMapper;
    @Autowired
    private TOrderRemarkService orderRemarkService;
    @Autowired
    private TBoardService boardService;
    @Autowired
    private TGoodsTypeService goodsTypeService;
    @Autowired
    private TGoodsService goodsService;

    @Override
    public void add(TOrderMealDTO dto) {
        TOrderMeal orderMeal = this.getById(dto.getId());
        if(Objects.isNull(orderMeal)){
            throw new ServiceException("该订单不存在");
        }
        if(StringUtils.isNotEmpty(dto.getRemark())){
            if(StringUtils.isNotEmpty(orderMeal.getRemark())){
                orderMeal.setRemark(orderMeal.getRemark()+dto.getRemark());
            }else {
                orderMeal.setRemark(dto.getRemark());
            }
        }
        orderMeal.setMealType(dto.getMealType());
        orderMeal.setMealPerson(dto.getMealPerson());
        orderMeal.setMealTime(dto.getMealTime());

        // 查询菜品分类
        List<TGoodsType> list1 = goodsTypeService.list();
        // 查询餐桌
        TBoard board = boardService.getById(orderMeal.getBoardId());
        if(!CollectionUtils.isEmpty(dto.getMealOrderGoodsDTOS())){
            board.setStatus(BoardEnum.DURING_MEAL.getCode());
            boardService.updateById(board);
            // 订单金额，订单编号
//            String orderNum = OrderNumConstants.MEAL+CodeGenerateUtils.generateVolumeSn();
//            dto.setOrderNum(orderNum);
            List<TOrderMealGoods> orderMealGoods = new ArrayList<>();
            // 查询商品
            List<MealOrderGoodsDTO> mealOrderGoodsDTOS = dto.getMealOrderGoodsDTOS();
            List<Long> goodsIds = mealOrderGoodsDTOS.stream().map(MealOrderGoodsDTO::getGoodsId).collect(Collectors.toList());
            List<TGoods> list = goodsService.list(Wrappers.lambdaQuery(TGoods.class)
                    .in(TGoods::getId, goodsIds));
            // 查询已存在的菜品
            List<TOrderMealGoods> list2 = orderMealGoodsService.list(Wrappers.lambdaQuery(TOrderMealGoods.class)
                    .in(TOrderMealGoods::getOrderId, dto.getId()));
            BigDecimal money = BigDecimal.ZERO;
            for (MealOrderGoodsDTO mealOrderGoodsDTO : mealOrderGoodsDTOS) {
                TOrderMealGoods tOrderMealGoods = list2.stream().filter(item1 -> item1.getGoodsId().equals(mealOrderGoodsDTO.getGoodsId())).findFirst().orElse(null);
                if(Objects.nonNull(tOrderMealGoods)){
                    tOrderMealGoods.setGoodsCount(tOrderMealGoods.getGoodsCount()+mealOrderGoodsDTO.getGoodsCount());
                    orderMealGoods.add(tOrderMealGoods);
                    money = money.add(tOrderMealGoods.getGoodsSalePrice().multiply(new BigDecimal(mealOrderGoodsDTO.getGoodsCount())));
                    continue;
                }
                for (TGoods goods : list) {
                    if(goods.getId().equals(mealOrderGoodsDTO.getGoodsId())){
                        TOrderMealGoods orderMealGood = new TOrderMealGoods();
                        orderMealGood.setGoodsName(goods.getGoodsName());
                        orderMealGood.setGoodsNum(goods.getGoodsNum());
                        orderMealGood.setGoodsPicture(goods.getGoodsPicture());
                        orderMealGood.setGoodsCount(mealOrderGoodsDTO.getGoodsCount());
                        orderMealGood.setGoodsSalePrice(goods.getSalePrice());
                        orderMealGood.setCostPrice(goods.getCostPrice());
                        orderMealGood.setTypeId(goods.getTypeId());
                        orderMealGood.setGoodsId(goods.getId());
                        orderMealGood.setTypeName(list1.stream().filter(item2 -> item2.getId().equals(goods.getTypeId())).findFirst().get().getTypeName());
                        orderMealGoods.add(orderMealGood);
                        money = money.add(goods.getSalePrice().multiply(new BigDecimal(mealOrderGoodsDTO.getGoodsCount())));
                    }
                }
            }
            // 添加菜品
            for (TOrderMealGoods orderMealGood : orderMealGoods) {
                orderMealGood.setOrderId(dto.getId());
            }
            orderMealGoodsService.saveOrUpdateBatch(orderMealGoods);
            BigDecimal orderMoney = orderMeal.getOrderMoney().add(money);
            orderMeal.setOrderMoney(orderMoney);
            this.updateById(orderMeal);
            // 添加备注
//            TOrderRemark tOrderRemark = new TOrderRemark();
//            tOrderRemark.setOrderId(dto.getId());
//            tOrderRemark.setRemark(dto.getRemark());
//            tOrderRemark.setCreateTime(LocalDateTime.now());
//            orderRemarkService.save(tOrderRemark);
        }
    }

    @Override
    public void addDish(AddDishDTO dto) {
        List<TOrderMealGoods> orderMealGoods = new ArrayList<>();
        // 查询菜品分类
        List<TGoodsType> list1 = goodsTypeService.list();
        // 查询商品
        List<Long> goodsIds = dto.getMealOrderGoodsDTOS().stream().map(MealOrderGoodsDTO::getGoodsId).collect(Collectors.toList());
        List<TOrderMealGoods> list = orderMealGoodsService.list(Wrappers.lambdaQuery(TOrderMealGoods.class)
                .in(TOrderMealGoods::getId, goodsIds));
        dto.getMealOrderGoodsDTOS().forEach(item -> {
            list.stream().filter(item1 -> item1.getId().equals(item.getGoodsId())).findFirst().ifPresent(item1 -> {
                TOrderMealGoods orderMealGood = new TOrderMealGoods();
                orderMealGood.setGoodsName(item1.getGoodsName());
                orderMealGood.setGoodsNum(item1.getGoodsNum());
                orderMealGood.setGoodsPicture(item1.getGoodsPicture());
                orderMealGood.setGoodsCount(item.getGoodsCount());
                orderMealGood.setGoodsSalePrice(item1.getGoodsSalePrice().multiply(new BigDecimal(item.getGoodsCount())));
                orderMealGood.setTypeId(item1.getTypeId());
                orderMealGood.setGoodsId(item1.getId());
                orderMealGood.setTypeName(list1.stream().filter(item2 -> item2.getId().equals(item1.getTypeId())).findFirst().get().getTypeName());
                orderMealGoods.add(orderMealGood);
            });
        });
        // 添加菜品
        orderMealGoods.forEach(item -> {
            item.setOrderId(dto.getOrderId());
        });
        orderMealGoodsService.saveBatch(orderMealGoods);
        // 添加备注
//        TOrderRemark tOrderRemark = new TOrderRemark();
//        tOrderRemark.setOrderId(dto.getOrderId());
//        tOrderRemark.setRemark(dto.getRemark());
//        tOrderRemark.setCreateTime(LocalDateTime.now());
//        orderRemarkService.save(tOrderRemark);
    }

    @Override
    public void checkout(CheckoutDTO dto) {
        TOrderMeal orderMeal = this.getById(dto.getOrderId());
        orderMeal.setPayType(dto.getPayType());
        orderMeal.setPayMoney(dto.getPayMoney());
        orderMeal.setStatus(2);
        this.updateById(orderMeal);
        TBoard board = boardService.getById(orderMeal.getBoardId());
        board.setStatus(BoardEnum.FREE.getCode());
        boardService.updateById(board);
    }

    @Override
    public PageInfo<TOrderMealVO> pageList(TOrderMealQuery query) {
        if(StringUtils.isEmpty(query.getStartTime()) && StringUtils.isEmpty(query.getEndTime())){
            if(Objects.nonNull(query.getTimeType())){
                LocalDateTime startTime = null;
                LocalDateTime endTime = null;
                switch (query.getTimeType()){
                    case 1:
                        // 今日
                        startTime = DateUtils.getDayStart(LocalDateTime.now());
                        endTime = DateUtils.getDayEnd(LocalDateTime.now());
                        break;
                    case 2:
                        // 昨日
                        startTime = DateUtils.getDayStart(LocalDateTime.now().minusDays(1));
                        endTime = DateUtils.getDayEnd(LocalDateTime.now().minusDays(1));
                        break;
                    case 3:
                        // 近7天
                        startTime = DateUtils.getDayStart(LocalDateTime.now().minusDays(7));
                        endTime = DateUtils.getDayEnd(LocalDateTime.now());
                        break;
                    case 4:
                        // 近30天
                        startTime = DateUtils.getDayStart(LocalDateTime.now().minusDays(30));
                        endTime = DateUtils.getDayEnd(LocalDateTime.now());
                        break;
                }
                query.setStartTime(DateUtils.localDateTimeToDate(startTime));
                query.setEndTime(DateUtils.localDateTimeToDate(endTime));
            }
        }
        PageInfo<TOrderMealVO> pageInfo = new PageInfo<>(query.getPageNum(),query.getPageSize());
        List<TOrderMealVO> list = this.baseMapper.pageList(query,pageInfo);
        if(CollectionUtils.isEmpty(list)){
            return new PageInfo<>();
        }
        List<Long> ids = list.stream().map(TOrderMealVO::getId).collect(Collectors.toList());
        List<TOrderMealGoods> list1 = orderMealGoodsService.list(Wrappers.lambdaQuery(TOrderMealGoods.class)
                .in(TOrderMealGoods::getOrderId, ids));
        // 查询商品信息
        for (TOrderMealVO tOrderMealVO : list) {
            List<TOrderMealGoods> collect = list1.stream().filter(e -> e.getOrderId().equals(tOrderMealVO.getId())).collect(Collectors.toList());
            tOrderMealVO.setOrderMealGoods(collect);
            if(!CollectionUtils.isEmpty(collect)){
                Map<String, List<TOrderMealGoods>> map = collect.stream().collect(Collectors.groupingBy(TOrderMealGoods::getTypeName));
                List<String> goodsList = new ArrayList<>();
                map.forEach((k,v)->{
                    goodsList.add(k+":"+v.stream().map(item->item.getGoodsName()+" "+(item.getGoodsSalePrice().multiply(new BigDecimal(item.getGoodsCount())))).collect(Collectors.joining(",")));
                });
                tOrderMealVO.setGoodsList(goodsList);
            }
        }
        pageInfo.setRecords(list);
        return pageInfo;
    }

    @Override
    public AmountSumVO amountSum(TOrderMealQuery query) {
        if(StringUtils.isEmpty(query.getStartTime()) && StringUtils.isEmpty(query.getEndTime())){
            if(Objects.nonNull(query.getTimeType())){
                LocalDateTime startTime = null;
                LocalDateTime endTime = null;
                switch (query.getTimeType()){
                    case 1:
                        // 今日
                        startTime = DateUtils.getDayStart(LocalDateTime.now());
                        endTime = DateUtils.getDayEnd(LocalDateTime.now());
                        break;
                    case 2:
                        // 昨日
                        startTime = DateUtils.getDayStart(LocalDateTime.now().minusDays(1));
                        endTime = DateUtils.getDayEnd(LocalDateTime.now().minusDays(1));
                        break;
                    case 3:
                        // 近7天
                        startTime = DateUtils.getDayStart(LocalDateTime.now().minusDays(7));
                        endTime = DateUtils.getDayEnd(LocalDateTime.now());
                        break;
                    case 4:
                        // 近30天
                        startTime = DateUtils.getDayStart(LocalDateTime.now().minusDays(30));
                        endTime = DateUtils.getDayEnd(LocalDateTime.now());
                        break;
                }
                query.setStartTime(DateUtils.localDateTimeToDate(startTime));
                query.setEndTime(DateUtils.localDateTimeToDate(endTime));
            }
        }
        return this.baseMapper.amountSum(query);
    }


    @Override
    public SalesVolumeVO salesVolume(TDataStatisticsQuery query) {
        SalesVolumeVO salesVolumeVO = this.baseMapper.salesVolume(query);
        salesVolumeVO.setSalesVolumeTotal(salesVolumeVO.getWeiXinPay().add(salesVolumeVO.getOtherPay()).add(salesVolumeVO.getCardPay())
                .add(salesVolumeVO.getMoneyPay()).add(salesVolumeVO.getAliPay()));
        // 查询成本
        List<TOrderMeal> list = this.list(Wrappers.lambdaQuery(TOrderMeal.class)
                .eq(TOrderMeal::getShopId, query.getShopId())
                .ge(TOrderMeal::getMealTime, query.getStartTime())
                .le(TOrderMeal::getMealTime, query.getEndTime())
                .eq(TOrderMeal::getStatus,2));
        List<Long> ids = list.stream().map(TOrderMeal::getId).collect(Collectors.toList());
        if(!CollectionUtils.isEmpty(ids)){
            BigDecimal costTotal = orderMealGoodsService.costTotal(ids);
            salesVolumeVO.setCostTotal(costTotal);
            salesVolumeVO.setProfitTotal(salesVolumeVO.getSalesVolumeTotal().subtract(costTotal));
        }
        return salesVolumeVO;
    }

    @Override
    public PageInfo<SalesRankingVO> salesRanking(TDataStatisticsQuery query) {
        PageInfo<SalesRankingVO> pageInfo = new PageInfo<>(query.getPageNum(),query.getPageSize());
        List<TOrderMeal> list = this.list(Wrappers.lambdaQuery(TOrderMeal.class)
                .eq(TOrderMeal::getShopId, query.getShopId())
                .between(TOrderMeal::getMealTime, query.getStartTime(), query.getEndTime()));
        List<Long> ids = list.stream().map(TOrderMeal::getId).collect(Collectors.toList());
        if(CollectionUtils.isEmpty(ids)){
            return new PageInfo<>();
        }
        List<SalesRankingVO> salesRankingVOS = orderMealGoodsMapper.salesRanking(ids, pageInfo);
        pageInfo.setRecords(salesRankingVOS);
        return pageInfo;
    }

    @Override
    public List<TOrderMealVO> exportOrderMeal(TOrderMealQuery query) {
        if(Objects.nonNull(query.getTimeType())){
            LocalDateTime startTime = null;
            LocalDateTime endTime = null;
            switch (query.getTimeType()){
                case 1:
                    // 今日
                    startTime = DateUtils.getDayStart(LocalDateTime.now());
                    endTime = DateUtils.getDayEnd(LocalDateTime.now());
                    break;
                case 2:
                    // 昨日
                    startTime = DateUtils.getDayStart(LocalDateTime.now().minusDays(1));
                    endTime = DateUtils.getDayEnd(LocalDateTime.now().minusDays(1));
                    break;
                case 3:
                    // 近7天
                    startTime = DateUtils.getDayStart(LocalDateTime.now().minusDays(7));
                    endTime = DateUtils.getDayEnd(LocalDateTime.now());
                    break;
                case 4:
                    // 近30天
                    startTime = DateUtils.getDayStart(LocalDateTime.now().minusDays(30));
                    endTime = DateUtils.getDayEnd(LocalDateTime.now());
                    break;
            }
            query.setStartTime(DateUtils.localDateTimeToDate(startTime));
            query.setEndTime(DateUtils.localDateTimeToDate(endTime));
        }
        List<TOrderMealVO> list = this.baseMapper.exportOrderMeal(query);
        List<Long> ids = list.stream().map(TOrderMealVO::getId).collect(Collectors.toList());
        if(!CollectionUtils.isEmpty(ids)){
            List<TOrderMealGoods> list1 = orderMealGoodsService.list(Wrappers.lambdaQuery(TOrderMealGoods.class)
                    .in(TOrderMealGoods::getOrderId,ids));
            // 查询商品信息
            for (TOrderMealVO tOrderMealVO : list) {
                List<TOrderMealGoods> collect = list1.stream().filter(e -> e.getOrderId().equals(tOrderMealVO.getId())).collect(Collectors.toList());
                tOrderMealVO.setOrderMealGoods(collect);
                Map<String, List<TOrderMealGoods>> map = collect.stream().collect(Collectors.groupingBy(TOrderMealGoods::getTypeName));
                List<String> goodsList = new ArrayList<>();
                map.forEach((k,v)->{
                    goodsList.add(k+":"+v.stream().map(item->item.getGoodsName()+" "+(item.getGoodsSalePrice().multiply(new BigDecimal(item.getGoodsCount())))).collect(Collectors.joining(",")));
                });
                tOrderMealVO.setGoodsList(goodsList);
            }
        }
        return list;
    }

    @Override
    public List<OrderTrendsVO> orderingTrends(TDataStatisticsQuery query) {
        List<OrderTrendsVO> orderTrendsVOS = this.baseMapper.orderingTrends(query);
        LocalDate localDate = DateUtils.stringToLocalDateTime(query.getEndTime()).toLocalDate();
        for (int i = 0; i < 7; i++) {
            if(i == 0){
                LocalDate finalLocalDate = localDate;
                OrderTrendsVO orderTrendsVO = orderTrendsVOS.stream().filter(e -> finalLocalDate.compareTo(DateUtils.stringToLocalDate(e.getDayTime())) == 0).findFirst().orElse(null);
                if(Objects.isNull(orderTrendsVO)){
                    orderTrendsVO = new OrderTrendsVO();
                    orderTrendsVO.setDayTime(DateUtils.localDateToString(localDate));
                    orderTrendsVO.setOrderCount(0);
                    orderTrendsVOS.add(orderTrendsVO);
                }
            }else {
                localDate = localDate.minusDays(1);
                LocalDate finalLocalDate1 = localDate;
                OrderTrendsVO orderTrendsVO = orderTrendsVOS.stream().filter(e -> finalLocalDate1.compareTo(DateUtils.stringToLocalDate(e.getDayTime())) == 0).findFirst().orElse(null);
                if(Objects.isNull(orderTrendsVO)){
                    orderTrendsVO = new OrderTrendsVO();
                    orderTrendsVO.setDayTime(DateUtils.localDateToString(finalLocalDate1));
                    orderTrendsVO.setOrderCount(0);
                    orderTrendsVOS.add(orderTrendsVO);
                }
            }
        }
        return orderTrendsVOS.stream().sorted(Comparator.comparing(OrderTrendsVO::getDayTime)).collect(Collectors.toList());
    }

    @Override
    public List<PersonnelStatisticsVO> personnelStatistics(TDataStatisticsQuery query) {
        return this.baseMapper.personnelStatistics(query);
    }

    @Override
    public PageInfo<TOrderMealVO> pageListGenerator(TDataGeneratorMealQuery query) {
        PageInfo<TOrderMealVO> pageInfo = new PageInfo<>(query.getPageNum(),query.getPageSize());
        List<TOrderMealVO> list = this.baseMapper.pageListGenerator(query,pageInfo);
        // 查询商品信息
        for (TOrderMealVO tOrderMealVO : list) {
            List<TOrderMealGoods> list1 = orderMealGoodsService.list(Wrappers.lambdaQuery(TOrderMealGoods.class)
                    .eq(TOrderMealGoods::getOrderId, tOrderMealVO.getId()));
            tOrderMealVO.setOrderMealGoods(list1);
            Map<String, List<TOrderMealGoods>> map = list1.stream().collect(Collectors.groupingBy(TOrderMealGoods::getTypeName));
            List<String> goodsList = new ArrayList<>();
            map.forEach((k,v)->{
                goodsList.add(k+":"+v.stream().map(item->item.getGoodsName()+" "+(item.getGoodsSalePrice().multiply(new BigDecimal(item.getGoodsCount())))).collect(Collectors.joining(",")));
            });
            tOrderMealVO.setGoodsList(goodsList);
        }
        pageInfo.setRecords(list);
        return pageInfo;
    }

    @Override
    public Map<String, Double> getDataGeneratorMealDetail(TDataGeneratorMealQuery query) {
        return this.baseMapper.getDataGeneratorMealDetail(query);
    }

    @Override
    public List<TOrderMealVO> mealGeneratorExport(TDataGeneratorMealQuery query) {
        List<TOrderMealVO> list = this.baseMapper.mealGeneratorExport(query);
        List<Long> ids = list.stream().map(TOrderMealVO::getId).collect(Collectors.toList());
        List<TOrderMealGoods> list1 = orderMealGoodsService.list(Wrappers.lambdaQuery(TOrderMealGoods.class)
                .in(TOrderMealGoods::getOrderId,ids));
        // 查询商品信息
        for (TOrderMealVO tOrderMealVO : list) {
            List<TOrderMealGoods> collect = list1.stream().filter(e -> e.getOrderId().equals(tOrderMealVO.getId())).collect(Collectors.toList());
            tOrderMealVO.setOrderMealGoods(collect);
            Map<String, List<TOrderMealGoods>> map = collect.stream().collect(Collectors.groupingBy(TOrderMealGoods::getTypeName));
            List<String> goodsList = new ArrayList<>();
            map.forEach((k,v)->{
                goodsList.add(k+":"+v.stream().map(item->item.getGoodsName()+" "+(item.getGoodsSalePrice().multiply(new BigDecimal(item.getGoodsCount())))).collect(Collectors.joining(",")));
            });
            tOrderMealVO.setGoodsList(goodsList);
        }
        return list;
    }

    @Override
    public void startMeal(TOrderMeal dto) {
        // 查询餐桌
        TBoard board = boardService.getById(dto.getBoardId());
        // 开台
        board.setStatus(BoardEnum.WAITING_ORDER.getCode());
        boardService.updateById(board);
        dto.setMealTime(dto.getMealTime());
        dto.setOrderNum(OrderNumConstants.MEAL + CodeGenerateUtils.generateVolumeSn());
        this.save(dto);
    }

    @Override
    public List<TDataGeneratorVO> mealGeneratorListExport(TDataGeneratorQuery query) {
        List<TDataGeneratorVO> list = this.baseMapper.mealGeneratorListExport(query);
        List<Long> ids = list.stream().map(TDataGeneratorVO::getId).collect(Collectors.toList());
        if(CollectionUtils.isEmpty(ids)){
            return new ArrayList<>();
        }
        List<TOrderMeal> orderMeals = this.list(Wrappers.lambdaQuery(TOrderMeal.class)
                .in(TOrderMeal::getGeneratorId, ids));
        List<Long> mealIds = orderMeals.stream().map(TOrderMeal::getId).collect(Collectors.toList());
        if(!CollectionUtils.isEmpty(mealIds)){
            List<TOrderMealGoods> mealGoods = orderMealGoodsService.list(Wrappers.lambdaQuery(TOrderMealGoods.class)
                    .in(TOrderMealGoods::getOrderId, mealIds));
            for (TDataGeneratorVO tDataGeneratorVO : list) {
                List<Long> collect = orderMeals.stream().filter(e -> e.getGeneratorId().equals(tDataGeneratorVO.getId())).map(TOrderMeal::getId).collect(Collectors.toList());
                BigDecimal money = mealGoods.stream().filter(e -> collect.contains(e.getOrderId()))
                        .reduce(BigDecimal.ZERO, (x, y) -> x.add(y.getGoodsSalePrice().multiply(new BigDecimal(y.getGoodsCount()))), BigDecimal::add);
                tDataGeneratorVO.setTotalRevenue(money);
            }
        }
        return list;
    }

    @Override
    public ProfitDetailsVO profitDetails(ProfitDetailsQuery query) {

        ProfitDetailsVO profitDetailsVO = new ProfitDetailsVO();
        // 查询商品盈利明细
        PageInfo<GoodsProfitVO> pageInfo = new PageInfo<>(query.getPageNum(),query.getPageSize());
        List<GoodsProfitVO> list = this.baseMapper.profitDetails(query,pageInfo);
        pageInfo.setRecords(list);
        profitDetailsVO.setGoodsProfitVOS(pageInfo);

        // 统计商品金额
        Map<String,Double> map = this.baseMapper.profitDetailsStatistics(query);
        profitDetailsVO.setTotalProfits(new BigDecimal(map.get("totalProfits").toString()));
        profitDetailsVO.setTotalCosts(new BigDecimal(map.get("totalCosts").toString()));
        profitDetailsVO.setTotalSales(new BigDecimal(map.get("totalSales").toString()));
        return profitDetailsVO;
    }

    @Override
    public List<GoodsProfitVO> profitDetailsExport(ProfitDetailsQuery query) {
        return this.baseMapper.profitDetailsExport(query);
    }

    @Override
    public void deleteByShopId(Long shopId) {
        this.baseMapper.deleteByShopId(shopId);
    }

    @Override
    public Map<String, Double> getDataGeneratorMealDetailOrderMoney(TDataGeneratorMealQuery query) {
        return this.baseMapper.getDataGeneratorMealDetailOrderMoney(query);
    }

    @Override
    public SumGeneratorClient sumExport(ProfitDetailsQuery query) {
        List<SumGeneratorDetailClient> sumGeneratorDetailClient = this.baseMapper.sumExport(query);

        for (SumGeneratorDetailClient generatorDetailClient : sumGeneratorDetailClient) {
            generatorDetailClient.setSingleAmount(generatorDetailClient.getActualAmount().divide(new BigDecimal(generatorDetailClient.getOrderCount()),2,BigDecimal.ROUND_DOWN));
            generatorDetailClient.setPerAmount(generatorDetailClient.getActualAmount().divide(new BigDecimal(generatorDetailClient.getPerCount()),2,BigDecimal.ROUND_DOWN));
        }

        SumGeneratorClient sumGeneratorClient = new SumGeneratorClient();
        if(!CollectionUtils.isEmpty(sumGeneratorDetailClient)){
            sumGeneratorClient.setActualAmountSum(sumGeneratorDetailClient.stream().map(SumGeneratorDetailClient::getActualAmount).reduce(BigDecimal::add).get());
            sumGeneratorClient.setOrderCountSum(sumGeneratorDetailClient.stream().map(SumGeneratorDetailClient::getOrderCount).reduce(Integer::sum).get());
            sumGeneratorClient.setSingleAmountSum(sumGeneratorDetailClient.stream().map(SumGeneratorDetailClient::getSingleAmount).reduce(BigDecimal::add).get());
            sumGeneratorClient.setPerCountSum(sumGeneratorDetailClient.stream().map(SumGeneratorDetailClient::getPerCount).reduce(Integer::sum).get());
            sumGeneratorClient.setPerAmountSum(sumGeneratorDetailClient.stream().map(SumGeneratorDetailClient::getPerAmount).reduce(BigDecimal::add).get());

            sumGeneratorClient.setAllMoney(sumGeneratorDetailClient.stream().map(SumGeneratorDetailClient::getActualAmount).reduce(BigDecimal::add).get());
            sumGeneratorClient.setSingleAvgAmount(sumGeneratorClient.getAllMoney().divide(new BigDecimal(sumGeneratorClient.getPerCountSum()),2,BigDecimal.ROUND_DOWN));
            sumGeneratorClient.setPerCapitaAmount(sumGeneratorClient.getAllMoney().divide(new BigDecimal(sumGeneratorClient.getOrderCountSum()),2,BigDecimal.ROUND_DOWN));
        }
        sumGeneratorClient.setOrderStatistics(sumGeneratorDetailClient);


        return sumGeneratorClient;
    }

}