package com.dsh.course.controller;


import cn.hutool.core.date.DateUtil;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.dsh.course.entity.*;
import com.dsh.course.entity.dto.*;
import com.dsh.course.feignclient.account.AppUserClient;
import com.dsh.course.feignclient.account.StudentClient;
import com.dsh.course.feignclient.account.model.Student;
import com.dsh.course.mapper.CoursePackageSchedulingMapper;
import com.dsh.course.mapper.CoursePackageStudentMapper;
import com.dsh.course.model.dto.ToClassDto;
import com.dsh.course.service.*;
import com.dsh.course.util.ResultUtil;
import com.dsh.course.util.UUIDUtil;
import io.swagger.annotations.Api;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang3.ArrayUtils;
import org.checkerframework.checker.units.qual.A;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.swing.text.html.parser.Entity;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.Period;
import java.time.ZoneId;
import java.util.*;
import java.util.stream.Collectors;

@Api
@CrossOrigin
@RestController
@RequestMapping("/courdent")
public class CourseStudentController {
    @Autowired
    CoursePackageStudentService studentService;
    @Autowired
    TCoursePackagePaymentService paymentService;
    @Autowired
    private CourseCounsumService counsumService;
    @Autowired
    private TCoursePackageService coursePackageService;
    @Resource
    private CoursePackageStudentMapper cpsMapper;

    //获取退费记录
    @RequestMapping("/getRefund")
    @ResponseBody
    public List<MoneyBack> getRefund() {
        // 查询已通过申请的退费记录
        return counsumService.getRefund();
    }


    @Resource
    private CoursePackageSchedulingMapper coursePackageSchedulingService;


    @RequestMapping("/getStudentTotal")
    @ResponseBody
    public List<Map<String, Object>> get(@RequestBody StudentQeryDto studentQeryDto) {
        System.out.println("-====studentQeryDto=========" + studentQeryDto);
        List<Map<String, Object>> pays = paymentService.getStudentTotal(studentQeryDto);
        System.out.println("=========pays======" + pays);

        return pays;

    }


    @RequestMapping("/bypac")
    @ResponseBody
    public List<Map<String, Object>> bypac(@RequestBody PacQueryDto pacQueryDto) {
        System.out.println("-====studentQeryDto=========" + pacQueryDto);
        if (pacQueryDto.getStoreIds() != null && pacQueryDto.getStoreIds().size() != 0) {
            // 根据门店id 查询课包ids
            List<Integer> coursePackageIds = coursePackageService.list(new QueryWrapper<TCoursePackage>()
                    .in("storeId", pacQueryDto.getStoreIds())).stream()
                    .map(TCoursePackage::getId).collect(Collectors.toList());
            pacQueryDto.setStoreIds(coursePackageIds);
        }
        List<Map<String, Object>> pays = paymentService.bypac(pacQueryDto);

        System.out.println("=========pays======" + pays);

        return pays;

    }

    @ResponseBody
    @PostMapping("/queryIdsByStore")
    public List<Integer> queryIdsByStore(@RequestBody Integer objectId) {
        List<TCoursePackage> list = packageService.list(new LambdaQueryWrapper<TCoursePackage>().eq(TCoursePackage::getStoreId, objectId));
        List<Integer> collect = list.stream().map(TCoursePackage::getId).collect(Collectors.toList());
        if (collect.size() == 0) {
            collect.add(-1);
        }
        return collect;
    }


    //获取学员课时数信息
    @RequestMapping("/getInfo")
    @ResponseBody
    public StudentClassInfo list(@RequestParam("tStudentId") Integer tStudentId){

//        System.out.println("------------>"+tStudentId);


        StudentClassInfo studentClassInfo = studentService.listAll(tStudentId);

//        Date maxDate = studentService.getMaxDate(tStudentId);
        Date minDate = studentService.getMinDate(tStudentId);
        Integer totalHours = studentClassInfo.getTotalHours();
        Integer hasHours = studentClassInfo.getRestHours();
        Integer restHours = totalHours - hasHours;
        studentClassInfo.setHasHours(restHours);
        studentClassInfo.setInDate(minDate);
        System.out.println("===========>" + studentClassInfo);

        return studentClassInfo;
    }

    //获取学员课程列表
    @RequestMapping("/getClassList")
    @ResponseBody
    public List<ClassListDto> listClass(@RequestParam("tStudentId") Integer tStudentId) {
        System.out.println("==========getClassList===tStudentId====" + tStudentId);
        List<ClassListDto> listDtos = studentService.getClassList(tStudentId);
        for (ClassListDto dto : listDtos) {
            dto.setHasClassHours(dto.getTotalClassHours() - dto.getLaveClassHours());
        }
        System.out.println("======listDtos======" + listDtos);
        return listDtos;

    }

    //获取学员有效期
    @RequestMapping("/getUseTime")
    @ResponseBody
    public Date getUseTime(@RequestParam("tStudentId") Integer tStudentId) {
        Date maxDate = studentService.getMaxDate(tStudentId);

        return maxDate;

    }

