package com.infoloop.tianting.service.impl;

import com.infoloop.tianting.clientcustomerorderservice.OrderStatusEnum;
import com.infoloop.tianting.clientcustomerorderservice.ServeStatusEnum;
import com.infoloop.tianting.clientcustomerorderservice.SingleClientCustomerOrderDetailRpcResponse;
import com.infoloop.tianting.clientcustomerorderservice.SingleClientCustomerOrderRpcResponse;
import com.infoloop.tianting.clientinventoryservice.SingleClientRpcResponse;
import com.infoloop.tianting.context.LoginContextHolder;
import com.infoloop.tianting.enums.SettlementDimensionEnum;
import com.infoloop.tianting.exception.ClientEndExceptions.BusinessException;
import com.infoloop.tianting.exception.ErrorCodeEnum;
import com.infoloop.tianting.menuservice.SingleMenuDetailRpcResponse;
import com.infoloop.tianting.menuservice.SingleMenuRpcResponse;
import com.infoloop.tianting.model.dto.OrderDbDTO.QueryOrderByConditionDto;
import com.infoloop.tianting.model.dto.SettlementDTO.SettlementDataByMealDto;
import com.infoloop.tianting.model.dto.SettlementDTO.SettlementDataDto;
import com.infoloop.tianting.model.dto.SettlementDTO.SettlementMenuMealDto;
import com.infoloop.tianting.model.dto.SettlementDTO.SettlementMenuSkuDto;
import com.infoloop.tianting.model.dto.SettlementDTO.SettlementRequestDto;
import com.infoloop.tianting.service.SettlementService;
import com.infoloop.tianting.service.client.InventoryServiceRpcClient;
import com.infoloop.tianting.service.client.MealServiceRpcClient;
import com.infoloop.tianting.service.client.MenuServiceRpcClient;
import com.infoloop.tianting.service.client.OrderServiceRpcClient;
import com.infoloop.tianting.service.client.SkuServiceRpcClient;
import com.infoloop.tianting.utils.DateUtil;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

@Slf4j
@Service
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
public class SettlementServiceImpl implements SettlementService {
    private final OrderServiceRpcClient orderServiceRpcClient;
    private final MenuServiceRpcClient menuServiceRpcClient;
    private final SkuServiceRpcClient skuServiceRpcClient;
    private final InventoryServiceRpcClient inventoryServiceRpcClient;
    private final MealServiceRpcClient mealServiceRpcClient;

