package com.ruoyi.system.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
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.Constants;
import com.ruoyi.common.constant.OrderNumConstants;
import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.CodeGenerateUtils;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.system.domain.*;
import com.ruoyi.system.dto.OrderMealGeneratorCountDTO;
import com.ruoyi.system.dto.OrderMealGeneratorDTO;
import com.ruoyi.system.dto.OrderSaleGeneratorDTO;
import com.ruoyi.system.mapper.TDataGeneratorMapper;
import com.ruoyi.system.query.*;
import com.ruoyi.system.service.*;
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 java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.util.*;
import java.util.stream.Collectors;

/**
 * <p>
 * 营业数据生成 服务实现类
 * </p>
 *
 * @author xiaochen
 * @since 2024-08-27
 */
@Service
public class TDataGeneratorServiceImpl extends ServiceImpl<TDataGeneratorMapper, TDataGenerator> implements TDataGeneratorService {

    @Autowired
    private TBoardService boardService;
    @Autowired
    private TFoundationConfigService foundationConfigService;
    @Autowired
    private TFoundationPersonService foundationPersonService;
    @Autowired
    private TGoodsService goodsService;
    @Autowired
    private TOrderMealService orderMealService;
    @Autowired
    private TOrderMealGoodsService orderMealGoodsService;
    @Autowired
    private TOrderSaleService orderSaleService;
    @Autowired
    private TOrderSaleGoodsService orderSaleGoodsService;
    @Autowired
    private TOrderStockService orderStockService;
    @Autowired
    private TOrderStockGoodsService orderStockGoodsService;
    @Autowired
    private TStockDataSetService stockDataSetService;
    @Autowired
    private TGoodsTypeService goodsTypeService;
    @Autowired
    private TShopService shopService;
    @Autowired
    private RedisCache redisCache;

    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
    @Override
    public void mealDataGenerator(OrderMealGeneratorDTO dto) {
        // 存储数据生成数据
        TDataGenerator dataGenerator = new TDataGenerator();
        dataGenerator.setUserId(dto.getUserId());
        dataGenerator.setUserName(dto.getNickName());
        dataGenerator.setShopId(dto.getShopId());
        dataGenerator.setStartTime(dto.getStartTime());
        dataGenerator.setEndTime(dto.getEndTime());
        dataGenerator.setMinMoney(dto.getMinMoney());
        dataGenerator.setMaxMoney(dto.getMaxMoney());
        dataGenerator.setStatus(2);
        dataGenerator.setOrderType(1);
        dataGenerator.setWeiXinPay(dto.getWeiXinProportion());
        dataGenerator.setAliPay(dto.getAliProportion());
        dataGenerator.setCardPay(dto.getCardProportion());
        dataGenerator.setMoneyPay(dto.getMoneyProportion());
        dataGenerator.setOtherPay(dto.getOtherProportion());
        this.save(dataGenerator);
        long start = System.currentTimeMillis();
        TShop shop = shopService.getById(dto.getShopId());
        List<TFoundationConfigVO> foundationConfigs = foundationConfigService.getList(shop.getMealType());
        if(CollectionUtils.isEmpty(foundationConfigs)){
            throw new ServiceException("请先添加中餐或火锅用餐标准");
        }
        // 查询所有桌子
        List<TBoard> boards = boardService.list(Wrappers.lambdaQuery(TBoard.class)
                .eq(TBoard::getShopId,dto.getShopId()));
        if(CollectionUtils.isEmpty(boards)){
            throw new ServiceException("请先添加该店铺桌台信息");
        }
        // 查询所有菜品
        List<TGoods> goods = goodsService.list(Wrappers.lambdaQuery(TGoods.class)
                .eq(TGoods::getShopId,dto.getShopId()));
        if(CollectionUtils.isEmpty(goods)){
            throw new ServiceException("请先添加该店铺菜品信息");
        }
        // 循环待生成订单列表，添加到集合中，批量插入
        List<OrderMealGeneratorCountDTO> orderMealGeneratorCountDTOS = dto.getOrderMealGeneratorCountDTOS();
        List<TOrderMeal> orderMeals = new ArrayList<>();
        for (OrderMealGeneratorCountDTO orderMealGeneratorCountDTO : orderMealGeneratorCountDTOS) {
            TBoard board = boards.stream().filter(e -> e.getId().equals(orderMealGeneratorCountDTO.getBoardId())).findFirst().orElse(null);
            if(Objects.isNull(board)){
                throw new ServiceException("该桌台信息不存在");
            }
            Integer orderCount = orderMealGeneratorCountDTO.getOrderCount();
            if(orderCount == 0){
                continue;
            }
            // 查询当前桌的用餐人数
            for (int i = 1; i <= orderCount; i++) {
                int random = getRandom(board.getMinPerson(), board.getMaxPerson());
                TOrderMeal orderMeal = new TOrderMeal();
                orderMeal.setBoardId(board.getId());
                orderMeal.setMealType(1);
                orderMeal.setMealPerson(random);
                orderMeal.setMealTime(orderMealGeneratorCountDTO.getTime());
                String num = OrderNumConstants.MEAL + CodeGenerateUtils.generateVolumeSn();
//                long count1 = orderMealService.count(Wrappers.lambdaQuery(TOrderMeal.class)
//                        .eq(TOrderMeal::getOrderNum, num));
//                if(count1>0){
//                    num = CodeGenerateUtils.generateVolumeSn();
//                }
                orderMeal.setOrderNum(num);
                orderMeal.setStatus(2);
                List<TOrderMealGoods> orderMealGoods = new ArrayList<>();
                // 获取当前桌的菜品
                List<TFoundationConfigVO> foundationConfigVOS = foundationConfigs.stream().filter(e -> e.getMealCount().equals(random)).collect(Collectors.toList());
                if(CollectionUtils.isEmpty(foundationConfigVOS)){
                    throw new ServiceException("桌台"+random+"人餐，人数配置不存在");
                }
                // 每种菜品分类需要几个菜的生成
                foundationConfigVOS.forEach(e -> {
                    int random1 = getRandom(e.getMinCount(), e.getMaxCount());
                    List<TGoods> typeGoodsList = goods.stream().filter(m -> e.getTypeId().equals(m.getTypeId())).collect(Collectors.toList());
                    List<TGoods> typeGoods = randomSelection(typeGoodsList, random1);
                    if(typeGoods.size() != random1){
                        List<TGoods> goods1 = randomSelection(typeGoodsList, random1 - typeGoods.size());
                        typeGoods.addAll(goods1);
                    }
                    for (TGoods typeGood : typeGoods) {
                        int count = 0;
                        for (TOrderMealGoods good : orderMealGoods) {
                            if (good.getGoodsNum().equals(typeGood.getGoodsNum())) {
                                count+=1;
                                good.setGoodsCount(good.getGoodsCount() + 1);
//                                good.setGoodsSalePrice(good.getGoodsSalePrice().add(typeGood.getSalePrice()));
                                break; // 找到后直接跳出循环
                            }
                        }
                        if (count==0) {
                            TOrderMealGoods tOrderMealGoods = new TOrderMealGoods();
                            tOrderMealGoods.setGoodsNum(typeGood.getGoodsNum());
                            tOrderMealGoods.setGoodsName(typeGood.getGoodsName());
                            tOrderMealGoods.setGoodsPicture(typeGood.getGoodsPicture());
                            tOrderMealGoods.setGoodsSalePrice(typeGood.getSalePrice());
                            tOrderMealGoods.setGoodsCount(1);
                            tOrderMealGoods.setTypeId(typeGood.getTypeId());
                            tOrderMealGoods.setGoodsId(typeGood.getId());
                            orderMealGoods.add(tOrderMealGoods);
                        }
                    }
                });
                if(!CollectionUtils.isEmpty(orderMealGoods)){
                    orderMeal.setMealOrderGoods(orderMealGoods);
                    orderMeal.setOrderMoney(orderMealGoods.stream().map(good->good.getGoodsSalePrice().multiply(new BigDecimal(good.getGoodsCount()))).reduce(BigDecimal::add).get());
                    orderMeal.setPayMoney(orderMealGoods.stream().map(good->good.getGoodsSalePrice().multiply(new BigDecimal(good.getGoodsCount()))).reduce(BigDecimal::add).get());
                    orderMeals.add(orderMeal);
                }
            }
        }
        BigDecimal sumMoney = orderMeals.stream().map(TOrderMeal::getPayMoney).reduce(BigDecimal::add).get();
        if(sumMoney.compareTo(dto.getMinMoney()) >= 0 && sumMoney.compareTo(dto.getMaxMoney()) <= 0){
            int weiXin = getRandomPayType(orderMeals.size(), dto.getWeiXinProportion());
            int ali = getRandomPayType(orderMeals.size(), dto.getAliProportion());
            int card = getRandomPayType(orderMeals.size(), dto.getCardProportion());
            int money = getRandomPayType(orderMeals.size(), dto.getMoneyProportion());
            int other = getRandomPayType(orderMeals.size(), dto.getOtherProportion());
            switch (orderMeals.size()-(weiXin+ali+card+money+other)){
                case 1:
                    weiXin += 1;
                    break;
                case 2:
                    weiXin += 1;
                    ali += 1;
                    break;
                case 3:
                    weiXin += 1;
                    ali += 1;
                    card += 1;
                    break;
                case 4:
                    weiXin += 1;
                    ali += 1;
                    card += 1;
                    money += 1;
                    break;
                case 5:
                    weiXin += 1;
                    ali += 1;
                    card += 1;
                    money += 1;
                    other += 1;
                    break;
            }
            List<TOrderMeal> weiXinOrderMeals = orderMeals.subList(0, weiXin);
            List<TOrderMeal> aliOrderMeals = orderMeals.subList(weiXin, weiXin+ali);
            List<TOrderMeal> cardOrderMeals = orderMeals.subList(weiXin+ali, weiXin+ali+card);
            List<TOrderMeal> moneyOrderMeals = orderMeals.subList(weiXin+ali+card, weiXin+ali+card+money);
            List<TOrderMeal> otherOrderMeals = orderMeals.subList(weiXin+ali+card+money, weiXin+ali+card+money+other);
            weiXinOrderMeals.forEach(e->e.setPayType(3));
            aliOrderMeals.forEach(e->e.setPayType(2));
            cardOrderMeals.forEach(e->e.setPayType(4));
            moneyOrderMeals.forEach(e->e.setPayType(1));
            otherOrderMeals.forEach(e->e.setPayType(5));
            List<TOrderMeal> allOrderMeals = new ArrayList<>();
            allOrderMeals.addAll(weiXinOrderMeals);
            allOrderMeals.addAll(aliOrderMeals);
            allOrderMeals.addAll(cardOrderMeals);
            allOrderMeals.addAll(moneyOrderMeals);
            allOrderMeals.addAll(otherOrderMeals);
            allOrderMeals.forEach(e->{
                e.setIsCover(0);
                e.setShopId(dataGenerator.getShopId());
                e.setGeneratorId(dataGenerator.getId());
            });

            // 判断是否进行了终止操作
            if(redisCache.hasKey(OrderNumConstants.MEAL+"_"+dto.getShopId())){
                redisCache.deleteObject(OrderNumConstants.MEAL+"_"+dto.getShopId());
                return;
            }

            orderMealService.saveBatch(allOrderMeals);

            for (TOrderMeal orderMeal : allOrderMeals) {
                orderMeal.getMealOrderGoods().forEach(e->e.setOrderId(orderMeal.getId()));
            }
            List<TGoodsType> list = goodsTypeService.list();
            List<TOrderMealGoods> collect = allOrderMeals.stream().map(TOrderMeal::getMealOrderGoods).flatMap(Collection::stream).collect(Collectors.toList());
            collect.forEach(e->e.setTypeName(list.stream().filter(m->m.getId().equals(e.getTypeId())).findFirst().get().getTypeName()));
            orderMealGoodsService.saveBatch(collect);
            // 存储
            long end = System.currentTimeMillis() - start;
            System.err.println("相差时间========="+end);
        }else {
            // 生成失败 进行重试
            String key = dto.getShopId()+"_fail";
            if(redisCache.hasKey(key)){
                Object cacheObject = redisCache.getCacheObject(key);
                int i = Integer.parseInt(cacheObject.toString());
                if(i == 10){
                    this.removeById(dataGenerator);
                    redisCache.deleteObject(key);
                    throw new ServiceException("多次匹配数据不成功，请调整营业额范围");
                }else {
                    this.removeById(dataGenerator);
                    redisCache.setCacheObject(key,i+1);
                    this.mealDataGenerator(dto);
                }
            }else {
                this.removeById(dataGenerator);
                redisCache.setCacheObject(key,1);
                this.mealDataGenerator(dto);
            }
        }

    }

    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
    @Override
    public void saleDataGenerator(OrderSaleGeneratorDTO dto) {
        // 查询上一次的数据生成时间
        TDataGenerator lastDataGenerator = this.getOne(new LambdaQueryWrapper<TDataGenerator>().eq(TDataGenerator::getShopId, dto.getShopId()).orderByDesc(TDataGenerator::getCreateTime).last("limit 1"));
        if(Objects.nonNull(lastDataGenerator) && lastDataGenerator.getEndTime().isAfter(dto.getStartTime())){
            throw new ServiceException("数据生成时间不能小于上次生成时间");
        }
        // 查询上次生成最后一次的时间  后续涛哥不用这个类，可以改成TOrderStock的最后一条数据
        TStockDataSet stockDataSet = stockDataSetService.getOne(new LambdaQueryWrapper<TStockDataSet>()
                .eq(TStockDataSet::getShopId, dto.getShopId())
                .orderByDesc(TStockDataSet::getStockDate)
                .last("limit 1"));
        // 存储数据生成数据
        TDataGenerator dataGenerator = new TDataGenerator();
        dataGenerator.setUserId(dto.getUserId());
        dataGenerator.setUserName(dto.getNickName());
        dataGenerator.setShopId(dataGenerator.getShopId());
        dataGenerator.setStartTime(dto.getStartTime());
        dataGenerator.setEndTime(dto.getEndTime());
        dataGenerator.setStatus(2);
        dataGenerator.setShopId(dto.getShopId());
        dataGenerator.setOrderType(2);
        this.save(dataGenerator);

        // 存储进货数据设置
        List<TStockDataSet> stockDataSets = dto.getStockDataSets();
        stockDataSets.forEach(e->e.setGeneratorId(dataGenerator.getId()));
        stockDataSetService.saveBatch(stockDataSets);

        // 添加销售订单数
        List<TOrderSale> orderSales = dto.getOrderSales();
        orderSales.forEach(e->{
            e.setGeneratorId(dataGenerator.getId());
            e.setOrderNum(OrderNumConstants.SALE + CodeGenerateUtils.generateVolumeSn());
            e.setIsCover(0);
            e.setStatus(2);
        });
        List<TOrderSaleGoods> orderSaleGoods = orderSales.stream().map(TOrderSale::getOrderSaleGoods).flatMap(Collection::stream).collect(Collectors.toList());
        TOrderStock orderStockLast = orderStockService.getOne(Wrappers.lambdaQuery(TOrderStock.class)
                .eq(TOrderStock::getShopId, dto.getShopId())
                .orderByDesc(TOrderStock::getStockTime)
                .last("LIMIT 1"));
        // 生成进货数据
        List<TOrderStock> stockList = new ArrayList<>();
        stockDataSets.stream().sorted(Comparator.comparing(TStockDataSet::getStockDate));
        for (int i = 0; i < stockDataSets.size(); i++) {
            TStockDataSet start = stockDataSets.get(i);
            LocalDate startTime = start.getStockDate();
            if(i==stockDataSets.size()-1){
                // 最后一次
                LocalDate endTime = LocalDate.now();
                List<TOrderSale> collect = orderSales.stream().filter(e -> e.getOrderTime().compareTo(startTime) >= 0 && e.getOrderTime().compareTo(endTime) <= 0).collect(Collectors.toList());
                List<TOrderSaleGoods> orderSaleGoodsList = new ArrayList<>();
                collect.forEach(e->orderSaleGoodsList.addAll(e.getOrderSaleGoods()));
                // 根据商品新生成一条数据
                TOrderStock orderStock = new TOrderStock();
                orderStock.setStockNum(OrderNumConstants.STOCK + CodeGenerateUtils.generateVolumeSn());
                orderStock.setStockTime(startTime);
                orderStock.setIsCover(0);
                orderStock.setGeneratorId(dataGenerator.getId());
                orderStock.setShopId(dto.getShopId());

                Map<String, List<TOrderSaleGoods>> goodsList = orderSaleGoodsList.stream().collect(Collectors.groupingBy(TOrderSaleGoods::getGoodsName));
                List<TOrderStockGoods> orderStockGoods = new ArrayList<>();
                goodsList.forEach((k,v)->{
                    TOrderStockGoods tOrderStockGoods = new TOrderStockGoods();
                    tOrderStockGoods.setGoodsName(k);
                    tOrderStockGoods.setGoodsNum(v.get(0).getGoodsNum());
                    tOrderStockGoods.setCostPrice(v.get(0).getGoodsCostPrice());
                    tOrderStockGoods.setSalePrice(v.get(0).getGoodsSalePrice());
//                    tOrderStockGoods.setThisCostPrice(v.get(0).getThisSalePrice());
                    tOrderStockGoods.setGoodsPicture(v.get(0).getGoodsPicture());
                    tOrderStockGoods.setGoodsId(v.get(0).getGoodsId());
                    int sum = v.stream().mapToInt(TOrderSaleGoods::getGoodsCount).sum();
                    BigDecimal rate = new BigDecimal(100).subtract(start.getLossRate()).divide(new BigDecimal(100)).setScale(2, BigDecimal.ROUND_HALF_UP);
                    BigDecimal bigDecimal = new BigDecimal(sum).divide(rate,2,BigDecimal.ROUND_HALF_UP).setScale(0, BigDecimal.ROUND_HALF_UP);
                    tOrderStockGoods.setStockCount(Integer.parseInt(bigDecimal.toString().split("\\.")[0]));
                    orderStockGoods.add(tOrderStockGoods);
                });
                orderStock.setOrderStockGoods(orderStockGoods);
                stockList.add(orderStock);

            }else if(i==0 && Objects.nonNull(stockDataSet)){
                if(Objects.nonNull(orderStockLast)){
                    // 查询商品进价
                    List<TOrderStockGoods> orderStockGoodsList = orderStockGoodsService.list(Wrappers.lambdaQuery(TOrderStockGoods.class).eq(TOrderStockGoods::getOrderId, orderStockLast.getId()));
                    // 第一次 第一次的进货时间为上一次的结束时间  开始时间为上一次的开始时间
                    LocalDate startTime1 = stockDataSet.getStockDate();
                    List<TOrderSale> collect = orderSales.stream().filter(e -> e.getOrderTime().compareTo(startTime) < 0).collect(Collectors.toList());
                    List<TOrderSaleGoods> orderSaleGoodsList = new ArrayList<>();
                    collect.forEach(e->orderSaleGoodsList.addAll(e.getOrderSaleGoods()));
                    // 查询上一次开始之后的订单数据
                    List<TOrderSale> orderSales1 = orderSaleService.list(new LambdaQueryWrapper<TOrderSale>().gt(TOrderSale::getOrderTime, startTime1));
                    List<Long> saleIds1 = orderSales1.stream().map(TOrderSale::getId).collect(Collectors.toList());
                    List<TOrderSaleGoods> list;
                    if(CollectionUtils.isEmpty(saleIds1)){
                        // 查询上一次的商品
                        list = orderSaleGoodsService.list(new LambdaQueryWrapper<TOrderSaleGoods>().in(TOrderSaleGoods::getOrderId, saleIds1));
                        // 结合上次最后一次的数据
                        list.addAll(orderSaleGoodsList);
                    }else {
                        list = orderSaleGoodsList;
                    }
                    // 删除上一次的数据生成   新生成一条数据
                    TOrderStock orderStock = new TOrderStock();
                    orderStock.setStockNum(OrderNumConstants.STOCK + CodeGenerateUtils.generateVolumeSn());
                    orderStock.setStockTime(orderStockLast.getStockTime());
                    orderStock.setIsCover(0);
                    orderStock.setGeneratorId(orderStockLast.getGeneratorId());
                    orderStock.setShopId(dto.getShopId());

                    Map<String, List<TOrderSaleGoods>> goodsList = list.stream().collect(Collectors.groupingBy(TOrderSaleGoods::getGoodsName));
                    List<TOrderStockGoods> orderStockGoods = new ArrayList<>();
                    goodsList.forEach((k,v)->{
                        TOrderStockGoods tOrderStockGoods = new TOrderStockGoods();
                        tOrderStockGoods.setGoodsName(k);
                        tOrderStockGoods.setGoodsNum(v.get(0).getGoodsNum());
                        tOrderStockGoods.setCostPrice(v.get(0).getGoodsCostPrice());
                        tOrderStockGoods.setSalePrice(v.get(0).getGoodsSalePrice());
                        TOrderStockGoods orderStockGoods1 = orderStockGoodsList.stream().filter(e -> e.getGoodsName().equals(k)).findFirst().orElse(null);
                        if(Objects.nonNull(orderStockGoods1)){
                            tOrderStockGoods.setThisCostPrice(orderStockGoods1.getThisCostPrice());
                        }
                        tOrderStockGoods.setGoodsPicture(v.get(0).getGoodsPicture());
                        tOrderStockGoods.setGoodsId(v.get(0).getGoodsId());
                        int sum = v.stream().mapToInt(TOrderSaleGoods::getGoodsCount).sum();
                        BigDecimal rate = new BigDecimal(100).subtract(start.getLossRate()).divide(new BigDecimal(100)).setScale(2, BigDecimal.ROUND_HALF_UP);
                        BigDecimal bigDecimal = new BigDecimal(sum).divide(rate,2,BigDecimal.ROUND_HALF_UP).setScale(0, BigDecimal.ROUND_HALF_UP);
                        tOrderStockGoods.setStockCount(Integer.parseInt(bigDecimal.toString().split("\\.")[0]));
                        orderStockGoods.add(tOrderStockGoods);
                    });
                    orderStock.setOrderStockGoods(orderStockGoods);
                    stockList.add(orderStock);
                }

                // 处理第一次到下一次的数据
                TStockDataSet end = stockDataSets.get(i + 1);
                LocalDate endTime = end.getStockDate();
                List<TOrderSale> collect1 = orderSales.stream().filter(e -> e.getOrderTime().compareTo(startTime) >= 0 && e.getOrderTime().compareTo(endTime) < 0).collect(Collectors.toList());
                List<TOrderSaleGoods> orderSaleGoodsList2 = new ArrayList<>();
                collect1.forEach(e->orderSaleGoodsList2.addAll(e.getOrderSaleGoods()));
                // 根据商品新生成一条数据
                TOrderStock orderStock1 = new TOrderStock();
                orderStock1.setStockNum(OrderNumConstants.STOCK + CodeGenerateUtils.generateVolumeSn());
                orderStock1.setStockTime(startTime);
                orderStock1.setIsCover(0);
                orderStock1.setGeneratorId(dataGenerator.getId());
                orderStock1.setShopId(dto.getShopId());

                Map<String, List<TOrderSaleGoods>> goodsList1 = orderSaleGoodsList2.stream().collect(Collectors.groupingBy(TOrderSaleGoods::getGoodsName));
                List<TOrderStockGoods> orderStockGoods1 = new ArrayList<>();
                goodsList1.forEach((k,v)->{
                    TOrderStockGoods tOrderStockGoods = new TOrderStockGoods();
                    tOrderStockGoods.setGoodsName(k);
                    tOrderStockGoods.setGoodsNum(v.get(0).getGoodsNum());
                    tOrderStockGoods.setCostPrice(v.get(0).getGoodsCostPrice());
                    tOrderStockGoods.setSalePrice(v.get(0).getGoodsSalePrice());
//                    tOrderStockGoods.setThisCostPrice(v.get(0).getThisSalePrice());
                    tOrderStockGoods.setGoodsPicture(v.get(0).getGoodsPicture());
                    tOrderStockGoods.setGoodsId(v.get(0).getGoodsId());
                    int sum = v.stream().mapToInt(TOrderSaleGoods::getGoodsCount).sum();
                    BigDecimal rate = new BigDecimal(100).subtract(start.getLossRate()).divide(new BigDecimal(100)).setScale(2, BigDecimal.ROUND_HALF_UP);
                    BigDecimal bigDecimal = new BigDecimal(sum).divide(rate,2,BigDecimal.ROUND_HALF_UP).setScale(0, BigDecimal.ROUND_HALF_UP);
                    tOrderStockGoods.setStockCount(Integer.parseInt(bigDecimal.toString().split("\\.")[0]));
                    orderStockGoods1.add(tOrderStockGoods);
                });
                orderStock1.setOrderStockGoods(orderStockGoods1);
                stockList.add(orderStock1);

            }else {
                TStockDataSet end = stockDataSets.get(i + 1);
                LocalDate endTime = end.getStockDate();
                List<TOrderSale> collect = orderSales.stream().filter(e -> e.getOrderTime().compareTo(startTime) >= 0 && e.getOrderTime().compareTo(endTime) < 0).collect(Collectors.toList());
                List<TOrderSaleGoods> orderSaleGoodsList = new ArrayList<>();
                collect.forEach(e->orderSaleGoodsList.addAll(e.getOrderSaleGoods()));
                // 根据商品新生成一条数据
                TOrderStock orderStock = new TOrderStock();
                orderStock.setStockNum(OrderNumConstants.STOCK + CodeGenerateUtils.generateVolumeSn());
                orderStock.setStockTime(startTime);
                orderStock.setIsCover(0);
                orderStock.setGeneratorId(dataGenerator.getId());
                orderStock.setShopId(dto.getShopId());

                Map<String, List<TOrderSaleGoods>> goodsList = orderSaleGoodsList.stream().collect(Collectors.groupingBy(TOrderSaleGoods::getGoodsName));
                List<TOrderStockGoods> orderStockGoods = new ArrayList<>();
                goodsList.forEach((k,v)->{
                    TOrderStockGoods tOrderStockGoods = new TOrderStockGoods();
                    tOrderStockGoods.setGoodsName(k);
                    tOrderStockGoods.setGoodsNum(v.get(0).getGoodsNum());
                    tOrderStockGoods.setCostPrice(v.get(0).getGoodsCostPrice());
                    tOrderStockGoods.setSalePrice(v.get(0).getGoodsSalePrice());
//                    tOrderStockGoods.setThisCostPrice(v.get(0).getThisSalePrice());
                    tOrderStockGoods.setGoodsPicture(v.get(0).getGoodsPicture());
                    tOrderStockGoods.setGoodsId(v.get(0).getGoodsId());
                    int sum = v.stream().mapToInt(TOrderSaleGoods::getGoodsCount).sum();
                    BigDecimal rate = new BigDecimal(100).subtract(start.getLossRate()).divide(new BigDecimal(100)).setScale(2, BigDecimal.ROUND_HALF_UP);
                    BigDecimal bigDecimal = new BigDecimal(sum).divide(rate,2,BigDecimal.ROUND_HALF_UP).setScale(0, BigDecimal.ROUND_HALF_UP);
                    tOrderStockGoods.setStockCount(Integer.parseInt(bigDecimal.toString().split("\\.")[0]));
                    orderStockGoods.add(tOrderStockGoods);
                });
                orderStock.setOrderStockGoods(orderStockGoods);
                stockList.add(orderStock);
            }
        }
        // 判断是否进行了终止操作
        if(redisCache.hasKey(OrderNumConstants.STOCK+"_"+dto.getShopId())){
            redisCache.deleteObject(OrderNumConstants.STOCK+"_"+dto.getShopId());
            return;
        }
        // 删除上一次的数据生成
        if(Objects.nonNull(orderStockLast) && Objects.nonNull(stockDataSet) && stockDataSets.size() > 1){
            orderStockService.removeById(orderStockLast);
        }
        orderSaleService.saveBatch(orderSales);
        for (TOrderSale orderSale : orderSales) {
            orderSale.getOrderSaleGoods().forEach(e->e.setOrderId(orderSale.getId()));
        }
        List<TGoodsType> list = goodsTypeService.list();
//        orderSaleGoods.forEach(e->e.setTypeName(list.stream().filter(m->m.getId().equals(e.getTypeId())).findFirst().get().getTypeName()));
        orderSaleGoods.forEach(e->{
            e.setId(null);
            e.setGoodsCostPrice(null);
        });
        orderSaleGoodsService.saveBatch(orderSaleGoods);
        // 添加数据
        orderStockService.saveBatch(stockList);
        for (TOrderStock stock : stockList) {
            stock.getOrderStockGoods().forEach(e->e.setOrderId(stock.getId()));
        }
        List<TOrderStockGoods> orderStockGoods = stockList.stream().map(TOrderStock::getOrderStockGoods).flatMap(Collection::stream).collect(Collectors.toList());
        orderStockGoodsService.saveBatch(orderStockGoods);
    }

