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.AppUser;
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.ALiSendSms;
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) {
        List<Map<String, Object>> pays = paymentService.getStudentTotal(studentQeryDto);
        return pays;
    }

    @RequestMapping("/bypac")
    @ResponseBody
    public List<Map<String, Object>> bypac(@RequestBody PacQueryDto pacQueryDto) {
        List<Map<String, Object>> pays = paymentService.bypac(pacQueryDto);
        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;
    }




    @ResponseBody
    @PostMapping("/queryAble")
    public Integer queryAble(@RequestBody Integer id) {

        int coursePackageId = orderStudentService.count(new QueryWrapper<CoursePackageOrderStudent>().eq("coursePackageId", id));
        if (coursePackageId>0){
            return 1;
        }else {
            return 0;
        }

    }

    //获取学员课时数信息
    @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);

//        appUserClient.queryGift(tStudentId);

        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) {
            if (dto.getClassType()!=2) {
                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 ALiSendSms aLiSendSms;


    @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 Integer insertBack(@RequestBody InsertBackDto insertBackDto) {

        List<MoneyBack> ids = moneyBackService.list(new QueryWrapper<MoneyBack>().eq("ids", insertBackDto.getIds()));

        if (!ids.isEmpty()){
            return 1 ;
        }


        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);
            List<CoursePackageScheduling> coursePackageSchedulings = coursePackageSchedulingService.selectList(new QueryWrapper<CoursePackageScheduling>().eq("studentId", o.getStudentId()).eq("coursePackageId", o.getCoursePackageId()).ge("classDate", new Date()));
            List<Long> scs = new ArrayList<>();
            for (CoursePackageScheduling coursePackageScheduling : coursePackageSchedulings) {
                scs.add(coursePackageScheduling.getId());
            }
            coursePackageStudentService.remove(new QueryWrapper<CoursePackageStudent>().in("coursePackageSchedulingId",scs));
            coursePackageSchedulingService.deleteBatchIds(scs);



        }



        orderStudentService.updateBatchById(pays);
        return 0;
    }


    @Autowired
    private ICoursePackageOrderService coursePackageOrderService;

    @Autowired
    private ICoursePackageOrderStudentService coursePackageOrderStudentService;
    @RequestMapping("/queryByIds")
    @ResponseBody
    public List<CoursePackageOrderStudent> queryByIds(@RequestParam("ids") String ids) {
        List<CoursePackageOrderStudent> paymentList = coursePackageOrderStudentService.list(new QueryWrapper<CoursePackageOrderStudent>()
                .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);
            schedulingService.addNewCoursePackageScheduling(o.getId(),o.getLaveClassHours());
        }
        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("/getOrder")
    @ResponseBody
    public List<CoursePackageOrder> getOrder(@RequestParam("id") Long id) {

        CoursePackageOrderStudent coursePackageOrderStudent = coursePackageOrderStudentService.getById(id);

        List<CoursePackageOrder> list = coursePackageOrderService.list(new QueryWrapper<CoursePackageOrder>().eq("coursePackageId", coursePackageOrderStudent.getCoursePackageId()).like("studentIds", coursePackageOrderStudent.getStudentId()));
            return  list;
    }


    @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<CoursePackageOrderStudent> id1 = coursePackageOrderStudentService.list(new QueryWrapper<CoursePackageOrderStudent>().in("id", split));