    public static ByteArrayOutputStream writeToExcelBySku(SettlementDataDto settlementDataDto)
            throws IOException {
        Workbook workbook = new XSSFWorkbook();
        Sheet sheet = workbook.createSheet("订单数据");

        final var classifyOrders = settlementDataDto.getClassifyOrders();

        int rowNum = 0;
        Row sheetTitleRow = sheet.createRow(rowNum++);
        Cell sheetTitleCell = sheetTitleRow.createCell(0);
        sheetTitleCell.setCellValue(settlementDataDto.getClient());
        Row dateRangeRow = sheet.createRow(rowNum++);
        Cell dateRangeCell = dateRangeRow.createCell(0);
        final var dateRange = settlementDataDto.getStartTime() + "至" + settlementDataDto.getEndTime();
        dateRangeCell.setCellValue(dateRange);
        Row titleRow = sheet.createRow(rowNum++);
        Cell dateTitleCell = titleRow.createCell(0);
        dateTitleCell.setCellValue("点餐日期");
        Cell menuTitleCell = titleRow.createCell(1);
        menuTitleCell.setCellValue("餐单名称");
        Cell skuCodeTitleCell = titleRow.createCell(2);
        skuCodeTitleCell.setCellValue("菜品编号");

        Cell skuNameTitleCell = titleRow.createCell(3);
        skuNameTitleCell.setCellValue("菜品名称");
        Cell skuPriceTitleCell = titleRow.createCell(4);
        skuPriceTitleCell.setCellValue("单价");
        Cell skuCountTitleCell = titleRow.createCell(5);
        skuCountTitleCell.setCellValue("数量");
        Cell skuTotalPriceTitleCell = titleRow.createCell(6);
        skuTotalPriceTitleCell.setCellValue("合计金额");

        for (Map.Entry<String, Map<String, List<SettlementMenuSkuDto>>> outerEntry : classifyOrders.entrySet()) {
            String orderDate = outerEntry.getKey();
            Map<String, List<SettlementMenuSkuDto>> innerMap = outerEntry.getValue();
            int curDateTotalRow = 0;
            for (Map.Entry<String, List<SettlementMenuSkuDto>> innerEntry : innerMap.entrySet()) {
                curDateTotalRow += innerEntry.getValue().size();
            }

            // 写入日期列并合并单元格
            int startRowForDate = rowNum;
            for (int i = 0; i < curDateTotalRow; i++) {
                Row dateRow = sheet.createRow(rowNum++);
                Cell dateCell = dateRow.createCell(0);
                dateCell.setCellValue(orderDate);
            }
            int endRowForDate = rowNum - 1;
            if (endRowForDate > startRowForDate) {
                CellRangeAddress dateRegion = new CellRangeAddress(startRowForDate, endRowForDate, 0, 0);
                sheet.addMergedRegion(dateRegion);
            }

            rowNum = startRowForDate;
            for (Map.Entry<String, List<SettlementMenuSkuDto>> innerEntry : innerMap.entrySet()) {
                String menuName = innerEntry.getKey();
                List<SettlementMenuSkuDto> skuList = innerEntry.getValue();

                // 写入菜单ID列并合并单元格
                int startRowForMenu = rowNum;
                for (int i = 0; i < skuList.size(); i++) {
                    Row menuRow = sheet.getRow(rowNum++);
                    Cell menuCell = menuRow.createCell(1);
                    menuCell.setCellValue(menuName);
                }
                int endRowForMenu = rowNum - 1;
                if (endRowForMenu > startRowForMenu) {
                    CellRangeAddress menuRegion = new CellRangeAddress(startRowForMenu, endRowForMenu, 1, 1);
                    sheet.addMergedRegion(menuRegion);
                }

                // 写入SKU列
                rowNum = startRowForMenu;
                for (SettlementMenuSkuDto skuDto : skuList) {
                    Row skuRow = sheet.getRow(rowNum++);
                    Cell skuCodeCell = skuRow.createCell(2);
                    skuCodeCell.setCellValue(skuDto.getSkuCode());
                    Cell showNameCell = skuRow.createCell(3);
                    showNameCell.setCellValue(skuDto.getShowName());
                    Cell priceCell = skuRow.createCell(4);
                    priceCell.setCellValue((double) skuDto.getPrice() / 100);
                    Cell countCell = skuRow.createCell(5);
                    countCell.setCellValue(skuDto.getCount());
                    Cell totalPriceCell = skuRow.createCell(6);
                    totalPriceCell.setCellValue((double) skuDto.getTotalPrice() / 100);
                }
            }
        }

        // 自动调整列宽
        for (int i = 0; i < 7; i++) {
            sheet.autoSizeColumn(i);
        }

        // 将工作簿内容写入字节数组输出流
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        workbook.write(outputStream);
        workbook.close();

        return outputStream;
    }

