package com.infoloop.tianting.service.impl;

import com.infoloop.tianting.clientcustomerorderservice.OrderStatusEnum;
import com.infoloop.tianting.clientcustomerorderservice.SingleClientCustomerOrderDetailRpcResponse;
import com.infoloop.tianting.clientcustomerorderservice.SingleClientCustomerOrderRpcResponse;
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.setmealscheduleservice.SingleMealRpcResponse;
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;

  @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().toLocalDate().atStartOfDay();
    final var endDate = settlementRequest.getTimeEnd().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()
        .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 curMenuDetailIds = curMenuDetails.stream()
            .map(SingleMenuDetailRpcResponse::getId)
            .collect(Collectors.toList());

        //找出当天所有已点的菜品明细
        final var curOrderDetails = orderDetailList.stream()
            .filter(d -> curOrderIds.contains(d.getOrderId()))
            .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 client = inventoryServiceRpcClient.getClientById(enterpriseId,
        settlementRequest.getClientId()).getClient();
    final var settlementDataDto = SettlementDataDto.builder()
        .classifyOrders(classifyOrders)
        .client(client.getName())
        .startTime(DateUtil.formatDate(settlementRequest.getTimeStart(), DateUtil.YYYY_MM_DD))
        .endTime(DateUtil.formatDate(settlementRequest.getTimeEnd(), DateUtil.YYYY_MM_DD))
        .build();
    try {
        return writeToExcelBySku(settlementDataDto);
    } catch (IOException e) {
      throw BusinessException.build(ErrorCodeEnum.GENERATE_EXCEL_ERROR);
    }

  }

  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 ByteArrayOutputStream generateOrderSettlementExcelByMeal(SettlementRequestDto settlementRequest) {

    final var startDate =  settlementRequest.getTimeStart().toLocalDate().atStartOfDay();
    final var endDate = settlementRequest.getTimeEnd().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()
        .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();
    //获取到所有的餐别
    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());
      final var curMenuMeals = allMeals.stream()
          .filter(m -> curMenuMealIds.contains(m.getId()))
          .collect(Collectors.toList());
      // 汇总每个餐别的情况
      for(SingleMealRpcResponse meal: curMenuMeals) {
        final var mealName = meal.getName();
        if (!menusMap.containsKey(mealName)) {
          menusMap.put(menuName, new HashMap<>());
        }
        final var mealsMap = menusMap.get(mealName);
        //当前餐别已点的order details
        final var curMealOrderDetails = curMenuOrderDetails.stream()
            .filter(od -> od.getMealId() == meal.getId())
            .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) {
            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())
        .endTime(settlementRequest.getTimeEnd())
        .build();
    try {
        return writeToExcelByMeal(settlementDataByMealDto);
    } catch (IOException e) {
      throw BusinessException.build(ErrorCodeEnum.GENERATE_EXCEL_ERROR);
    }

  }

  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 dateRange = settlementDataDto.getStartTime() + "至" + settlementDataDto.getEndTime();
    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) {
          final var toWriteDateSkuList = skuMap.get(date);
          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);
      }
    }

    // 自动调整列宽
    for (int i = 0; i < 7; 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;
  }

}