    //批量修改有效期
    @RequestMapping("/updateUseDate")
    @ResponseBody
    public void updateUseDate(@RequestBody updateTimeDto updateTimeDto) {
        System.out.println("=========updateUseDate=====>=" + updateTimeDto);
        List<TCoursePackagePayment> paymentList = paymentService.list(new QueryWrapper<TCoursePackagePayment>().eq("studentId", updateTimeDto.getTStudentId()));

        System.out.println("=========paymentList=====>=" + paymentList);

        for (TCoursePackagePayment payment : paymentList) {
//            payment.setUseTime(updateTimeDto.getDate());
            paymentService.updateUseTime(payment.getId(), updateTimeDto.getDate());
        }
        System.out.println("=======updateUseDate=======>" + paymentList);


    }

    @Resource
    private AppUserClient appUserClient;


    @Autowired
    private ICoursePackageOrderStudentService orderStudentService;
    //获取可转移学员
    @RequestMapping("/getSelect")
    @ResponseBody
    public List<SelectDto> getSelect(@RequestParam("payId") Long payId) {

//        TCoursePackagePayment byId = paymentService.getById(payId);
//
//        List<Integer> studentIds = paymentService.getStudentIds(payId, byId.getCoursePackageId(), byId.getAppUserId());
//        System.out.println("=========studentIds=================>" + studentIds);

        CoursePackageOrderStudent coursePackageOrderStudent = orderStudentService.getById(payId);


        List<CoursePackageOrderStudent> orderStudent = orderStudentService.list(new QueryWrapper<CoursePackageOrderStudent>().eq("appUserId", coursePackageOrderStudent.getAppUserId()).eq("coursePackageId", coursePackageOrderStudent.getCoursePackageId()).ne("id",payId));

        List<Integer> studentIds = new ArrayList<>();
        for (CoursePackageOrderStudent packageOrderStudent : orderStudent) {
            studentIds.add(packageOrderStudent.getStudentId());
        }


        if (studentIds.size() > 0) {
            List<SelectDto> selectDtos = appUserClient.getSelects(studentIds);

            return selectDtos;
        } else return null;
    }


    //根据payid获取对应门店的常规课程

    @Autowired
    private TCoursePackageService packageService;

    @RequestMapping("/holiSelect")
    @ResponseBody
    public List<SelectDto> getHoliSelect(@RequestParam("courseId") Integer id) {

        TCoursePackage byId = packageService.getById(id);
        Integer storeId = byId.getStoreId();
        List<TCoursePackage> list = packageService.list(new QueryWrapper<TCoursePackage>()
                .select("id", "name")
                .eq("storeId", storeId)
                .eq("type", "2")
        );
        List<SelectDto> selectDtos = new ArrayList<>();
        for (TCoursePackage t : list) {
            SelectDto selectDto = new SelectDto();
            selectDto.setId(t.getId());
            selectDto.setValue(t.getName());
            selectDtos.add(selectDto);
        }


        return selectDtos;
    }

    @RequestMapping("/transSelect")
    @ResponseBody
    public List<SelectDto> getTransSelect(@RequestParam("courseId") Integer id) {

        TCoursePackage byId = packageService.getById(id);
        Integer storeId = byId.getStoreId();
        List<TCoursePackage> list = packageService.list(new QueryWrapper<TCoursePackage>()
                .select("id", "name")
                .eq("storeId", storeId)
                .eq("type", "1").ne("id", id)
        );
        List<SelectDto> selectDtos = new ArrayList<>();
        for (TCoursePackage t : list) {
            SelectDto selectDto = new SelectDto();
            selectDto.setId(t.getId());
            selectDto.setValue(t.getName());
            selectDtos.add(selectDto);
        }


        return selectDtos;
    }


    @RequestMapping("/queryCounsum")
    @ResponseBody
    public List<CourseCounsum> queryCounsum(@RequestBody ConsumeQuery consumeQuery) {
        System.out.println("======queryCounsum===========" + consumeQuery);

        QueryWrapper<CourseCounsum> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("paymentId", consumeQuery.getPayId());


        if (consumeQuery.getChangeType() != null) {
            queryWrapper.eq("changeType", consumeQuery.getChangeType());
        }
        if (consumeQuery.getStart() != null) {
            queryWrapper.between("insertTime", consumeQuery.getStart(), consumeQuery.getEnd());
        }
        if (consumeQuery.getReason() != null && consumeQuery.getReason() != "") {
            queryWrapper.like("reason", consumeQuery.getReason());

        }
        List<CourseCounsum> list = counsumService.list(queryWrapper);
//        List<CourseCounsum> list = counsumService.list(new QueryWrapper<CourseCounsum>().eq("paymentId", consumeQuery.getPayId()).eq("changeType", consumeQuery.getChangeType()).between("insertTime", consumeQuery.getStart(), consumeQuery.getEnd()).like("reason", consumeQuery.getReason()));
        return list;
    }