    public static ByteArrayOutputStream writeToExcelByMeal(SettlementDataByMealDto settlementDataDto)
            throws IOException {
        Workbook workbook = new XSSFWorkbook();
        Sheet sheet = workbook.createSheet("订单数据");

        final var classifyOrders = settlementDataDto.getClassifyOrders();

        int rowNum = 0;
        Row sheetTitleRow = sheet.createRow(rowNum++);
        Cell sheetTitleCell = sheetTitleRow.createCell(0);
        sheetTitleCell.setCellValue(settlementDataDto.getClient());
        Row dateRangeRow = sheet.createRow(rowNum++);
        Cell dateRangeCell = dateRangeRow.createCell(0);
        final var startDateStr = DateUtil.formatDate(settlementDataDto.getStartTime(), DateUtil.YYYY_MM_DD);
        final var endDateStr = DateUtil.formatDate(settlementDataDto.getEndTime(), DateUtil.YYYY_MM_DD);
        final var dateRange = startDateStr + "至" + endDateStr;
        dateRangeCell.setCellValue(dateRange);
        Row titleRow = sheet.createRow(rowNum++);
        int columnNum = 0;
        Cell menuTitleCell = titleRow.createCell(columnNum++);
        menuTitleCell.setCellValue("餐单名称");
        Cell mealTitleCell = titleRow.createCell(columnNum++);
        mealTitleCell.setCellValue("餐别");

        final var dates = getDatesBetween(settlementDataDto.getStartTime(),
                settlementDataDto.getEndTime());
        for (String date : dates) {
            Cell dateTitleCell = titleRow.createCell(columnNum++);
            dateTitleCell.setCellValue(date);
        }
        Cell priceTitleCell = titleRow.createCell(columnNum);
        priceTitleCell.setCellValue("总金额");
        for (Map.Entry<String, Map<String, Map<String, List<SettlementMenuMealDto>>>> outerEntry : classifyOrders.entrySet()) {
            String menuNme = outerEntry.getKey();
            Map<String, Map<String, List<SettlementMenuMealDto>>> innerMap = outerEntry.getValue();
            int curMenuTotalRow = innerMap.size();
            // 写入menu列并合并单元格
            int startRowForMenu = rowNum;
            for (int i = 0; i < curMenuTotalRow; i++) {
                Row dateRow = sheet.createRow(rowNum++);
                Cell menuCell = dateRow.createCell(0);
                menuCell.setCellValue(menuNme);
            }
            int endRowForDate = rowNum - 1;
            if (endRowForDate > startRowForMenu) {
                CellRangeAddress dateRegion = new CellRangeAddress(startRowForMenu, endRowForDate, 0, 0);
                sheet.addMergedRegion(dateRegion);
            }

            rowNum = startRowForMenu;
            for (Map.Entry<String, Map<String, List<SettlementMenuMealDto>>> innerEntry : innerMap.entrySet()) {
                String mealName = innerEntry.getKey();
                Map<String, List<SettlementMenuMealDto>> skuMap = innerEntry.getValue();

                // 写入meal列并合并单元格
                Row mealRow = sheet.getRow(rowNum++);
                Cell mealCell = mealRow.createCell(1);
                mealCell.setCellValue(mealName);

                columnNum = 2;
                int totalPrice = 0;
                for (String date : dates) {
                    List<SettlementMenuMealDto> toWriteDateSkuList = skuMap.get(date);
                    if (toWriteDateSkuList == null) {
                        toWriteDateSkuList = new ArrayList<>();
                    }
                    int price = 0;
                    if (!toWriteDateSkuList.isEmpty()) {
                        for (SettlementMenuMealDto settlementMenuMealDto : toWriteDateSkuList) {
                            price += settlementMenuMealDto.getPrice() * settlementMenuMealDto.getCount();
                        }
                    }
                    totalPrice += price;
                    Cell priceCell = mealRow.createCell(columnNum++);
                    priceCell.setCellValue((double) price / 100);
                }
                Cell totalPriceCell = mealRow.createCell(columnNum);
                totalPriceCell.setCellValue((double) totalPrice / 100);
            }
        }

        // 自动调整列宽
        final var columnCnt = dates.size() + 2;
        for (int i = 0; i < columnCnt; i++) {
            sheet.autoSizeColumn(i);
        }

        // 将工作簿内容写入字节数组输出流
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        workbook.write(outputStream);
        workbook.close();

        return outputStream;
    }

    public static List<String> getDatesBetween(LocalDateTime startTime, LocalDateTime endTime) {
        List<String> dateList = new ArrayList<>();
        LocalDate startDate = startTime.toLocalDate();
        LocalDate endDate = endTime.toLocalDate();

        long daysBetween = ChronoUnit.DAYS.between(startDate, endDate) + 1;
        for (int i = 0; i < daysBetween; i++) {
            LocalDate currentDate = startDate.plusDays(i);
            dateList.add(DateUtil.formatDate(currentDate, DateUtil.YYYY_MM_DD));
        }
        return dateList;
    }

    @Override
    public ByteArrayOutputStream generateOrderSettlementExcel(SettlementRequestDto settlementRequest) {
        if (settlementRequest.getDimension().equals(SettlementDimensionEnum.BY_SKU)) {
            return generateOrderSettlementExcelBySku(settlementRequest);
        } else {
            return generateOrderSettlementExcelByMeal(settlementRequest);
        }
    }

