package com.stylefeng.guns.modular.code.controller;

import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.stylefeng.guns.modular.system.dto.CourseDTO;
import com.stylefeng.guns.modular.system.dto.CourseQuery;
import com.stylefeng.guns.modular.system.dto.OSQuery;
import com.stylefeng.guns.modular.system.dto.OrderQuery;
import com.stylefeng.guns.modular.system.model.*;
import com.stylefeng.guns.modular.system.model.Package;
import com.stylefeng.guns.modular.system.service.*;
import com.stylefeng.guns.modular.system.util.DateUtils;
import com.stylefeng.guns.modular.system.util.Page;
import com.stylefeng.guns.modular.system.util.ResultUtil;
import com.stylefeng.guns.modular.system.util.UUIDUtil;
import com.stylefeng.guns.modular.system.vo.*;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import net.bytebuddy.asm.Advice;
import org.aspectj.weaver.ast.Or;
import org.aspectj.weaver.ast.Var;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @author 无关风月
 * @Date 2024/2/6 18:25
 */
@Slf4j
@RestController
@RequestMapping("")
public class OrderController {
    @Autowired
    private IFitnessTypeService fitnessTypeService;
    @Autowired
    private IFitnessPositionService fitnessPositionService;
    @Autowired
    private IAppUserService appUserService;
    @Autowired
    private ICourseService courseService;
    @Autowired
    private ICourseVideoService courseVideoService;
    @Autowired
    private IOrderService orderService;
    @Autowired
    private IOrderCourseService orderCourseService;
    @Autowired
    private ICouponService couponService;
    @Autowired
    private ICouponReceiveService couponReceiveService;
    @Autowired
    private IPackageService packageService;
    @Autowired
    private IProtocolService protocolService;
    @Autowired
    private IFindService findService;
    @Autowired
    private IRechargeService rechargeService;
    @Autowired
    private IWithdrawalService withdrawalService;
    @Autowired
    private IInviteService inviteService;
    @ResponseBody
    @PostMapping("/base/system/os")
    @ApiOperation(value = "运营数据", tags = {"运营统计"})
    public ResultUtil<OperationalDataVO> courseList(OSQuery query) throws ParseException {
        Date endTime = new Date();
        Date startTime = new Date();
        OperationalDataVO res = new OperationalDataVO();
        // 先查询用户总数、课程总数、动态总数
        int c1 = appUserService.selectList(new EntityWrapper<AppUser>()
                .ne("state", 3)
        .isNotNull("phone")).size();
        res.setUserCount(c1);
        int c2 = courseService.selectList(new EntityWrapper<Course>()
                .ne("state", 3)).size();
        res.setCourseCount(c2);
        int c3 = findService.selectList(new EntityWrapper<Find>()
                .eq("isDelete", 0)).size();
        res.setFindCount(c3);
        // 判断选择的是什么搜索类型
        LocalDateTime endDate = LocalDateTime.now().with(LocalTime.MAX);
        LocalDateTime startDate = LocalDateTime.now().with(LocalTime.MIN);
        switch (query.getType()){
            case 1:
                startDate = endDate.minusDays(7).with(LocalTime.MIN);
                break;
            case 2:
                startDate = endDate.minusDays(30).with(LocalTime.MIN);
                break;
            case 3:
                startDate = endDate.minusMonths(6).with(LocalTime.MIN);
                break;
            case 4:
                startDate = endDate.minusYears(1).with(LocalTime.MIN);
                break;
        }
         endTime = DateUtils.toDate(endDate);
         startTime = DateUtils.toDate(startDate);
        if (query.getType()==6){
            startTime = DateUtils.getDate_str4(query.getStartTime());
            endTime = DateUtils.getDate_str4(query.getEndTime());
            endTime.setHours(23);
            endTime.setMinutes(59);
            endTime.setSeconds(59);
        }
        // 查询提现金额
        EntityWrapper<Withdrawal> wrapper4 = new EntityWrapper<>();
        wrapper4.eq("payment",2);
        // 查询用户注册
        EntityWrapper<AppUser> wrapper5 = new EntityWrapper<>();
        wrapper5.ne("state",3);
        wrapper5.isNotNull("phone");
        // 查询平台销售额（购买课程 购买套餐 充值余额）
        EntityWrapper<Order> wrapper1 = new EntityWrapper<Order>();
        EntityWrapper<Order> wrapper7 = new EntityWrapper<Order>();
        EntityWrapper<OrderCourse> wrapper2 = new EntityWrapper<OrderCourse>();
        EntityWrapper<OrderCourse> wrapper8 = new EntityWrapper<OrderCourse>();
        wrapper1.ne("payType",3);
        wrapper1.eq("state",2);
        wrapper7.eq("state",2);
        wrapper8.eq("state",2);
        wrapper2.ne("payType",3);
        wrapper2.eq("state",2);
        EntityWrapper<Recharge> wrapper3 = new EntityWrapper<Recharge>();
        EntityWrapper<Invite> wrapper6 = new EntityWrapper<Invite>();
        wrapper6.eq("type",1);
        wrapper3.eq("state",2);
        if (query.getType() != 5) {
            wrapper7.ge("insertTime",startTime);
            wrapper8.ge("insertTime",startTime);
            wrapper1.ge("insertTime",startTime);
            wrapper2.ge("insertTime",startTime);
            wrapper3.ge("insertTime",startTime);
            wrapper4.ge("complete",startTime);
            wrapper5.ge("insertTime",startTime);
            wrapper6.ge("insertTime",startTime);
            wrapper1.le("insertTime",endTime);
            wrapper2.le("insertTime",endTime);
            wrapper3.le("insertTime",endTime);
            wrapper4.le("complete",endTime);
            wrapper5.le("insertTime",endTime);
            wrapper6.le("insertTime",endTime);
            wrapper7.le("insertTime",endTime);
            wrapper8.le("insertTime",endTime);
        }
        List<AppUser> users = appUserService.selectList(wrapper5);
        BigDecimal bigDecimal = orderService.selectList(wrapper1)
                .stream().map(Order::getRealMoney).reduce(BigDecimal::add).orElse(BigDecimal.ZERO);
        BigDecimal bigDecimal1 = orderCourseService.selectList(wrapper2)
                .stream().map(OrderCourse::getRealMoney).reduce(BigDecimal::add).orElse(BigDecimal.ZERO);
        BigDecimal bigDecimal2 = rechargeService.selectList(wrapper3)
                .stream().map(Recharge::getAmount).reduce(BigDecimal::add).orElse(BigDecimal.ZERO);
        BigDecimal add = bigDecimal.add(bigDecimal1);
        BigDecimal add1 = add.add(bigDecimal2);
        // 销售额
        res.setSaleCount(add1);
        // 查询提现金额
        BigDecimal payment = withdrawalService.selectList(wrapper4)
                .stream().map(Withdrawal::getAmount).reduce(BigDecimal::add).orElse(BigDecimal.ZERO);
        res.setWithdrawalCount(payment);
        BigDecimal subtract = add1.subtract(payment);
        res.setBalanceCount(subtract);
        // 一级邀请奖励
        BigDecimal bigDecimal5 = new BigDecimal("0");
        List<AppUser> appUsers = appUserService.selectList(new EntityWrapper<AppUser>()
                .ne("state", 3).isNotNull("phone"));
        for (AppUser appUser : appUsers) {
            bigDecimal5=bigDecimal5.add(appUser.getBalance());
        }
        res.setBalanceWithdrawalCount(bigDecimal5);
        // 购课量
        List<Integer> list1 = new ArrayList<>();
        // 购课金额
        List<BigDecimal> list2 = new ArrayList<>();
        // 用户量
        List<Integer> list3 = new ArrayList<>();
        // 购课数统计 先查询购买课程的数量
        List<OrderCourse> orderCourses = orderCourseService.selectList(wrapper8);
        // 购买套餐的数量 这个套餐有几个课程就算几次
        List<Order> orders = orderService.selectList(wrapper7);
        LocalDate currentDate = LocalDate.now();
        // 根据所选时间类型 设置y轴
        switch (query.getType()){
            case 1:
                // 获取当前日期
                Calendar calendar = Calendar.getInstance();
                calendar.setTime(new Date());
                // 初始化一个列表来存储最近七天的日期
                List<Date> recentDates = new ArrayList<>();
                // 循环生成最近七天的日期，并将其添加到列表中
                for (int i = 0; i < 7; i++) {
                    recentDates.add(calendar.getTime());
                    calendar.add(Calendar.DAY_OF_YEAR, -1); // 减去一天
                }
                List<String> strings = new ArrayList<>();
                SimpleDateFormat format1 = new SimpleDateFormat("dd");
                for (Date recentDate : recentDates) {
                    String format = format1.format(recentDate);

                    strings.add(format+"号");
                }
                Collections.reverse(strings);
                res.setTime(strings);
                for (int i = 0; i < 7; i++) {
                    list1.add(0);
                }
                for (int i = 0; i < 7; i++) {
                    list2.add(BigDecimal.ZERO);
                }
                for (int i = 0; i < 7; i++) {
                    list3.add(0);
                }
                for (OrderCourse orderCourse : orderCourses) {
                    // 获取订单的插入时间
                    Date insertTime = orderCourse.getInsertTime();
                    // 计算 insertTime 距离当前日期的天数差
                    long millisecondsDifference = currentDate.toEpochDay() - insertTime.toInstant().toEpochMilli() / (1000 * 3600 * 24);
                    int index = (int) millisecondsDifference;
                    if (index<7){
                        Integer integer = list1.get(index);
                        integer+=1;
                        list1.set(index,integer);
                        // 累加购课金额
                        BigDecimal realMoney = orderCourse.getRealMoney();
                        BigDecimal bigDecimal3 = list2.get(index);
                        BigDecimal add2 = bigDecimal3.add(realMoney);
                        list2.set(index,add2);
                    }

                }
                for (Order order : orders) {
                    // 获取订单的插入时间
                    Date insertTime = order.getInsertTime();
                    // 计算 insertTime 距离当前日期的天数差
                    long millisecondsDifference = currentDate.toEpochDay() - insertTime.toInstant().toEpochMilli() / (1000 * 3600 * 24);
                    // 如果 insertTime 在7天内，则放入对应位置的列表中
                    int index = (int) millisecondsDifference;
                    if (index<7){
                        Integer integer = list1.get(index);
                        integer+=1;
                        list1.set(index,integer);
                        // 累加购课金额
                        BigDecimal realMoney = order.getRealMoney();
                        BigDecimal bigDecimal3 = list2.get(index);
                        BigDecimal add2 = bigDecimal3.add(realMoney);
                        list2.set(index,add2);
                    }
                }
                for (AppUser user : users) {
                    // 获取订单的插入时间
                    Date insertTime = user.getInsertTime();
                    // 计算 insertTime 距离当前日期的天数差
                    long millisecondsDifference = currentDate.toEpochDay() - insertTime.toInstant().toEpochMilli() / (1000 * 3600 * 24);
                    int index = (int) millisecondsDifference;
                    if (index<7){
                        Integer integer = list3.get(index);
                        integer+=1;
                        list3.set(index,integer);
                    }
                }
                break;
            case 2:
                // 获取当前日期
                Calendar calendar1 = Calendar.getInstance();
                calendar1.setTime(new Date());
                // 初始化一个列表来存储最近七天的日期
                List<Date> recentDates1 = new ArrayList<>();
                // 循环生成最近七天的日期，并将其添加到列表中
                for (int i = 0; i < 30; i++) {
                    recentDates1.add(calendar1.getTime());
                    calendar1.add(Calendar.DAY_OF_YEAR, -1); // 减去一天
                }
                List<String> strings1 = new ArrayList<>();
                SimpleDateFormat format2 = new SimpleDateFormat("dd");
                for (Date recentDate : recentDates1) {
                    String format = format2.format(recentDate);
                    strings1.add(format+"号");
                }
                Collections.reverse(strings1);
                res.setTime(strings1);
                for (int i = 0; i < 30; i++) {
                    list1.add(0);
                }
                for (int i = 0; i < 30; i++) {
                    list2.add(BigDecimal.ZERO);
                }
                for (int i = 0; i < 30; i++) {
                    list3.add(0);
                }
                for (OrderCourse orderCourse : orderCourses) {
                    // 获取订单的插入时间
                    Date insertTime = orderCourse.getInsertTime();
                    // 计算 insertTime 距离当前日期的天数差
                    long millisecondsDifference = currentDate.toEpochDay() - insertTime.toInstant().toEpochMilli() / (1000 * 3600 * 24);
                    // 如果 insertTime 在7天内，则放入对应位置的列表中
                        int index = (int) millisecondsDifference;

                    if (index<30){
                        Integer integer = list1.get(index);
                        integer+=1;
                        list1.set(index,integer);
                        // 累加购课金额
                        BigDecimal realMoney = orderCourse.getRealMoney();
                        BigDecimal bigDecimal3 = list2.get(index);
                        BigDecimal add2 = bigDecimal3.add(realMoney);
                        list2.set(index,add2);
                    }
                }
                for (Order order : orders) {

                    // 获取订单的插入时间
                    Date insertTime = order.getInsertTime();
                    // 计算 insertTime 距离当前日期的天数差
                    long millisecondsDifference = currentDate.toEpochDay() - insertTime.toInstant().toEpochMilli() / (1000 * 3600 * 24);
                    // 如果 insertTime 在7天内，则放入对应位置的列表中
                    int index = (int) millisecondsDifference;
                    if (index<30){
                        Integer integer = list1.get(index);
                        integer+=1;
                        list1.set(index,integer);
                        // 累加购课金额
                        BigDecimal realMoney = order.getRealMoney();
                        BigDecimal bigDecimal3 = list2.get(index);
                        BigDecimal add2 = bigDecimal3.add(realMoney);
                        list2.set(index,add2);
                    }
                }
                for (AppUser user : users) {
                    // 获取订单的插入时间
                    Date insertTime = user.getInsertTime();
                    // 计算 insertTime 距离当前日期的天数差
                    long millisecondsDifference = currentDate.toEpochDay() - insertTime.toInstant().toEpochMilli() / (1000 * 3600 * 24);
                    int index = (int) millisecondsDifference;
                    if (index<30){
                        Integer integer = list3.get(index);
                        integer+=1;
                        list3.set(index,integer);
                    }
                }
                break;
            case 3:
                // 获取当前日期
                LocalDate currentDate1 = LocalDate.now();
                // 初始化一个列表来存储最近半年的日期的字符串表示
                List<String> recentDates2 = new ArrayList<>();
                // 设置日期格式化器
                DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM");
                // 循环生成最近半年的日期，并将其格式化为字符串，然后添加到列表中
                for (int i = 0; i < 6; i++) {
                    LocalDate date = currentDate1.minusMonths(i);
                    String formattedDate = date.format(formatter);
                    recentDates2.add(formattedDate+"月");
                }
                Collections.reverse(recentDates2);
                res.setTime(recentDates2);
                for (int i = 0; i < 6; i++) {
                    list1.add(0);
                }
                for (int i = 0; i < 6; i++) {
                    list2.add(BigDecimal.ZERO);
                }
                for (int i = 0; i < 6; i++) {
                    list3.add(0);
                }
                for (OrderCourse orderCourse : orderCourses) {
                    // 获取订单课程的插入日期，并转换为 LocalDate 类型
                    Date insertDate = orderCourse.getInsertTime();
                    LocalDate localInsertDate = insertDate.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
                    // 计算月份差距
                    int monthDifference = getMonthDifference(currentDate, localInsertDate);
                    if (monthDifference<7){
                        Integer integer = list1.get(monthDifference);
                        integer+=1;
                        list1.set(monthDifference,integer);

                        // 累加购课金额
                        BigDecimal realMoney = orderCourse.getRealMoney();
                        BigDecimal bigDecimal3 = list2.get(monthDifference);
                        BigDecimal add2 = bigDecimal3.add(realMoney);
                        list2.set(monthDifference,add2);
                    }

                    }
                for (Order order : orders) {

                    // 获取订单课程的插入日期，并转换为 LocalDate 类型
                    Date insertDate = order.getInsertTime();
                    LocalDate localInsertDate = insertDate.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
                    // 计算月份差距
                    int monthDifference = getMonthDifference(currentDate, localInsertDate);
                    if (monthDifference<7){
                        Integer integer = list1.get(monthDifference);
                        integer+=1;
                        list1.set(monthDifference,integer);
                        // 累加购课金额
                        BigDecimal realMoney = order.getRealMoney();
                        BigDecimal bigDecimal3 = list2.get(monthDifference);
                        BigDecimal add2 = bigDecimal3.add(realMoney);
                        list2.set(monthDifference,add2);
                    }

                }
                for (AppUser user : users) {
                    // 获取订单课程的插入日期，并转换为 LocalDate 类型
                    Date insertDate = user.getInsertTime();
                    LocalDate localInsertDate = insertDate.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
                    // 计算月份差距
                    int monthDifference = getMonthDifference(currentDate, localInsertDate);
                    if (monthDifference<7){
                        Integer integer = list3.get(monthDifference);
                        integer+=1;
                        list3.set(monthDifference,integer);
                    }

                }
                break;
            case 4:
                // 获取当前日期
                LocalDate currentDate7 = LocalDate.now();
                // 初始化一个列表来存储最近半年的日期的字符串表示
                List<String> recentDates7 = new ArrayList<>();
                // 设置日期格式化器
                DateTimeFormatter formatter7 = DateTimeFormatter.ofPattern("MM");
                // 循环生成最近半年的日期，并将其格式化为字符串，然后添加到列表中
                for (int i = 0; i < 12; i++) {
                    LocalDate date = currentDate7.minusMonths(i);
                    String formattedDate = date.format(formatter7);
                    recentDates7.add(formattedDate+"月");
                }
                Collections.reverse(recentDates7);
                res.setTime(recentDates7);

                for (int i = 0; i < 12; i++) {
                    list1.add(0);
                }
                for (int i = 0; i < 12; i++) {
                    list2.add(BigDecimal.ZERO);
                }
                for (int i = 0; i < 12; i++) {
                    list3.add(0);
                }
                for (OrderCourse orderCourse : orderCourses) {
                    // 获取订单课程的插入日期，并转换为 LocalDate 类型
                    Date insertDate = orderCourse.getInsertTime();
                    LocalDate localInsertDate = insertDate.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
                    // 计算月份差距
                    int monthDifference = getMonthDifference(currentDate, localInsertDate);
                    if (monthDifference<12){
                        Integer integer = list1.get(monthDifference);
                        integer+=1;
                        list1.set(monthDifference,integer);

                        // 累加购课金额
                        BigDecimal realMoney = orderCourse.getRealMoney();
                        BigDecimal bigDecimal3 = list2.get(monthDifference);
                        BigDecimal add2 = bigDecimal3.add(realMoney);
                        list2.set(monthDifference,add2);
                    }

                }
                for (Order order : orders) {

                    // 获取订单课程的插入日期，并转换为 LocalDate 类型
                    Date insertDate = order.getInsertTime();
                    LocalDate localInsertDate = insertDate.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
                    // 计算月份差距
                    int monthDifference = getMonthDifference(currentDate, localInsertDate);
                    if (monthDifference<12){
                        Integer integer = list1.get(monthDifference);
                        integer+=1;
                        list1.set(monthDifference,integer);
                        // 累加购课金额
                        BigDecimal realMoney = order.getRealMoney();
                        BigDecimal bigDecimal3 = list2.get(monthDifference);
                        BigDecimal add2 = bigDecimal3.add(realMoney);
                        list2.set(monthDifference,add2);
                    }

                }
                for (AppUser user : users) {
                    // 获取订单课程的插入日期，并转换为 LocalDate 类型
                    Date insertDate = user.getInsertTime();
                    LocalDate localInsertDate = insertDate.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
                    // 计算月份差距
                    int monthDifference = getMonthDifference(currentDate, localInsertDate);
                    if (monthDifference<12){
                        Integer integer = list3.get(monthDifference);
                        integer+=1;
                        list3.set(monthDifference,integer);
                    }
                }
                break;
            case 5:
                int size = orderCourses.size();
                list1.add(size+orders.size());
                BigDecimal bigDecimal7 = orderService.selectList(new EntityWrapper<Order>()
                .eq("state",2)).stream().map(Order::getRealMoney).reduce(BigDecimal::add).orElse(BigDecimal.ZERO);
                BigDecimal bigDecimal8 = orderCourseService.selectList(
                        new EntityWrapper<OrderCourse>().eq("state",2))
                        .stream().map(OrderCourse::getRealMoney).reduce(BigDecimal::add).orElse(BigDecimal.ZERO);
                BigDecimal add3 = bigDecimal7.add(bigDecimal8);
                list2.add(add3);
                List<AppUser> users1 = appUserService.selectList(new EntityWrapper<AppUser>()
                        .ne("state", 3)
                        .isNotNull("phone"));
                list3.add(users1.size());
                List<String> strings2 = new ArrayList<>();
                strings2.add("全部");
                res.setTime(strings2);
                break;
            case 6:
                SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                Date parse = format.parse(query.getEndTime());
                LocalDate localDate = parse.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
                // 将字符串解析为 LocalDate 对象
                DateTimeFormatter formatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
                // 解析字符串为 LocalDateTime 对象
                LocalDateTime localDateTime1 = LocalDateTime.parse(query.getStartTime(), formatter1);
                LocalDateTime localDateTime2 = LocalDateTime.parse(query.getEndTime(), formatter1);
                // 提取日期部分，并转换为 LocalDate 对象
                LocalDate s1 = localDateTime1.toLocalDate();
                LocalDate e1 = localDateTime2.toLocalDate();

                // 计算日期范围内的天数差
                long daysDifference = e1.toEpochDay() - s1.toEpochDay() + 1;
                // 初始化一个列表来存储日期字符串
                List<String> datesInRange = new ArrayList<>();
                // 设置日期格式化器
                DateTimeFormatter formatter8 = DateTimeFormatter.ofPattern("MM-dd");
                SimpleDateFormat format3 = new SimpleDateFormat("MM月dd号");

                // 循环生成日期范围内的日期，并将其格式化为字符串，然后添加到列表中
                for (int i = 0; i < daysDifference; i++) {
                    LocalDate date = s1.plusDays(i);
                    Date date1 = DateUtils.toDate(date);
                    String formattedDate = format3.format(date1);
                    datesInRange.add(formattedDate);
                }
                res.setTime(datesInRange);
                for (int i = 0; i < daysDifference; i++) {
                    list1.add(0);
                }
                for (int i = 0; i < daysDifference; i++) {
                    list2.add(BigDecimal.ZERO);
                }
                for (int i = 0; i < daysDifference; i++) {
                    list3.add(0);
                }
                for (OrderCourse orderCourse : orderCourses) {
                    // 获取订单的插入时间
                    Date insertTime = orderCourse.getInsertTime();
                    // 计算 insertTime 距离当前日期的天数差
                    long millisecondsDifference = localDate.toEpochDay() - insertTime.toInstant().toEpochMilli() / (1000 * 3600 * 24);
                    // 如果 insertTime 在7天内，则放入对应位置的列表中
                    int index = (int) millisecondsDifference;
                    if (index<daysDifference){
                        Integer integer = list1.get(index);
                        integer+=1;
                        list1.set(index,integer);
                        // 累加购课金额
                        BigDecimal realMoney = orderCourse.getRealMoney();
                        BigDecimal bigDecimal3 = list2.get(index);
                        BigDecimal add2 = bigDecimal3.add(realMoney);
                        list2.set(index,add2);
                    }

                }
                for (Order order : orders) {

                    // 获取订单的插入时间
                    Date insertTime = order.getInsertTime();
                    // 计算 insertTime 距离当前日期的天数差
                    long millisecondsDifference = localDate.toEpochDay() - insertTime.toInstant().toEpochMilli() / (1000 * 3600 * 24);
                    // 如果 insertTime 在7天内，则放入对应位置的列表中
                    int index = (int) millisecondsDifference;
                    if (index<daysDifference){
                        Integer integer = list1.get(index);
                        integer+=1;
                        list1.set(index,integer);
                        // 累加购课金额
                        BigDecimal realMoney = order.getRealMoney();
                        BigDecimal bigDecimal3 = list2.get(index);
                        BigDecimal add2 = bigDecimal3.add(realMoney);
                        list2.set(index,add2);
                    }

                }
                for (AppUser user : users) {
                    // 获取订单的插入时间
                    Date insertTime = user.getInsertTime();
                    // 计算 insertTime 距离当前日期的天数差
                    long millisecondsDifference = localDate.toEpochDay() - insertTime.toInstant().toEpochMilli() / (1000 * 3600 * 24);
                    // 如果 insertTime 在7天内，则放入对应位置的列表中
                    int index = (int) millisecondsDifference;
                    if (index<daysDifference){
                        Integer integer = list3.get(index);
                        integer+=1;
                        list3.set(index,integer);
                    }

                }
                break;
        }
        Collections.reverse(list1);
        Collections.reverse(list2);
        Collections.reverse(list3);
        res.setBuyCourse(list1);
        res.setBuyMoney(list2);
        res.setUserList(list3);


        if (query.getType() == 5){
            startTime =null;
            endTime =null;
        }
        // 查询用户提成统计
        List<CSVO> invites = inviteService.list(startTime,endTime);

//        PageHelper.startPage(query.getPageNum(),query.getPageSize());
        PageInfo<CSVO> info=new PageInfo<>(invites);
        res.setCommissionStatistics(info);
        return ResultUtil.success(res);
    }
    public static int getMonthDifference(LocalDate currentDate, LocalDate insertDate) {
        return Period.between(insertDate, currentDate).getMonths();
    }
    @ResponseBody
    @PostMapping("/base/sysnotice/update")
    @ApiOperation(value = "公告消息详情和编辑", tags = {"公告消息"})
    public ResultUtil<Protocol> courseList(String content) {
            Protocol type = protocolService.selectOne(new EntityWrapper<Protocol>()
                    .eq("type", 5));
            type.setContent(content);
            type.setInsertTime(new Date());
            protocolService.updateById(type);
            return ResultUtil.success(type);
    }
    @ResponseBody
    @PostMapping("/base/sysnotice/getInfo")
    @ApiOperation(value = "获取公告消息", tags = {"公告消息"})
    public ResultUtil<Protocol> courseList() {
            Protocol type = protocolService.selectOne(new EntityWrapper<Protocol>()
                    .eq("type", 5));
            return ResultUtil.success(type);
    }
    @ResponseBody
    @PostMapping("/base/order/orderList")
    @ApiOperation(value = "列表查询", tags = {"订单管理"})
    public ResultUtil<PageInfo<OrderListVO>> courseList(OrderQuery query) throws ParseException {
        if (query.getEndTime()!=null){
            query.getEndTime().setHours(23);
            query.getEndTime().setMinutes(59);
            query.getEndTime().setSeconds(59);

            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String format1 = format.format(query.getStartTime());
            String format2 = format.format(query.getEndTime());
            query.setEndTime1(format2);
            query.setStartTime1(format1);
            Date parse = format.parse(format1);
            Date parse1 = format.parse(format2);
            query.setStartTime(parse);
            query.setEndTime(parse1);
        }

        // 查询套餐
        List<OrderListVO> temp1= orderService.selectOrder(query);
        // 查询购课
        List<OrderListVO> temp2= orderCourseService.selectOrderCourse(query);
        temp1.addAll(temp2);
        List<OrderListVO> sortedList = temp1.stream()
                .sorted(Comparator.comparing(OrderListVO::getPayTime).reversed())
                .collect(Collectors.toList());
//        PageHelper.startPage(query.getPageNum(),query.getPageSize());
        PageInfo<OrderListVO> info=new PageInfo<>(sortedList);
        return ResultUtil.success(info);
    }