    @RequestMapping("/insertBack")
    @ResponseBody
    public void insertBack(@RequestBody InsertBackDto insertBackDto) {

        MoneyBack moneyBack = new MoneyBack();
        moneyBack.setStudentId(insertBackDto.getId());
        moneyBack.setStatus(0);
        moneyBack.setInsertTime(new Date());
        moneyBack.setIds(insertBackDto.getIds());
        moneyBackService.save(moneyBack);

//        List<TCoursePackagePayment> pays = paymentService.list(new QueryWrapper<TCoursePackagePayment>().in("id", insertBackDto.getIds()));


        List<CoursePackageOrderStudent> pays = orderStudentService.list(new QueryWrapper<CoursePackageOrderStudent>().in("id", insertBackDto.getIds()));
        for (CoursePackageOrderStudent o : pays) {
            o.setStatus(4);
            o.setAppUserId(null);
        }

        orderStudentService.updateBatchById(pays);
    }


    @RequestMapping("/queryByIds")
    @ResponseBody
    public List<TCoursePackagePayment> queryByIds(@RequestParam("ids") String ids) {
        List<TCoursePackagePayment> paymentList = paymentService.list(new QueryWrapper<TCoursePackagePayment>()
                .in("id", Arrays.asList(ids.split(","))));

        System.out.println("========client==>" + paymentList);
        return paymentList;
    }

    @RequestMapping("/changeStatus")
    @ResponseBody
    public void changeStatus(@RequestParam("id") Integer id) {
        MoneyBack byId = moneyBackService.getById(id);
        byId.setStatus(1);
        moneyBackService.updateById(byId);

    }

    @RequestMapping("/noStatus")
    @ResponseBody
    public void noStatus(@RequestParam("id") Integer id) {
        MoneyBack byId = moneyBackService.getById(id);
        byId.setStatus(2);
        moneyBackService.updateById(byId);

        List<CoursePackageOrderStudent> pays = orderStudentService.list(new QueryWrapper<CoursePackageOrderStudent>().in("id", byId.getIds()));
        for (CoursePackageOrderStudent o : pays) {
            o.setStatus(1);
            o.setAppUserId(null);
        }
        orderStudentService.updateBatchById(pays);

    }

    @RequestMapping("/zeroClass")
    @ResponseBody
    public void zeroClass(@RequestParam("id") Integer id) {
        MoneyBack byId = moneyBackService.getById(id);
        String[] split2 = byId.getIds().split(",");
        System.out.println("========split===>" + split2);
        List<TCoursePackagePayment> id1 = paymentService.list(new QueryWrapper<TCoursePackagePayment>().in("id", split2));
        for (TCoursePackagePayment o : id1) {
            CourseCounsum courseCounsum = new CourseCounsum();
            courseCounsum.setNum(o.getLaveClassHours());
            courseCounsum.setChangeType(0);
            courseCounsum.setReason("退费");
            courseCounsum.setPaymentId(o.getId());
            courseCounsum.setInsertTime(new Date());
            counsumService.save(courseCounsum);

            o.setTotalClassHours(0);
            o.setLaveClassHours(0);
            o.setStatus(2);
            o.setAppUserId(null);


            TCoursePackage tCoursePackage = packageService.getById(o.getCoursePackageId());
            String classWeeks = tCoursePackage.getClassWeeks();
            List<Integer> week = week(classWeeks);

            String[] split = tCoursePackage.getClassStartTime().split(",");
            String[] split1 = tCoursePackage.getClassEndTime().split(",");
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
            SimpleDateFormat format1 = new SimpleDateFormat("yyyy-MM-dd HH:mm");
            // 本周周几

            List<CoursePackageStudent> studentCourse = coursePackageStudentService.list(new QueryWrapper<CoursePackageStudent>().eq("studentId", o.getStudentId()).eq("coursePackageId", o.getCoursePackageId()));
            List<Long> collect = studentCourse.stream().map(CoursePackageStudent::getCoursePackageSchedulingId).collect(Collectors.toList());
            //拿到最后一天的排课记录
            if (collect.size() > 0) {
                coursePackageSchedulingService.delete(new QueryWrapper<CoursePackageScheduling>().in("id", collect));
                coursePackageStudentService.remove(new QueryWrapper<CoursePackageStudent>().eq("studentId", o.getStudentId()).eq("coursePackageId", o.getCoursePackageId()));
            }


        }
        paymentService.updateBatchById(id1);
    }


    @RequestMapping("/backStausClass")
    @ResponseBody
    public void backStausClass(@RequestParam("id") Integer id) {
        MoneyBack byId = moneyBackService.getById(id);
        String[] split = byId.getIds().split(",");
        System.out.println("========split===>" + split);
        List<TCoursePackagePayment> id1 = paymentService.list(new QueryWrapper<TCoursePackagePayment>().in("id", split));
        for (TCoursePackagePayment o : id1) {
            o.setStatus(1);
            o.setAppUserId(null);
        }
        paymentService.updateBatchById(id1);
    }