    public ByteArrayOutputStream generateOrderSettlementExcelBySku(SettlementRequestDto settlementRequest) {
        final var startDate = settlementRequest.getTimeStart().plusHours(8).toLocalDate().atStartOfDay();
        final var endDate = settlementRequest.getTimeEnd().plusHours(8).toLocalDate().plusDays(1).atStartOfDay();
        final var operatorLoginInfo = LoginContextHolder.getLoginInfo();
        final int enterpriseId = LoginContextHolder.hasLogin() ? operatorLoginInfo.getEnterpriseId() : settlementRequest.getEnterpriseId();
        final var queryOrderDto = QueryOrderByConditionDto.builder()
                .enterpriseId(enterpriseId)
                .shouldFilterCreatedAtTimeStart(true)
                .createdAtTimeStart(startDate)
                .shouldFilterCreatedAtTimeEnd(true)
                .createdAtTimeEnd(endDate)
                .shouldFilterStallIds(!settlementRequest.getStallIds().isEmpty())
                .stallIds(settlementRequest.getStallIds())
                .build();
        final var orderList = orderServiceRpcClient.getOrdersByCondition(queryOrderDto);
        List<Integer> orderIds = orderList.stream()
                .filter(o -> !o.getStatus().equals(OrderStatusEnum.ORDER_CANCELED))
                .map(SingleClientCustomerOrderRpcResponse::getId).distinct()
                .collect(Collectors.toList());
        final var orderDetailList = orderServiceRpcClient.getOrderDetailsByOrderIds(orderIds);
        List<Integer> skuIds = orderDetailList.stream()
                .filter(d -> !d.getServeStatus().equals(ServeStatusEnum.SERVE_REJECT))
                .map(SingleClientCustomerOrderDetailRpcResponse::getSkuId)
                .distinct()
                .collect(Collectors.toList());
        final var skus = skuServiceRpcClient.getDishSkusByIds(skuIds).getResponseList();

        List<Integer> menuIds = orderList.stream().map(
                        SingleClientCustomerOrderRpcResponse::getMenuId).distinct()
                .collect(Collectors.toList());
        final var menuList = menuServiceRpcClient
                .getMenusByIds(enterpriseId, menuIds)
                .getResponsesList();
        final var menuDetailList = menuServiceRpcClient.queryMenuDetailsByMenuIds(
                enterpriseId, menuIds).getResponsesList();

        Map<String, Map<String, List<SettlementMenuSkuDto>>> classifyOrders = new HashMap<>();

        //找出所有需要的日期
        final var dates = orderList.stream()
                .sorted(Comparator.comparingLong(SingleClientCustomerOrderRpcResponse::getCreatedAt))
                .map(o -> DateUtil.formatDateOfUtc(o.getCreatedAt(), DateUtil.YYYY_MM_DD_UTC))
                .distinct()
                .collect(Collectors.toList());
        for (String date : dates) {

            if (!classifyOrders.containsKey(date)) {
                classifyOrders.put(date, new HashMap<>());
            }
            final var menusMap = classifyOrders.get(date);

            // 找出当天所有的订单
            final var curOrderList = orderList.stream()
                    .filter(o -> Objects.equals(DateUtil.formatDateOfUtc(o.getCreatedAt(), DateUtil.YYYY_MM_DD_UTC), date))
                    .collect(Collectors.toList());
            final var curOrderIds = curOrderList.stream()
                    .map(SingleClientCustomerOrderRpcResponse::getId)
                    .collect(Collectors.toList());

            // 找出当天已点的所有餐单
            final var curMenuIds = curOrderList.stream()
                    .map(SingleClientCustomerOrderRpcResponse::getMenuId)
                    .distinct()
                    .collect(Collectors.toList());
            for (Integer curMenuId : curMenuIds) {
                final var curMenu = menuList.stream().filter(m -> m.getId() == curMenuId).findFirst();
                if (curMenu.isEmpty()) {
                    continue;
                }
                final var curMenuName = curMenu.get().getName();
                if (!menusMap.containsKey(curMenuName)) {
                    menusMap.put(curMenuName, new ArrayList<>());
                }
                final var menuSkuList = new ArrayList<SettlementMenuSkuDto>();
                // 找出当天餐单所有的菜品
                final var curMenuDetails = menuDetailList.stream()
                        .filter(md -> md.getMenuId() == curMenuId)
                        .collect(Collectors.toList());

                //找出当天所有已点的菜品明细
                final var curOrderDetails = orderDetailList.stream()
                        .filter(d -> curOrderIds.contains(d.getOrderId()) && !d.getServeStatus().equals(ServeStatusEnum.SERVE_REJECT))
                        .collect(Collectors.toList());

                for (SingleMenuDetailRpcResponse m : curMenuDetails) {
                    // 找出该餐单下该sku所点菜品的明细
                    final var curSkuOrderDetails = curOrderDetails.stream()
                            .filter(rd -> rd.getMenuDetailId() == m.getId())
                            .collect(Collectors.toList());
                    final var countList = curSkuOrderDetails.stream()
                            .map(SingleClientCustomerOrderDetailRpcResponse::getCount)
                            .collect(Collectors.toList());
                    int countTotal = countList.stream().mapToInt(Integer::intValue).sum();
                    if (countTotal <= 0) {
                        continue;
                    }
                    // 找出该sku的code
                    final var curSku = skus.stream().filter(s -> s.getId() == m.getSkuId()).findFirst();
                    String skuCode = "";
                    if (curSku.isPresent()) {
                        skuCode = curSku.get().getCode();
                        final var existSku = menuSkuList.stream().filter(s -> s.getSkuCode().equals(curSku.get().getCode())).findFirst();
                        if (existSku.isPresent()) {
                            final var originalSku = existSku.get();
                            final var count = existSku.get().getCount();
                            final var newCount = count + countTotal;
                            originalSku.setCount(newCount);
                            originalSku.setTotalPrice(m.getPrice() * newCount);
                            continue;
                        }
                    }

                    final var settlementMenuSku = SettlementMenuSkuDto.builder()
                            .skuCode(skuCode)
                            .count(countTotal)
                            .showName(m.getShowName())
                            .price(m.getPrice())
                            .totalPrice(m.getPrice() * countTotal)
                            .build();
                    menuSkuList.add(settlementMenuSku);

                }
                menusMap.get(curMenuName).addAll(menuSkuList);

            }
        }
        final var stalls = inventoryServiceRpcClient.getStallsByIds(enterpriseId, settlementRequest.getStallIds()).getClientsList();
        final var stallNames = stalls.stream()
                .filter(s -> settlementRequest.getStallIds().contains(s.getId()))
                .map(SingleClientRpcResponse::getName).collect(Collectors.toList());
        String joinedString = String.join(" ", stallNames);
        final var settlementDataDto = SettlementDataDto.builder()
                .classifyOrders(classifyOrders)
                .client(joinedString)
                .startTime(DateUtil.formatDate(settlementRequest.getTimeStart().plusHours(8), DateUtil.YYYY_MM_DD))
                .endTime(DateUtil.formatDate(settlementRequest.getTimeEnd().plusHours(8), DateUtil.YYYY_MM_DD))
                .build();

        try {
            return writeToExcelBySku(settlementDataDto);
        } catch (IOException e) {
            throw BusinessException.build(ErrorCodeEnum.GENERATE_EXCEL_ERROR);
        }

    }