    @Override
    public PageInfo<TDataGeneratorVO> pageList(TDataGeneratorQuery query) {
        PageInfo<TDataGeneratorVO> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());
        List<TDataGeneratorVO> list = this.baseMapper.pageList(query,pageInfo);
        List<Long> ids = list.stream().map(TDataGeneratorVO::getId).collect(Collectors.toList());
        if(CollectionUtils.isEmpty(ids)){
            return new PageInfo<>();
        }
        if(query.getOrderType() == 1){
            List<TOrderMeal> orderMeals = orderMealService.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);
                    BigDecimal money = orderMeals.stream().filter(e -> e.getGeneratorId().equals(tDataGeneratorVO.getId()))
                            .map(TOrderMeal::getPayMoney).reduce(BigDecimal.ZERO, BigDecimal::add);
                    tDataGeneratorVO.setTotalRevenue(money);
                }
            }
        }else {
            List<TOrderSale> orderSales = orderSaleService.list(Wrappers.lambdaQuery(TOrderSale.class)
                    .in(TOrderSale::getGeneratorId, ids));
//            List<Long> saleIds = orderSales.stream().map(TOrderSale::getId).collect(Collectors.toList());
//            List<TOrderSaleGoods> orderSaleGoods = orderSaleGoodsService.list(Wrappers.lambdaQuery(TOrderSaleGoods.class)
//                    .in(TOrderSaleGoods::getOrderId, saleIds));
            for (TDataGeneratorVO tDataGeneratorVO : list) {
//                List<Long> collect = orderSales.stream().filter(e -> e.getGeneratorId().equals(tDataGeneratorVO.getId())).map(TOrderSale::getId).collect(Collectors.toList());
//                BigDecimal money = orderSaleGoods.stream().filter(e -> collect.contains(e.getOrderId()))
//                        .reduce(BigDecimal.ZERO, (x, y) -> x.add(y.getGoodsCostPrice().multiply(new BigDecimal(y.getGoodsCount()))), BigDecimal::add);
                if(!CollectionUtils.isEmpty(orderSales)){
                    List<TOrderSale> collect = orderSales.stream().filter(e -> e.getGeneratorId().equals(tDataGeneratorVO.getId())).collect(Collectors.toList());
                    BigDecimal money = BigDecimal.ZERO;
                    if(!CollectionUtils.isEmpty(collect)){
                        money = collect.stream().map(TOrderSale::getPayMoney).reduce(BigDecimal::add).get();
                    }
                    tDataGeneratorVO.setTotalRevenue(money);
                }
            }
        }
        pageInfo.setRecords(list);
        return pageInfo;
    }

    @Override
    public void dataCoverage(Long id) {
        TDataGenerator dataGenerator = this.getOne(Wrappers.lambdaQuery(TDataGenerator.class)
                .eq(TDataGenerator::getId, id));
        if(dataGenerator.getOrderType() == 1){
            // 删除时间段的数据
            orderMealService.remove(Wrappers.lambdaQuery(TOrderMeal.class)
                    .ge(TOrderMeal::getMealTime, dataGenerator.getStartTime())
                    .le(TOrderMeal::getMealTime, dataGenerator.getEndTime())
                    .eq(TOrderMeal::getIsCover,1));
            // 修改覆盖类型为已覆盖
            orderMealService.update(Wrappers.lambdaUpdate(TOrderMeal.class).set(TOrderMeal::getIsCover, 1).eq(TOrderMeal::getGeneratorId, id));
        }else {
            List<TOrderStock> list = orderStockService.list(Wrappers.lambdaQuery(TOrderStock.class)
                    .eq(TOrderStock::getGeneratorId, id));
            List<Long> stockIds = list.stream().map(TOrderStock::getId).collect(Collectors.toList());
            if(!CollectionUtils.isEmpty(stockIds)){
                List<TOrderStockGoods> list1 = orderStockGoodsService.list(Wrappers.lambdaQuery(TOrderStockGoods.class)
                        .in(TOrderStockGoods::getOrderId, stockIds));
                // 判断集合中的进价是否为0
                for (TOrderStockGoods tOrderStockGoods : list1) {
                    if(tOrderStockGoods.getThisCostPrice().compareTo(BigDecimal.ZERO) == 0){
                        throw new ServiceException("进价不能为0");
                    }
                }
            }
            // 删除时间段的数据
            orderSaleService.remove(Wrappers.lambdaQuery(TOrderSale.class)
                    .ge(TOrderSale::getOrderTime, dataGenerator.getStartTime())
                    .le(TOrderSale::getOrderTime, dataGenerator.getEndTime())
                    .eq(TOrderSale::getIsCover,1));
            // 修改覆盖类型为已覆盖
            orderSaleService.update(Wrappers.lambdaUpdate(TOrderSale.class).set(TOrderSale::getIsCover, 1).eq(TOrderSale::getGeneratorId, id));
            // 删除时间段的数据
            orderStockService.remove(Wrappers.lambdaQuery(TOrderStock.class)
                    .ge(TOrderStock::getStockTime, dataGenerator.getStartTime())
                    .le(TOrderStock::getStockTime, dataGenerator.getEndTime())
                    .eq(TOrderStock::getIsCover,1));
            // 修改覆盖类型为已覆盖
            orderStockService.update(Wrappers.lambdaUpdate(TOrderStock.class).set(TOrderStock::getIsCover, 1).eq(TOrderStock::getGeneratorId, id));
        }
        dataGenerator.setStatus(3);
        this.updateById(dataGenerator);
    }

    @Override
    public TDataGeneratorMealDetailVO mealGeneratorDataDetail(TDataGeneratorMealQuery query) {
        // 查询餐饮数据生成详情
        TDataGenerator dataGenerator = this.getById(query.getGeneratorId());
        TDataGeneratorMealDetailVO data = new TDataGeneratorMealDetailVO();
        BeanUtils.copyProperties(dataGenerator,data);
        // 查询店铺
        TShop shop = shopService.getById(dataGenerator.getShopId());
        if(Objects.nonNull(shop)){
            data.setShopName(shop.getShopName());
        }
        // 查询订单
        PageInfo<TOrderMealVO> pageInfo = orderMealService.pageListGenerator(query);
        data.setOrderMealList(pageInfo);
        // 统计支付金额
        Map<String, Double> map = orderMealService.getDataGeneratorMealDetail(query);
        BigDecimal money = new BigDecimal(map.get("moneyPay")).setScale(2,BigDecimal.ROUND_HALF_UP);
        BigDecimal card = new BigDecimal(map.get("cardPay")).setScale(2,BigDecimal.ROUND_HALF_UP);
        BigDecimal weiXin = new BigDecimal(map.get("weiXinPay")).setScale(2,BigDecimal.ROUND_HALF_UP);
        BigDecimal ali = new BigDecimal(map.get("aliPay")).setScale(2,BigDecimal.ROUND_HALF_UP);
        BigDecimal other = new BigDecimal(map.get("otherPay")).setScale(2,BigDecimal.ROUND_HALF_UP);
        data.setMoneyPayAmount(money);
        data.setCardPayAmount(card);
        data.setWeiXinPayAmount(weiXin);
        data.setAliPayAmount(ali);
        data.setOtherPayAmount(other);
        return data;
    }

    @Override
    public TDataGeneratorSaleDetailVO saleGeneratorDataDetail(TDataGeneratorSaleQuery query) {
        // 查询餐饮数据生成详情
        TDataGeneratorSaleDetailVO data = new TDataGeneratorSaleDetailVO();
        // 查询订单
        TOrderSaleQuery orderSaleQuery = new TOrderSaleQuery();
        orderSaleQuery.setTimeType(query.getTimeType());
        orderSaleQuery.setPayType(query.getPayType());
        orderSaleQuery.setOrderNum(query.getOrderNum());
        orderSaleQuery.setGeneratorId(query.getGeneratorId());
        try {
            if (Objects.nonNull(query.getStartTime()) && Objects.nonNull(query.getEndTime())){
                orderSaleQuery.setStartTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(query.getStartTime()));
                orderSaleQuery.setEndTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(query.getEndTime()));
            }
        } catch (ParseException e) {
            throw new ServiceException(e.getMessage());
        }
        PageInfo<TOrderSaleVO> pageInfo = orderSaleService.pageList(orderSaleQuery);
        data.setOrderMealList(pageInfo);
        // 统计支付金额
        Map<String, Double> map = orderSaleService.getDataGeneratorSaleDetail(query);
        BigDecimal money = new BigDecimal(map.get("moneyPay")).setScale(2,BigDecimal.ROUND_HALF_UP);
        BigDecimal card = new BigDecimal(map.get("cardPay")).setScale(2,BigDecimal.ROUND_HALF_UP);
        BigDecimal weiXin = new BigDecimal(map.get("weiXinPay")).setScale(2,BigDecimal.ROUND_HALF_UP);
        BigDecimal ali = new BigDecimal(map.get("aliPay")).setScale(2,BigDecimal.ROUND_HALF_UP);
        BigDecimal other = new BigDecimal(map.get("otherPay")).setScale(2,BigDecimal.ROUND_HALF_UP);
        data.setMoneyPayAmount(money);
        data.setCardPayAmount(card);
        data.setWeiXinPayAmount(weiXin);
        data.setAliPayAmount(ali);
        data.setOtherPayAmount(other);
        return data;
    }

    @Override
    public TDataGeneratorStockDetailVO stockGeneratorDataDetail(TDataGeneratorStockQuery query) {
        // 查询餐饮数据生成详情
        TDataGeneratorStockDetailVO data = new TDataGeneratorStockDetailVO();
        // 查询订单
        TOrderStockQuery orderStockQuery = new TOrderStockQuery();
        orderStockQuery.setGeneratorId(query.getGeneratorId());
        orderStockQuery.setTimeType(query.getTimeType());
        orderStockQuery.setStockNum(query.getOrderNum());
        try {
            if(Objects.nonNull(query.getStartTime()) && Objects.nonNull(query.getEndTime())){
                orderStockQuery.setStartTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(query.getStartTime()));
                orderStockQuery.setEndTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(query.getEndTime()));
            }
        } catch (ParseException e) {
            throw new ServiceException(e.getMessage());
        }
        PageInfo<TOrderStockVO> pageInfo = orderStockService.pageList(orderStockQuery);
        data.setOrderStockVOList(pageInfo);
        // 统计支付金额
        Map<String, Object> map = orderStockService.getDataGeneratorStockDetail(query);
        Integer totalStock = Integer.parseInt(map.get("totalStock").toString());