    @RequestMapping("/cancel")
    @ResponseBody
    public void cancel(@RequestParam("ids") String ids) {
        String[] split = ids.split(",");
        List<CoursePackageStudent> coursePackagePaymentId = studentService.list(new QueryWrapper<CoursePackageStudent>().in("coursePackagePaymentId", split));
        for (CoursePackageStudent student : coursePackagePaymentId) {
            student.setReservationStatus(3);
            student.setAppUserId(null);
        }
        studentService.updateBatchById(coursePackagePaymentId);


    }

    @Autowired
    private MoneyBackService moneyBackService;

    @RequestMapping("/getMoneyBack")
    @ResponseBody
    public List<MoneyBack> getMoneyBack(@RequestParam("tStudentId") Integer tStudentId) {

        List<MoneyBack> moneyBacksck = moneyBackService.list(new QueryWrapper<MoneyBack>().eq("studentId", tStudentId));
        return moneyBacksck;
    }



    @Autowired
    private ICoursePackageSchedulingService schedulingService;

    //课程转移
    @RequestMapping("/toClass")
    @ResponseBody
    public void toClass(@RequestBody ToClassDto toClassDto) throws ParseException {
        CoursePackageOrderStudent orinPay = orderStudentService.getById(toClassDto.getId());
        CoursePackageOrderStudent studentPay = orderStudentService.getOne(new QueryWrapper<CoursePackageOrderStudent>()
                .eq("studentId", toClassDto.getToStudentId())
                .eq("coursePackageId", orinPay.getCoursePackageId()));
        TCoursePackage coursePackage = packageService.getById(orinPay.getCoursePackageId());
        if (studentPay != null) {
            //转移
            Integer laveClassHours = orinPay.getLaveClassHours();
            Integer totalClassHours = orinPay.getTotalClassHours();

            CourseCounsum courseCounsum = new CourseCounsum();
            courseCounsum.setInsertTime(new Date());
            Integer appUserId = orinPay.getAppUserId();
            Integer appUserId1 = studentPay.getAppUserId();
            if (appUserId.compareTo(appUserId1) != 0) {
                courseCounsum.setReason("课时赠送");
            } else {
                courseCounsum.setReason("课时转移");
            }

            orinPay.setLaveClassHours(0);
            orinPay.setStatus(5);
            orinPay.setAppUserId(null);
            orderStudentService.updateById(orinPay);

            courseCounsum.setNum(laveClassHours);
            courseCounsum.setChangeType(0);
            courseCounsum.setPaymentId(orinPay.getId());
            counsumService.save(courseCounsum);

            CourseCounsum courseCounsum1 = new CourseCounsum();
            courseCounsum1.setInsertTime(new Date());
            if (appUserId.compareTo(appUserId1) != 0) {
                courseCounsum1.setReason("课时赠送");
            } else {
                courseCounsum1.setReason("课时转移");
            }
            courseCounsum1.setNum(laveClassHours);
            courseCounsum1.setChangeType(1);
            courseCounsum1.setPaymentId(studentPay.getId());
            counsumService.save(courseCounsum1);

            schedulingService.addNewCoursePackageScheduling(studentPay.getId(), laveClassHours);
            //删除原排课数据
            List<CoursePackageScheduling> coursePackageSchedulings = coursePackageSchedulingService.selectList(new QueryWrapper<CoursePackageScheduling>()
                    .eq("type", 1).eq("appUserId", appUserId)
                    .eq("studentId", orinPay.getStudentId()).eq("coursePackageId", orinPay.getCoursePackageId())
                    .orderByAsc("classDate"));
            int num = totalClassHours - laveClassHours;
            for (int i = num; i < coursePackageSchedulings.size(); i++) {
                CoursePackageScheduling packageScheduling = coursePackageSchedulings.get(i);
                coursePackageSchedulingService.deleteById(packageScheduling.getId());
                coursePackageStudentService.remove(new QueryWrapper<CoursePackageStudent>().eq("coursePackageSchedulingId", packageScheduling.getId()));
            }
        } else {

            Integer totalClassHours = orinPay.getTotalClassHours();
            Integer laveClassHours = orinPay.getLaveClassHours();
            Student student = studentClient.queryStudentById(toClassDto.getToStudentId());
            CoursePackageOrderStudent to = new CoursePackageOrderStudent();
            to.setStudentId(toClassDto.getToStudentId());
            to.setTotalClassHours(laveClassHours);
            to.setLaveClassHours(laveClassHours);
            to.setCoursePackageId(orinPay.getCoursePackageId());
            to.setState(1);
            to.setAppUserId(student.getAppUserId());
            to.setStatus(1);
            to.setInsertTime(new Date());

            Integer validDays = coursePackage.getValidDays();
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(new Date());
            calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) + validDays);
            to.setUseTime(calendar.getTime());
            orderStudentService.save(to);

            Integer appUserId = orinPay.getAppUserId();
            orinPay.setLaveClassHours(0);
            orinPay.setAppUserId(null);
            orinPay.setStatus(6);
            orderStudentService.updateById(orinPay);