    public ByteArrayOutputStream generateOrderSettlementExcelByMeal(SettlementRequestDto settlementRequest) {
        final var startDate = settlementRequest.getTimeStart().plusHours(8).toLocalDate().atStartOfDay();
        final var endDate = settlementRequest.getTimeEnd().plusHours(8).toLocalDate().plusDays(1).atStartOfDay();
        final var operatorLoginInfo = LoginContextHolder.getLoginInfo();
        final int enterpriseId = LoginContextHolder.hasLogin() ? operatorLoginInfo.getEnterpriseId() : settlementRequest.getEnterpriseId();
        final var queryOrderDto = QueryOrderByConditionDto.builder()
                .enterpriseId(enterpriseId)
                .shouldFilterCreatedAtTimeStart(true)
                .createdAtTimeStart(startDate)
                .shouldFilterCreatedAtTimeEnd(true)
                .createdAtTimeEnd(endDate)
                .shouldFilterStallIds(!settlementRequest.getStallIds().isEmpty())
                .stallIds(settlementRequest.getStallIds())
                .build();
        final var orderList = orderServiceRpcClient.getOrdersByCondition(queryOrderDto);
        List<Integer> orderIds = orderList.stream()
                .filter(o -> !o.getStatus().equals(OrderStatusEnum.ORDER_CANCELED))
                .map(SingleClientCustomerOrderRpcResponse::getId).distinct()
                .collect(Collectors.toList());
        final var orderDetailList = orderServiceRpcClient.getOrderDetailsByOrderIds(orderIds);
        List<Integer> menuIds = orderList.stream().map(
                        SingleClientCustomerOrderRpcResponse::getMenuId).distinct()
                .collect(Collectors.toList());
        final var menuList = menuServiceRpcClient
                .getMenusByIds(enterpriseId, menuIds)
                .getResponsesList();
        //获取到所有的餐别
        final var allMeals = mealServiceRpcClient.getAllMeals(enterpriseId).getResponsesList();

        Map<String, Map<String, Map<String, List<SettlementMenuMealDto>>>> classifyOrders = new HashMap<>();
        for (SingleMenuRpcResponse menu : menuList) {
            final var menuName = menu.getName();
            if (!classifyOrders.containsKey(menuName)) {
                classifyOrders.put(menuName, new HashMap<>());
            }
            final var menusMap = classifyOrders.get(menuName);
            //这个餐单下所有已点的orders
            final var curMenuOrders = orderList.stream()
                    .filter(o -> o.getMenuId() == menu.getId())
                    .collect(Collectors.toList());
            final var curMenuOrderIds = curMenuOrders.stream()
                    .map(SingleClientCustomerOrderRpcResponse::getId)
                    .collect(Collectors.toList());
            //这个餐单下所有已点的order details
            final var curMenuOrderDetails = orderDetailList.stream()
                    .filter(od -> curMenuOrderIds.contains(od.getOrderId()))
                    .collect(Collectors.toList());
            //这个餐单下所有已点的餐别
            final var curMenuMealIds = curMenuOrderDetails.stream()
                    .map(SingleClientCustomerOrderDetailRpcResponse::getMealId)
                    .distinct()
                    .collect(Collectors.toList());
            // 汇总每个餐别的情况
            for (Integer curMealId : curMenuMealIds) {
                String mealName = "无餐别";
                if (curMealId != 0) {
                    final var curMeal = allMeals.stream().filter(m -> m.getId() == curMealId).findFirst();
                    if (curMeal.isEmpty()) {
                        continue;
                    } else {
                        mealName = curMeal.get().getName();
                    }
                }
                if (!menusMap.containsKey(mealName)) {
                    menusMap.put(mealName, new HashMap<>());
                }
                final var mealsMap = menusMap.get(mealName);
                //当前餐别已点的order details
                final var curMealOrderDetails = curMenuOrderDetails.stream()
                        .filter(od -> od.getMealId() == curMealId)
                        .collect(Collectors.toList());
                //找出所有需要的日期
                final var dates = curMealOrderDetails.stream()
                        .sorted(Comparator.comparingLong(SingleClientCustomerOrderDetailRpcResponse::getCreatedAt))
                        .map(o -> DateUtil.formatDateOfUtc(o.getCreatedAt(), DateUtil.YYYY_MM_DD_UTC))
                        .distinct()
                        .collect(Collectors.toList());
                for (String date : dates) {

                    if (!mealsMap.containsKey(date)) {
                        mealsMap.put(date, new ArrayList<>());
                    }
                    final var curMealDateSkuList = mealsMap.get(date);
                    //找出当天所有的order details
                    final var curMealDateOrderDetails = curMealOrderDetails.stream()
                            .filter(o -> Objects.equals(DateUtil.formatDateOfUtc(o.getCreatedAt(), DateUtil.YYYY_MM_DD_UTC), date))
                            .collect(Collectors.toList());
                    for (SingleClientCustomerOrderDetailRpcResponse detail : curMealDateOrderDetails) {
                        if (detail.getServeStatus().equals(ServeStatusEnum.SERVE_REJECT)) {
                            continue;
                        }
                        final var settlementOrderDetail = SettlementMenuMealDto.builder()
                                .skuName(detail.getShowName())
                                .count(detail.getCount())
                                .price(detail.getPrice())
                                .build();
                        curMealDateSkuList.add(settlementOrderDetail);
                    }
                }
            }

        }
        final var client = inventoryServiceRpcClient.getClientById(enterpriseId,
                settlementRequest.getClientId()).getClient();
        final var settlementDataByMealDto = SettlementDataByMealDto.builder()
                .classifyOrders(classifyOrders)
                .client(client.getName())
                .startTime(settlementRequest.getTimeStart().plusHours(8))
                .endTime(settlementRequest.getTimeEnd().plusHours(8))
                .build();
        try {
            return writeToExcelByMeal(settlementDataByMealDto);
        } catch (IOException e) {
            throw BusinessException.build(ErrorCodeEnum.GENERATE_EXCEL_ERROR);
        }

    }

}