    @ResponseBody
    @PostMapping("/base/order/orderDetail")
    @ApiOperation(value = "查看详情", tags = {"订单管理"})
    @ApiImplicitParams({
            @ApiImplicitParam(value = "订单id", name = "id"),
            @ApiImplicitParam(value = "订单类型(列表查询里的type字段的值)", name = "type"),
    })
    public ResultUtil<OrderDetailVO> courseList(Integer id, Integer type) {
        OrderDetailVO orderDetailVO = new OrderDetailVO();
        if (type==1){
            // 购买课程
            OrderCourse orderCourse = orderCourseService.selectById(id);
            AppUser appUser = appUserService.selectById(orderCourse.getUserId());
            orderDetailVO.setUserName(appUser.getName());
            orderDetailVO.setPhone(appUser.getPhone());
            orderDetailVO.setPayTime(orderCourse.getPayTime());
            // 查询这笔订单有没有使用优惠券
            if (orderCourse.getCouponId()!=null){
                CouponReceive couponReceive = couponReceiveService.selectById(orderCourse.getCouponId());
                Coupon coupon = couponService.selectById(couponReceive.getCouponId());
                if (coupon!=null){
                    orderDetailVO.setCouponName(coupon.getCouponName());
                }
                // 原价
                BigDecimal amount = orderCourse.getAmount();
                // 实际支付价格
                BigDecimal realMoney = orderCourse.getRealMoney();
                orderDetailVO.setRealMoney(realMoney);
                orderDetailVO.setAmount(amount);
                BigDecimal subtract = amount.subtract(realMoney);
                orderDetailVO.setPreferential(""+subtract);
                // 计算优惠价格
            }else{
                orderDetailVO.setAmount(orderCourse.getAmount());
                orderDetailVO.setRealMoney(orderCourse.getRealMoney());
                // 没有使用优惠券
                orderDetailVO.setCouponName("无");
                orderDetailVO.setPreferential("无");
            }
            orderDetailVO.setPayType(orderCourse.getPayType());
            orderDetailVO.setPackageName("无");
            Integer courseId = orderCourse.getCourseId();
            Course course = courseService.selectById(courseId);
            Integer positionId = course.getPositionId();
            FitnessPosition fitnessPosition = fitnessPositionService.selectById(positionId);
            FitnessType fitnessType = fitnessTypeService.selectById(fitnessPosition.getTypeId());
            orderDetailVO.setPosition(fitnessType.getName()+"|"+fitnessPosition.getName());
        }else{
            // 购买的套餐
            Order order = orderService.selectById(id);
            AppUser appUser = appUserService.selectById(order.getUserId());
            orderDetailVO.setUserName(appUser.getName());
            orderDetailVO.setPhone(appUser.getPhone());
            orderDetailVO.setPayTime(order.getPayTime());
            // 查询这笔订单有没有使用优惠券
            if (order.getCouponId()!=null){
                Coupon coupon = couponService.selectById(order.getCouponId());
                if (coupon!=null){
                    orderDetailVO.setCouponName(coupon.getCouponName());
                }
                // 原价
                BigDecimal amount = order.getAmount();
                // 实际支付价格
                BigDecimal realMoney = order.getRealMoney();
                orderDetailVO.setRealMoney(realMoney);
                orderDetailVO.setAmount(amount);
                BigDecimal subtract = amount.subtract(realMoney);
                orderDetailVO.setPreferential(""+subtract);
                // 计算优惠价格
            }else{
                orderDetailVO.setAmount(order.getAmount());
                orderDetailVO.setRealMoney(order.getRealMoney());
                // 没有使用优惠券
                orderDetailVO.setCouponName("无");
                orderDetailVO.setPreferential("无");
            }
            orderDetailVO.setPayType(order.getPayType());
            Integer packageId = order.getPackageId();
            Package aPackage = packageService.selectById(packageId);
            orderDetailVO.setPackageName(aPackage.getName());
            // 查询套餐的购买部位
            String positions = aPackage.getPositions();
            // 套餐包含的部位名称
            StringBuilder temp = new StringBuilder("");
            // 套餐包含的部位ids
            for (String s : positions.split(",")) {
                Integer positionId = Integer.valueOf(s);
                FitnessPosition fitnessPosition = fitnessPositionService.selectById(positionId);
                FitnessType fitnessType = fitnessTypeService.selectById(fitnessPosition.getTypeId());
                temp.append(fitnessType.getName()+"|"+fitnessPosition.getName()+"、");
            }
            String s = temp.toString();
            String substring = s.substring(0, s.length() - 1);
            orderDetailVO.setPosition(substring+"。");
        }
        return ResultUtil.success(orderDetailVO);
    }

    public static void main(String[] args) {

            // 定义开始日期和结束日期的字符串
            String startTimeStr = "2024-11-11";
            String endTimeStr = "2024-11-30";

            // 将字符串解析为 LocalDate 对象
            LocalDate startTime = LocalDate.parse(startTimeStr);
            LocalDate endTime = LocalDate.parse(endTimeStr);

            // 计算日期范围内的天数差
            long daysDifference = endTime.toEpochDay() - startTime.toEpochDay() + 1;

            // 初始化一个列表来存储日期字符串
            List<String> datesInRange = new ArrayList<>();

            // 设置日期格式化器
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

            // 循环生成日期范围内的日期，并将其格式化为字符串，然后添加到列表中
            for (int i = 0; i < daysDifference; i++) {
                LocalDate date = startTime.plusDays(i);
                String formattedDate = date.format(formatter);
                datesInRange.add(formattedDate);
            }

            // 输出集合中的日期字符串
            for (String date : datesInRange) {
                System.out.println(date);
            }

            // 输出日期范围内的天数差
            System.out.println("日期范围内的天数差：" + daysDifference);
    }

}