            CourseCounsum courseCounsum = new CourseCounsum();
            courseCounsum.setInsertTime(new Date());
            courseCounsum.setReason("课时赠送");
            courseCounsum.setNum(orinPay.getLaveClassHours());
            courseCounsum.setChangeType(0);
            courseCounsum.setPaymentId(orinPay.getId());
            counsumService.save(courseCounsum);


            CourseCounsum courseCounsum1 = new CourseCounsum();
            courseCounsum1.setInsertTime(new Date());
            courseCounsum1.setReason("课时赠送");
            courseCounsum1.setNum(orinPay.getLaveClassHours());
            courseCounsum1.setChangeType(1);
            courseCounsum1.setPaymentId(to.getId());
            counsumService.save(courseCounsum1);

            //开始排课
             addPackageStudent(coursePackage, to.getAppUserId(), to.getStudentId(), to);
            //删除原排课数据
            List<CoursePackageScheduling> coursePackageSchedulings = coursePackageSchedulingService.selectList(new QueryWrapper<CoursePackageScheduling>()
                    .eq("type", 1).eq("appUserId", appUserId)
                    .eq("studentId", orinPay.getStudentId()).eq("coursePackageId", orinPay.getCoursePackageId())
                    .orderByAsc("classDate"));
            int num = totalClassHours - laveClassHours;
            for (int i = num; i < coursePackageSchedulings.size(); i++) {
                CoursePackageScheduling packageScheduling = coursePackageSchedulings.get(i);
                coursePackageSchedulingService.deleteById(packageScheduling.getId());
                coursePackageStudentService.remove(new QueryWrapper<CoursePackageStudent>().eq("coursePackageSchedulingId", packageScheduling.getId()));
            }
        }
    }



    /**
     * 新购买课程后的排课
     *
     * @param userId
     * @param sId
     * @throws ParseException
     */
    private void addPackageStudent(TCoursePackage tCoursePackage, Integer userId, Integer sId, CoursePackageOrderStudent coursePackageOrderStudent) {
        try {
            //1常规 2假期 3体验
            if (tCoursePackage.getType() == 1) {
                //上课星期
                String classWeeks = tCoursePackage.getClassWeeks();
                List<Integer> week = week(classWeeks);
                //上课时段
                String[] split = tCoursePackage.getClassStartTime().split(",");
                String[] split1 = tCoursePackage.getClassEndTime().split(",");
                SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
                SimpleDateFormat format1 = new SimpleDateFormat("yyyy-MM-dd HH:mm");


                //剩余课时
                Integer laveClassHours = coursePackageOrderStudent.getLaveClassHours();
                //扣除课时数
                Integer codeTime = tCoursePackage.getCodeTime();
                //排课 本周+下周，课时不够扣则直接剩余不排课
                Calendar calendar = Calendar.getInstance();
                calendar.setTime(new Date());
                calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) + 1);
                calendar.set(Calendar.HOUR_OF_DAY, 0);
                calendar.set(Calendar.MINUTE, 0);
                calendar.set(Calendar.SECOND, 0);
                int day_week = calendar.get(Calendar.DAY_OF_WEEK);
                day_week = day_week - 1 == 0 ? 7 : day_week - 1;
                int num = 8 - day_week + 7;
                Date useTime = coursePackageOrderStudent.getUseTime();

                for (int i = 0; i < num; i++) {
                    Date time = calendar.getTime();

                    //判断当天是否在排课星期内
                    int day = calendar.get(Calendar.DAY_OF_WEEK);
                    day = day - 1 == 0 ? 7 : day - 1;
                    if (!week.contains(day)) {
                        calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) + 1);
                        continue;
                    }


                    //大于有效期不进行排课
                    if (calendar.getTimeInMillis() >= useTime.getTime()) {
                        break;
                    }
                    for (int j = 0; j < split.length; j++) {
                        //剩余数量不足以排课
                        if (laveClassHours.compareTo(codeTime) < 0) {
                            break;
                        }

                        laveClassHours -= codeTime;

                        CoursePackageScheduling coursePackageScheduling = new CoursePackageScheduling();
                        coursePackageScheduling.setType(tCoursePackage.getType());
                        coursePackageScheduling.setAppUserId(userId);
                        coursePackageScheduling.setStudentId(sId);
                        coursePackageScheduling.setCoursePackageId(tCoursePackage.getId());
                        Date parse = format1.parse(format.format(time) + " " + split[j]);
                        Date parse1 = format1.parse(format.format(time) + " " + split1[j]);
                        coursePackageScheduling.setClassDate(parse);
                        coursePackageScheduling.setEndDate(parse1);
                        coursePackageScheduling.setStatus(1);
                        coursePackageSchedulingService.insert(coursePackageScheduling);
                        CoursePackageStudent student1 = new CoursePackageStudent();
                        student1.setAppUserId(userId);
                        student1.setStudentId(sId);
                        student1.setCoursePackageId(tCoursePackage.getId());
                        student1.setCoursePackagePaymentId(coursePackageOrderStudent.getId());
                        student1.setCoursePackageSchedulingId(coursePackageScheduling.getId());
                        student1.setSignInOrNot(1);
                        student1.setReservationStatus(1);
                        student1.setInsertTime(new Date());
                        cpsMapper.insert(student1);
                    }
                    //增加日期，用于判断
                    calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) + 1);
                }
            }

            if (tCoursePackage.getType() == 2) {
                //上课星期
                String classWeeks = tCoursePackage.getClassWeeks();
                List<Integer> week = week(classWeeks);
                //上课时段
                String[] split = tCoursePackage.getClassStartTime().split(",");
                String[] split1 = tCoursePackage.getClassEndTime().split(",");
                SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
                SimpleDateFormat format1 = new SimpleDateFormat("yyyy-MM-dd HH:mm");

                Date startTime = tCoursePackage.getStartTime();
                Date endTime = tCoursePackage.getEndTime();
                //排课 本周+下周，课时不够扣则直接剩余不排课
                Calendar calendar = Calendar.getInstance();
                //假期开始使用当前时间为起始时间进行排课
                calendar.setTime(startTime.getTime() > System.currentTimeMillis() ? startTime : new Date());
                calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) + 1);
                while (true) {
                    Date time = calendar.getTime();

                    //判断当天是否在排课星期内
                    int day = calendar.get(Calendar.DAY_OF_WEEK);
                    day = day - 1 == 0 ? 7 : day - 1;
                    if (!week.contains(day)) {
                        calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) + 1);
                        continue;
                    }

                    //大于有效期不进行排课
                    if (calendar.getTimeInMillis() > endTime.getTime()) {
                        break;
                    }
                    for (int j = 0; j < split.length; j++) {
                        CoursePackageScheduling coursePackageScheduling = new CoursePackageScheduling();
                        coursePackageScheduling.setType(tCoursePackage.getType());
                        coursePackageScheduling.setAppUserId(userId);
                        coursePackageScheduling.setStudentId(sId);
                        coursePackageScheduling.setCoursePackageId(tCoursePackage.getId());
                        Date parse = format1.parse(format.format(time) + " " + split[j]);
                        Date parse1 = format1.parse(format.format(time) + " " + split1[j]);
                        coursePackageScheduling.setClassDate(parse);
                        coursePackageScheduling.setEndDate(parse1);
                        coursePackageScheduling.setStatus(1);
                        coursePackageSchedulingService.insert(coursePackageScheduling);
                        CoursePackageStudent student1 = new CoursePackageStudent();
                        student1.setAppUserId(userId);
                        student1.setStudentId(sId);
                        student1.setCoursePackageId(tCoursePackage.getId());
                        student1.setCoursePackagePaymentId(null);
                        student1.setCoursePackageSchedulingId(coursePackageScheduling.getId());
                        student1.setSignInOrNot(1);
                        student1.setReservationStatus(1);
                        student1.setInsertTime(new Date());
                        cpsMapper.insert(student1);
                    }
                    //增加日期，用于判断
                    calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) + 1);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Resource
    private StudentClient studentClient;
    @Autowired
    private CourseCounsumService courseCounsumService;

    @RequestMapping(value = "/toHoli", produces = MediaType.APPLICATION_JSON_UTF8_VALUE, consumes = "application/json;charset=UTF-8")
    @ResponseBody
    public String toHoli(@RequestBody ToHoliDto toHoliDto) throws ParseException {

        String[] ids = toHoliDto.getIds();
        List<String> strings = new ArrayList<>();


        for (String id : ids) {
            //扣除课时
            TCoursePackagePayment payment = paymentService.getById(id);
            System.out.println("=====byId=========" + payment);


            Integer laveClassHours = payment.getLaveClassHours();

            Integer classNum = toHoliDto.getClassNum();
            Integer totalClassHours = payment.getTotalClassHours();
            Student student = studentClient.queryStudentById(payment.getStudentId());

            if (laveClassHours < classNum) {
                strings.add(student.getName());
                continue;
            }

            Integer laveClassHoursnew = laveClassHours - classNum;
            Integer totalClassHoursnew = totalClassHours - classNum;
            payment.setLaveClassHours(laveClassHoursnew);
            payment.setTotalClassHours(totalClassHoursnew);
            payment.setAppUserId(null);
//            payment.setStatus(3);

            paymentService.updateById(payment);

            //获取student信息

            //新增课时

            TCoursePackagePayment holi = new TCoursePackagePayment();
            holi.setAppUserId(student.getAppUserId());
            holi.setStudentId(student.getId());
            holi.setCoursePackageId(toHoliDto.getClassId());
            holi.setTotalClassHours(toHoliDto.getClassNum());
            holi.setLaveClassHours(toHoliDto.getClassNum());
            holi.setState(1);
            holi.setInsertTime(new Date());
            holi.setPayStatus(2);
            paymentService.save(holi);


            CourseCounsum courseCounsum = new CourseCounsum();
            courseCounsum.setPaymentId(holi.getId());
            courseCounsum.setChangeType(0);
            courseCounsum.setNum(classNum);
            courseCounsum.setInsertTime(new Date());
            courseCounsum.setReason("报名假期班");
            courseCounsumService.save(courseCounsum);

            //排假期课

            TCoursePackage tCoursePackage = packageService.getById(toHoliDto.getClassId());
            String classWeeks = tCoursePackage.getClassWeeks();
            List<Integer> week = week(classWeeks);

            Date today = new Date();

            Date startTime = tCoursePackage.getStartTime();
            Date endTime = tCoursePackage.getEndTime();
            LocalDate startDate = startTime.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
            LocalDate endDate = endTime.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
            Period period = Period.between(startDate, endDate);
            int days = period.getDays() + 1;
            Integer can = 999;
            int count = 0;
            String[] split = tCoursePackage.getClassStartTime().split(",");
            String[] split1 = tCoursePackage.getClassEndTime().split(",");
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
            SimpleDateFormat format1 = new SimpleDateFormat("yyyy-MM-dd HH:mm");

            Calendar calendar = Calendar.getInstance();
            calendar.setTime(startTime);
            calendar.add(Calendar.DAY_OF_MONTH, -1);

            Date[] dates = generateDateArray(days, calendar.getTime());
            for (Date date : dates) {
                if (count == can) {
                    break;
                }
                int wei = cn.hutool.core.date.DateUtil.dayOfWeek(date) - 1;
                if (wei == 0) {
                    wei = 7;
                }
                if (week.contains(wei)) {
                    for (int i1 = 0; i1 < split.length; i1++) {
                        if (count == can) {
                            break;
                        }
                        CoursePackageScheduling coursePackageScheduling = new CoursePackageScheduling();
                        coursePackageScheduling.setCoursePackageId(tCoursePackage.getId());
                        Date parse = format1.parse(format.format(date) + " " + split[i1]);
                        Date parse1 = format1.parse(format.format(date) + " " + split1[i1]);
                        coursePackageScheduling.setClassDate(parse);
                        coursePackageScheduling.setEndDate(parse1);
                        coursePackageScheduling.setStatus(1);
                        coursePackageSchedulingService.insert(coursePackageScheduling);
                        CoursePackageStudent student1 = new CoursePackageStudent();
                        student1.setAppUserId(student.getAppUserId());
                        student1.setStudentId(student.getId());
                        student1.setCoursePackageId(toHoliDto.getClassId());
                        student1.setCoursePackagePaymentId(holi.getId());
                        student1.setCoursePackageSchedulingId(coursePackageScheduling.getId());
                        student1.setSignInOrNot(1);
                        student1.setReservationStatus(1);
                        student1.setInsertTime(new Date());
                        studentService.save(student1);
                        count++;
                    }
                }
            }


            System.out.println("保存成功=============》=" + holi);


        }
        String[] stringArray = strings.toArray(new String[strings.size()]);

        String join = StringUtils.join(stringArray, ",");
        System.out.println("==========join========" + join);
        return join;


    }


    @Autowired
    private TCoursePackagePaymentService coursePackagePaymentService;

    public static Date[] generateDateArray(int numDays, Date date) {
//        LocalDate tomorrow = LocalDate.now().plusDays(1);
        LocalDate tomorrow = date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate().plusDays(1);

        Date[] dates = new Date[numDays];

        for (int i = 0; i < numDays; i++) {
            LocalDate currentDate = tomorrow.plusDays(i);
            dates[i] = Date.from(currentDate.atStartOfDay(ZoneId.systemDefault()).toInstant());
        }

        return dates;
    }

    private List<Integer> week(String week) {
        String[] split = week.split(";");
        ArrayList<Integer> integers = new ArrayList<>();
        for (String s : split) {
            switch (s) {
                case "周一":
                    integers.add(1);
                    break;
                case "周二":
                    integers.add(2);
                    break;
                case "周三":
                    integers.add(3);
                    break;
                case "周四":
                    integers.add(4);
                    break;
                case "周五":
                    integers.add(5);
                    break;
                case "周六":
                    integers.add(6);
                    break;
                case "周日":
                    integers.add(7);
                    break;
            }
        }
        return integers;
    }


    @Autowired
    private CoursePackageStudentService coursePackageStudentService;

    @RequestMapping(value = "/toTrans", produces = MediaType.APPLICATION_JSON_UTF8_VALUE, consumes = "application/json;charset=UTF-8")
    @ResponseBody
    public String toTrans(@RequestBody ToHoliDto toHoliDto) throws ParseException {

        String[] ids = toHoliDto.getIds();
        List<String> strings = new ArrayList<>();


        for (String id : ids) {
            //扣除课时
            TCoursePackagePayment payment = paymentService.getById(id);
            System.out.println("=====byId=========" + payment);


            Integer laveClassHours = payment.getLaveClassHours();

            Integer classNum = toHoliDto.getClassNum();
            Integer totalClassHours = payment.getTotalClassHours();
            Student student = studentClient.queryStudentById(payment.getStudentId());

//            if (laveClassHours < classNum){
//                strings.add(student.getName()); continue;
//            }
//
//            Integer laveClassHoursnew = laveClassHours - classNum;
//            Integer totalClassHoursnew = totalClassHours - classNum;
            payment.setLaveClassHours(0);
            payment.setTotalClassHours(0);
            payment.setAppUserId(null);

            paymentService.updateById(payment);

            //获取student信息

            //新增课时

            TCoursePackagePayment one = paymentService.getOne(new QueryWrapper<TCoursePackagePayment>().eq("studentId", student.getId()).eq("coursePackageId", toHoliDto.getClassId()));

            TCoursePackagePayment holi = new TCoursePackagePayment();
            if (one == null) {
                holi.setAppUserId(student.getAppUserId());
                holi.setStudentId(student.getId());
                holi.setCoursePackageId(toHoliDto.getClassId());
                holi.setTotalClassHours(laveClassHours);
                holi.setLaveClassHours(laveClassHours);
                holi.setState(1);
                holi.setInsertTime(new Date());
                holi.setPayStatus(2);
                holi.setStatus(1);
                paymentService.save(holi);

            } else {
                one.setTotalClassHours(one.getTotalClassHours() + laveClassHours);
                one.setLaveClassHours(one.getLaveClassHours() + laveClassHours);
                one.setAppUserId(null);
                paymentService.updateById(one);
                holi = one;
            }
            System.out.println("保存成功=============》=" + holi);


            CourseCounsum courseCounsum = new CourseCounsum();
            courseCounsum.setPaymentId(holi.getId());
            courseCounsum.setChangeType(1);
            courseCounsum.setNum(laveClassHours);
            courseCounsum.setInsertTime(new Date());
            courseCounsum.setReason("换课");
            courseCounsumService.save(courseCounsum);


            TCoursePackage tCoursePackage = packageService.getById(toHoliDto.getClassId());
            String classWeeks = tCoursePackage.getClassWeeks();
            List<Integer> week = week(classWeeks);

            String[] split = tCoursePackage.getClassStartTime().split(",");
            String[] split1 = tCoursePackage.getClassEndTime().split(",");
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
            SimpleDateFormat format1 = new SimpleDateFormat("yyyy-MM-dd HH:mm");
            // 本周周几

            List<CoursePackageStudent> studentCourse = coursePackageStudentService.list(new QueryWrapper<CoursePackageStudent>().eq("studentId", student.getId()).eq("coursePackageId", toHoliDto.getClassId()));
            List<Long> collect = studentCourse.stream().map(CoursePackageStudent::getCoursePackageSchedulingId).collect(Collectors.toList());
            //拿到最后一天的排课记录
            if (collect.size() > 0) {
                coursePackageSchedulingService.delete(new QueryWrapper<CoursePackageScheduling>().in("id", collect));
                coursePackageStudentService.remove(new QueryWrapper<CoursePackageStudent>().eq("studentId", student.getId()).eq("coursePackageId", toHoliDto.getClassId()));
            }


            Date today = new Date();


            TCoursePackagePayment pay = coursePackagePaymentService.getById(holi.getId());
            Integer laveClassHours1 = pay.getLaveClassHours();
            Integer codeTime = tCoursePackage.getCodeTime();
            Integer can = 0;


            int count = 0;

            // 本周周几
//        int i = DateUtil.dayOfWeek(new Date())-1;

            Date[] dates = generateDateArray(14, today);
            can = laveClassHours1 / codeTime;

            for (Date date : dates) {
                if (count == can) {
                    break;
                }
                int wei = DateUtil.dayOfWeek(date);
                if (week.contains(wei)) {
                    for (int i1 = 0; i1 < split.length; i1++) {
                        if (count == can) {
                            break;
                        }
                        CoursePackageScheduling coursePackageScheduling = new CoursePackageScheduling();
                        coursePackageScheduling.setCoursePackageId(tCoursePackage.getId());
                        Date parse = format1.parse(format.format(date) + " " + split[i1]);
                        Date parse1 = format1.parse(format.format(date) + " " + split1[i1]);
                        coursePackageScheduling.setClassDate(parse);
                        coursePackageScheduling.setEndDate(parse1);
                        coursePackageScheduling.setStatus(1);
                        coursePackageSchedulingService.insert(coursePackageScheduling);
                        CoursePackageStudent student1 = new CoursePackageStudent();
                        student1.setAppUserId(student.getAppUserId());
                        student1.setStudentId(student.getId());
                        student1.setCoursePackageId(tCoursePackage.getId());
                        student1.setCoursePackagePaymentId(holi.getId());
                        student1.setCoursePackageSchedulingId(coursePackageScheduling.getId());
                        student1.setSignInOrNot(1);
                        student1.setReservationStatus(1);
                        student1.setInsertTime(new Date());
                        cpsMapper.insert(student1);
                        count++;
                    }
                }
            }


        }
        String[] stringArray = strings.toArray(new String[strings.size()]);

        String join = StringUtils.join(stringArray, ",");
        System.out.println("==========join========" + join);
        return "转课成功";
    }


}