//        for (CoursePackageOrderStudent o : id1) {
//            o.setStatus(1);
//            o.setAppUserId(null);
//        }
//        coursePackageOrderStudentService.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);
            if(null == student.getValidity()){
                student.setValidity(calendar.getTime());
            }else if(student.getValidity().getTime() < calendar.getTime().getTime()){
                student.setValidity(calendar.getTime());
            }
            studentClient.frozen(student);


            Integer laveClassHours1 = orinPay.getLaveClassHours();
            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(laveClassHours1);
            courseCounsum.setChangeType(0);
            courseCounsum.setPaymentId(orinPay.getId());
            counsumService.save(courseCounsum);


            CourseCounsum courseCounsum1 = new CourseCounsum();
            courseCounsum1.setInsertTime(new Date());
            courseCounsum1.setReason("赠课");
            courseCounsum1.setNum(laveClassHours1);
            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;

                Student student = studentClient.queryStudentById(coursePackageOrderStudent.getStudentId());
                Date useTime = student.getValidity();

                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[] stuIds = toHoliDto.getIds();
        //查询出学员ids对应的棵树，判断剩余课时数是否够
        List<CoursePackageOrderStudent> list = orderStudentService.list(new QueryWrapper<CoursePackageOrderStudent>().eq("coursePackageId", toHoliDto.getClassId()).in("studentId", stuIds));
        List<String> notStudent = new ArrayList<>();
        for (CoursePackageOrderStudent coursePackageOrderStudent : list) {
            if (coursePackageOrderStudent.getLaveClassHours() < toHoliDto.getClassNum()) {
                notStudent.add(studentClient.queryStudentById(coursePackageOrderStudent.getStudentId()).getName());
            }
        }
        if (!notStudent.isEmpty()) {
            String notStudentStr = String.join(",", notStudent);
            return notStudentStr+":课时数不足";
        }

        for (String stuId : stuIds) {
            Student student = studentClient.queryStudentById(Integer.valueOf(stuId));

            // 扣除 原来的课时数
        // 添加购买课时 paytyoe为7
        // 排课可期  判断课程时间段  添加排课表  添加上课记录表
        // 找到原来的课包 扣课时
//        CoursePackageOrderStudent coursePackageOrderStudent = orderStudentService.getById(toHoliDto.getId());
        CoursePackageOrderStudent coursePackageOrderStudent = orderStudentService.getOne(new QueryWrapper<CoursePackageOrderStudent>().eq("coursePackageId",toHoliDto.getId()).eq("studentId",stuId));

        TCoursePackage coursePackage = coursePackageService.getById(coursePackageOrderStudent.getCoursePackageId());
        TCoursePackage coursePackage1 = coursePackageService.getById(toHoliDto.getClassId());
        //判断剩余课时是否已经全部进行排课，如果排课需要删除已经排好的记录
        List<CoursePackageScheduling> list1 = coursePackageSchedulingService.selectList(new QueryWrapper<CoursePackageScheduling>()
                .eq("studentId", coursePackageOrderStudent.getStudentId()).eq("status", 1)
                .eq("type", 1).orderByDesc("classDate"));
        //已经排课但没有使用的课时数量
        int number = list1.size() * coursePackage.getNeedNum();
        Integer laveClassHours1 = coursePackageOrderStudent.getLaveClassHours();
        laveClassHours1 -= number;
        //需要购买使用的课时数
        Integer num = toHoliDto.getClassNum();
        //需要删除多余的排课记录
        if(num.compareTo(laveClassHours1) > 0){
            //课时数差额
            int number1 = num - laveClassHours1;
            double o = number1 % coursePackage.getNeedNum();
            int l = 0;
            if(0 != o){
                l = 1;
            }
            int n = Double.valueOf(number1 / coursePackage.getNeedNum()).intValue() + l;
            for (int i = 0; i < n; i++) {
                CoursePackageScheduling coursePackageScheduling = list1.get(i);
                coursePackageSchedulingService.deleteById(coursePackageScheduling.getId());

                coursePackageStudentService.getBaseMapper().delete(new QueryWrapper<CoursePackageStudent>()
                        .eq("coursePackageSchedulingId", coursePackageScheduling.getId()));
            }
        }
            coursePackageOrderStudent.setAppUserId(null);
        coursePackageOrderStudent.setLaveClassHours(coursePackageOrderStudent.getLaveClassHours()-toHoliDto.getClassNum());
            orderStudentService.updateById(coursePackageOrderStudent);
            Integer laveClassHours = coursePackageOrderStudent.getLaveClassHours();
            if(3 >= laveClassHours){
                AppUser appUser = appUserClient.queryAppUser(coursePackageOrderStudent.getAppUserId());
                //发送短信提醒
                aLiSendSms.sendSms(appUser.getPhone(), "SMS_463646317", "");
            }

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

            Date startTime = coursePackage1.getStartTime();
            Date endTime = coursePackage1.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(coursePackage1.getType());
                    coursePackageScheduling.setAppUserId(student.getAppUserId());
                    coursePackageScheduling.setStudentId(Integer.valueOf(stuId));
                    coursePackageScheduling.setCoursePackageId(coursePackage1.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(student.getAppUserId());
                    student1.setStudentId(Integer.valueOf(stuId));
                    student1.setCoursePackageId(coursePackage1.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);
            }




        CourseCounsum courseCounsum = new CourseCounsum();
        courseCounsum.setPaymentId(coursePackageOrderStudent.getId());
        courseCounsum.setChangeType(0);
        courseCounsum.setNum(toHoliDto.getClassNum());
        courseCounsum.setInsertTime(new Date());
        courseCounsum.setReason("报名假期班");
//        courseCounsum.setAppUserId(userId);
        courseCounsumService.save(courseCounsum);
        }

        return "报名成功";


    }


    @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[] stuIds = toHoliDto.getIds();