//        BigDecimal stockAmountSum = new BigDecimal(map.get("stockAmountSum").toString());
        data.setTotalStock(totalStock);
        List<TOrderStock> list = orderStockService.list(Wrappers.lambdaQuery(TOrderStock.class)
                .eq(TOrderStock::getGeneratorId, query.getGeneratorId()));
        if(CollectionUtils.isEmpty(list)){
            data.setStockAmountSum(BigDecimal.ZERO);
        }else {
            data.setStockAmountSum(list.stream().filter(e->Objects.nonNull(e.getStockTotalPrice())).map(TOrderStock::getStockTotalPrice).reduce(BigDecimal.ZERO, BigDecimal::add));
        }
        return data;
    }

    @Override
    public List<TOrderSaleVO> mealGeneratorExport(TDataGeneratorMealQuery query) {
        return null;
    }

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

    private int getRandomPayType(Integer size,BigDecimal count) {
        BigDecimal bigDecimal = new BigDecimal(size).multiply(count.divide(new BigDecimal(100))).setScale(0, BigDecimal.ROUND_FLOOR);
        return Integer.parseInt(bigDecimal.toString());
    }

    private int getRandom(int min,int max) {
        // 生成一个min到max之间的随机数
        return new Random().nextInt(max - min + 1) + min;
    }

    private static <T> List<T> randomSelection(List<T> list, int size) {
        List<T> selected = new ArrayList<>();
        int length = list.size();
        for (int i = 0; i < size; i++) {
            Collections.shuffle(list);
            // 如果需求的大小超过了集合的长度，则只能取到集合的全部元素
            int subListSize = Math.min(size - selected.size(), length);
            selected.addAll(list.subList(0, subListSize));
        }
        return selected;
    }

}