//        //查询出学员ids对应的棵树，判断剩余课时数是否够
//        List<CoursePackageOrderStudent> list = orderStudentService.list(new QueryWrapper<CoursePackageOrderStudent>().eq("coursePackageId", toHoliDto.getClassId()).in("studentId", stuIds));
//        List<String> notStudent = new ArrayList<>();
//        for (CoursePackageOrderStudent coursePackageOrderStudent : list) {
//            if (coursePackageOrderStudent.getLaveClassHours() < toHoliDto.getClassNum()) {
//                notStudent.add(studentClient.queryStudentById(coursePackageOrderStudent.getStudentId()).getName());
//            }
//        }
//        if (!notStudent.isEmpty()) {
//            String notStudentStr = String.join(",", notStudent);
//            return notStudentStr+":课时数不足";
//        }


        //转移课程
        for (String stuId : stuIds) {
//            CoursePackageOrderStudent orinPay = orderStudentService.getById(toHoliDto.getId());
            CoursePackageOrderStudent orinPay = orderStudentService.getOne(new QueryWrapper<CoursePackageOrderStudent>()
                    .eq("studentId", stuId)
                    .eq("coursePackageId", toHoliDto.getId()));
            CoursePackageOrderStudent studentPay = orderStudentService.getOne(new QueryWrapper<CoursePackageOrderStudent>()
                    .eq("studentId", stuId)
                    .eq("coursePackageId", toHoliDto.getClassId()));
            TCoursePackage coursePackage = packageService.getById(toHoliDto.getClassId());
            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();

                    courseCounsum.setReason("换课");


                orinPay.setLaveClassHours(0);
                orinPay.setStatus(3);
                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(Integer.valueOf(stuId));
                CoursePackageOrderStudent to = new CoursePackageOrderStudent();
                to.setStudentId(Integer.valueOf(stuId));
                to.setTotalClassHours(laveClassHours);
                to.setLaveClassHours(laveClassHours);
                to.setCoursePackageId(toHoliDto.getClassId());
                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);
                if (null == student.getValidity()) {
                    student.setValidity(calendar.getTime());
                } else if (student.getValidity().getTime() < calendar.getTime().getTime()) {
                    student.setValidity(calendar.getTime());
                }
                studentClient.frozen(student);


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


                CourseCounsum courseCounsum = new CourseCounsum();
                courseCounsum.setInsertTime(new Date());
                courseCounsum.setReason("换课");
                courseCounsum.setNum(laveClassHours1);
                courseCounsum.setChangeType(0);
                courseCounsum.setPaymentId(orinPay.getId());
                counsumService.save(courseCounsum);


                CourseCounsum courseCounsum1 = new CourseCounsum();
                courseCounsum1.setInsertTime(new Date());
                courseCounsum1.setReason("换课");
                courseCounsum1.setNum(laveClassHours1);
                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()));
                }
            }

        }
    return "换课成功";

    }
}