package com.dsh.course.controller;


import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.dsh.course.entity.*;
import com.dsh.course.entity.TAppUser;
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.feignclient.account.model.TCourseInfoRecord;
import com.dsh.course.feignclient.account.model.TStudent;
import com.dsh.course.feignclient.activity.CouponClient;
import com.dsh.course.feignclient.activity.model.Coupon;
import com.dsh.course.feignclient.model.*;
import com.dsh.course.feignclient.other.StoreClient;
import com.dsh.course.feignclient.other.model.Store;
import com.dsh.course.mapper.CoursePackageSchedulingMapper;
import com.dsh.course.model.*;
import com.dsh.course.model.dto.DiscountJsonDto;
import com.dsh.course.model.vo.CourseDetailRequest;
import com.dsh.course.model.vo.RegisterCourseVo;
import com.dsh.course.model.vo.request.*;
import com.dsh.course.model.vo.response.*;
import com.dsh.course.service.*;
import com.dsh.course.util.*;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import net.bytebuddy.asm.Advice;
import org.aspectj.weaver.ast.Var;
import io.swagger.models.auth.In;
import org.checkerframework.checker.units.qual.C;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.*;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.stream.Collectors;

@Api
@CrossOrigin
@RestController
@RequestMapping("")
public class CoursePackagePaymentController {

    private Logger logger = LoggerFactory.getLogger("business-log");


    @Autowired
    private TCoursePackagePaymentService packagePaymentService;

    @Autowired
    private TCoursePackageService tcpService;

    @Autowired
    private TCoursePackageDiscountService tcpdService;


    @Autowired
    private ICoursePackagePaymentConfigService icppcService;

    @Autowired
    private UserVideoDetailsService uvdsService;

    @Autowired
    private TCourseService tcService;

    @Resource
    private StudentClient studentClient;

    @Autowired
    private TCoursePackageTypeService coursePackageTypeService;

    @Autowired
    private TokenUtil tokenUtil;

    @Autowired
    private CancelledClassesService cancelledClassesService;

    @Resource
    private CoursePackageStudentService cspsService;


    @Autowired
    private PayMoneyUtil payMoneyUtil;
    @Resource
    private AppUserClient auClitn;

    @Resource
    private StoreClient sreClient;

    @Autowired
    private AppUserClient appUserClient;

    @Autowired
    private RestTemplate internalRestTemplate;
    @Autowired
    private CouponClient couponClient;
    @Autowired
    private StoreClient storeClient;
    @Autowired
    private TCoursePackageDiscountService discountService;

    @Resource
    private CoursePackageSchedulingMapper coursePackageSchedulingMapper;
    @Autowired
    private ICoursePackageSchedulingService coursePackageSchedulingService;
    @Autowired
    private CoursePackageStudentService coursePackageStudentService;

    private final SimpleDateFormat format = new SimpleDateFormat("MM-dd HH:mm");

    /**
     * 查询学员入学时间 根据第一次购买课包的时间
     * @return
     */
    @RequestMapping("/base/coursePackagePayment/getTime")
    public String getTime(@RequestBody Integer studentId){
        List<TCoursePackagePayment> list = packagePaymentService.list(new QueryWrapper<TCoursePackagePayment>()
                .eq("studentId", studentId)
                .orderByDesc("insertTime")
                .last("LIMIT 1"));
        if (list.size()>0){
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
            Date insertTime = list.get(0).getInsertTime();
            String format1 = format.format(list.get(0).getInsertTime());
            return format1;
        }
        return "";
    }
    /**
     * 添加购课记录-后台
     * @return
     */
    @RequestMapping("/base/coursePackagePayment/add")
    public Object addCoursePackagePayment(@RequestBody TCoursePackagePayment packagePayment){
        packagePayment.setInsertTime(new Date());
        packagePayment.setInsertTime(new Date());
        Integer studentId = packagePayment.getStudentId();
        // 添加学员上课记录
        CoursePackageStudent coursePackageStudent = new CoursePackageStudent();
        TCoursePackagePayment one = packagePaymentService.getOne(new QueryWrapper<TCoursePackagePayment>().eq("studentId", packagePayment.getStudentId())
                .orderByDesc("insertTime")
                .last("LIMIT 1"));

        if (one!=null){
            Integer totalClassHours = one.getTotalClassHours();
            Integer absencesNumber = one.getAbsencesNumber();
            // 没有过期
            if (one.getUseTime().after(new Date())){
                if (one.getLaveClassHours()-packagePayment.getClassHours()<0){
                    return 5002;
                }
                packagePayment.setTotalClassHours(one.getTotalClassHours());
                packagePayment.setLaveClassHours(one.getLaveClassHours()-packagePayment.getClassHours());
                packagePayment.setAbsencesNumber(one.getAbsencesNumber());
            }
            packagePayment.setTotalClassHours(packagePayment.getClassHours());
            packagePayment.setLaveClassHours(packagePayment.getClassHours());
            packagePayment.setAbsencesNumber(one.getAbsencesNumber());
        }else{
            packagePayment.setTotalClassHours(packagePayment.getClassHours());
            packagePayment.setLaveClassHours(packagePayment.getClassHours());
            packagePayment.setAbsencesNumber(0);
        }
        // 生成排课数据
        TCoursePackage coursePackage = tcpService.getById(packagePayment.getCoursePackageId());
        //生成排课数据
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date date = sdf1.parse(sdf.format(new Date()) + " 00:00:00");
            List<String> list = Arrays.asList(coursePackage.getClassWeeks().split(";"));
            String value = coursePackage.getClassStartTime();
            String value1 = coursePackage.getClassEndTime();

            String[] star = value.split(",");
            String[] end = value1.split(",");
            for (int i = 0; i < star.length; i++) {
    //                int index = star[i].indexOf(",");
    //                String result = value.substring(0, index).trim();
                String classStartTime = star[i];
                String[] split = classStartTime.split(":");
    //            String value1 = en;
                int index1 = value1.indexOf(",");
    //                String result1 = value.substring(0, index1).trim();
                String classEndTime = end[i];
                String[] split1 = classEndTime.split(":");
                Calendar s = Calendar.getInstance();
                s.setTime(date);
                s.set(Calendar.DAY_OF_YEAR, s.get(Calendar.DAY_OF_YEAR) + 1);
                s.set(Calendar.HOUR_OF_DAY, Integer.valueOf(split[0]));
                s.set(Calendar.MINUTE, Integer.valueOf(split[1]));
                s.set(Calendar.SECOND, 0);

                Calendar e = Calendar.getInstance();
                e.setTime(date);
                e.set(Calendar.DAY_OF_YEAR, s.get(Calendar.DAY_OF_YEAR) + 14);
                long timeInMillis = e.getTimeInMillis();

                while (true){
                    int w = s.get(Calendar.DAY_OF_WEEK);
                    WeekEnum weekEnum = WeekEnum.getWeekEnum(w);
                    if(list.contains(weekEnum.getChineseName())){
                        Calendar classDate = Calendar.getInstance();
                        classDate.setTime(s.getTime());
                        classDate.set(Calendar.HOUR_OF_DAY, Integer.valueOf(split[0]));
                        classDate.set(Calendar.MINUTE, Integer.valueOf(split[1]));
                        classDate.set(Calendar.SECOND, 0);

                        Calendar endDate = Calendar.getInstance();
                        endDate.setTime(s.getTime());
                        endDate.set(Calendar.HOUR_OF_DAY, Integer.valueOf(split1[0]));
                        endDate.set(Calendar.MINUTE, Integer.valueOf(split1[1]));
                        endDate.set(Calendar.SECOND, 0);

                        CoursePackageScheduling coursePackageScheduling = new CoursePackageScheduling();
                        coursePackageScheduling.setCoursePackageId(coursePackage.getId());
                        coursePackageScheduling.setClassDate(classDate.getTime());
                        coursePackageScheduling.setEndDate(endDate.getTime());
                        coursePackageScheduling.setStatus(1);
                        coursePackageSchedulingService.save(coursePackageScheduling);
                        coursePackageStudent.setCoursePackageSchedulingId(coursePackageScheduling.getId());

                        List<CoursePackageScheduling> list1 = coursePackageSchedulingService.list(new QueryWrapper<CoursePackageScheduling>()
                                .eq("coursePackageId", coursePackage.getId())
                                .eq("classDate", classDate.getTime())
                                .eq("endDate", endDate.getTime()));
                        if (list1.size()+1>coursePackage.getMaxSubscribeNumber()){
                            // 当前课包预约人数已满
                            return 5001;
                        }
                    }
                    s.set(Calendar.DAY_OF_YEAR, s.get(Calendar.DAY_OF_YEAR) + 1);
                    if(s.getTimeInMillis() > timeInMillis){
                        break;
                    }
                }
            }
        } catch (ParseException e) {
            e.printStackTrace();
        }

        coursePackageStudent.setStudentId(packagePayment.getStudentId());
        coursePackageStudent.setCoursePackageId(packagePayment.getCoursePackageId());


        coursePackageStudent.setSignInOrNot(0);
        coursePackageStudent.setReservationStatus(1);
        coursePackageStudent.setInsertTime(new Date());
        coursePackageStudent.setAppUserId(packagePayment.getAppUserId());
        packagePaymentService.save(packagePayment);
        coursePackageStudent.setCoursePackagePaymentId(packagePayment.getId());
        return coursePackageStudentService.save(coursePackageStudent);
    }
    /**
     * 手动支付
     * @return
     */
    @RequestMapping("/base/coursePackagePayment/changeState")
    public Object changeState(@RequestBody CoursePackagePayDTO dto){

        return packagePaymentService.changeState(dto);
    }
    @GetMapping("/coursePackagePayment/courseStore/{appUserId}/{coursePackageId}")
    public List<TCoursePackagePayment> getByUserIdAndCoursePackageId(@PathVariable("appUserId") Integer appUserId,@PathVariable("coursePackageId") Integer coursePackageId){
        List<TCoursePackagePayment> list = packagePaymentService.list(new QueryWrapper<TCoursePackagePayment>()
                .eq("appUserId", appUserId)
                .eq("coursePackageId", coursePackageId));
        return list;
    }
    /**
     * 获取购课记录
     */
    @ResponseBody
    @RequestMapping("/coursePackagePayment/listAll")
    public List<CoursePackagePaymentVO> listAll(@RequestBody CoursePackagePaymentQuery query){
        List<CoursePackagePaymentVO> res = packagePaymentService.listAll(query);
        List<CoursePackagePaymentVO> result = new ArrayList<>();
        for (CoursePackagePaymentVO re : res) {
            if (re.getCashPayment()==null){
                if (re.getPlayPaiCoin()!=null){
                    String value = String.valueOf(re.getPlayPaiCoin());
                    re.setCashPayment(new BigDecimal(value));
                }
            }

            Store store = storeClient.queryStoreById(re.getStoreId());
            TAppUser appUser = appUserClient.queryAppUser1(re.getAppUserId());
            Student student = studentClient.queryStudentById(re.getStudentId());
            re.setPayStudent(student.getName());
            re.setPayUser(appUser.getName());
            re.setPhone(appUser.getPhone());
            re.setStoreName(store.getName());
            if (query.getPayUser()== null || query.getPayUser().equals("") ){
            }else{
                List<AppUser> appUsers = appUserClient.queryAppUserListByName(query.getPayUser());
                for (AppUser user : appUsers) {
                    if (appUser.getName().equals(user.getName())){
                        if (query.getPayStudent()== null || query.getPayStudent().equals("")){
                        }else{
                            List<Student> students = studentClient.queryStudentListByName(query.getPayStudent());
                            for (Student student1 : students) {
                                if (student.getName().equals(student1.getName())){
                                    result.add(re);
                                }
                            }
                        }
                    }
                }
            }

            if (re.getPayType()!=null){
                if (re.getPayType()==1){
                    re.setBuyTypeName("微信支付");
                }else if(re.getPayType()==2){
                    re.setBuyTypeName("支付宝支付");
                }else if(re.getPayType()==3){
                    re.setBuyTypeName("玩湃币支付");
                }else if(re.getPayType()==4){
                    re.setBuyTypeName("积分支付");
                }else if(re.getPayType()==5){
                    re.setBuyTypeName("积分+微信支付");
                }else if(re.getPayType()==6){
                    re.setBuyTypeName("积分+支付宝支付");
                }else if(re.getPayType()==7){
                    re.setBuyTypeName("手动支付"+"-"+re.getBuyTypeName());
                }
            }

            // 如果支付用户类型为管理员 则购买方式则为1线下购买
            if (re.getPayUserType()!=null){
                if (re.getPayUserType()== 2){
                    re.setBuyType(1);
                }else{
                    // 如果当前课包有折扣 则为3折扣购买
                    if (discountService.list(new QueryWrapper<TCoursePackageDiscount>()
                            .eq("coursePackageId",re.getCoursePackageId()).eq("auditStatus",2)).size()>0){
                        re.setBuyType(3);
                        re.setDiscountAmount(re.getOriginalPrice().subtract(re.getPayMoney()));
                    }else{
                        re.setBuyType(2);
                    }
                }
            }
            if(re.getCashPayment()==null){
                BigDecimal bigDecimal = new BigDecimal("0.00");
                re.setDiscountAmount(bigDecimal);
                continue;
            }
            BigDecimal subtract = re.getOriginalPrice().subtract(re.getCashPayment());
            re.setDiscountAmount(subtract);
            }
        if (query.getPayStudent()== null || query.getPayStudent().equals("")){
            if (query.getPayUser()== null || query.getPayUser().equals("")){
                return res;
            }else{
                return result;
            }
        }else{
            return result;
        }
    }

    /**
     * 获取报名订单记录列表
     */
    @ResponseBody
    @RequestMapping("/registerOrder/listAllRegister")
    public List<RegisterOrderVO> listAllRegister(@RequestBody RegisterOrderQuery query){
        if (query.getStudentName()!=null){
            if (!query.getStudentName().equals("")){
                List<TStudent> students1 = studentClient.queryTStudentListByName(query.getStudentName());
                List<Integer> studentIds = students1.stream().map(TStudent::getId).collect(Collectors.toList());
                query.setStudentIds(studentIds);
                if (students1.size()==0){
                    return new ArrayList<>();
                }
            }
        }
        List<RegisterOrderVO> res = packagePaymentService.listAllRegister(query);
        // 该运营商下没有门店
        if (query.getInsertType() == 2){
            if (query.getStoresIds()!=null){
                if (query.getStoresIds().size()==0){
                    List<RegisterOrderVO> registerOrderVOS = new ArrayList<>();
                    return registerOrderVOS;
                }
            }else{
                List<RegisterOrderVO> registerOrderVOS = new ArrayList<>();
                return registerOrderVOS;
            }
        }

        List<RegisterOrderVO> result = new ArrayList<>();
        Iterator<RegisterOrderVO> iterator = res.iterator();
        while (iterator.hasNext()) {
            RegisterOrderVO re = iterator.next();
            if (re.getSalesName() == null) {
                re.setSalesName("无");
            }
            if (re.getPayType() != null) {
                if (re.getPayType() == 3) {
                    re.setPayMoneyAndType(re.getPlayPaiCoin() + "玩湃币");
                } else {
                    re.setPayMoneyAndType("￥" + re.getMoney());
                }
            }
            if (re.getStoreId()!=null){
                Store store = storeClient.queryStoreById(re.getStoreId());
                if (store!=null){
                    re.setStoreName(store.getName());
                }
            }
            TAppUser appUser = appUserClient.queryAppUser1(re.getAppUserId());
            Student student = studentClient.queryStudentById(re.getStudentId());
            re.setPayStudent(student.getName());
            re.setPayUser(appUser.getName());
            re.setPhone(appUser.getPhone());
        }
        return res;
    }

    /**
     * 获取 没有学员信息的图片配置
     * @param stuId 学员id
     * @return  课包列表
     */
    @ResponseBody
    @PostMapping("/base/coursePack/queryPayment")
    public List<StuCourseResp> getStuCoursePackagePayment(@RequestBody Integer stuId){
        List<StuCourseResp> resps = new ArrayList<>();
        Student student = studentClient.queryStudentById(stuId);
        List<TCoursePackagePayment> byUserId = packagePaymentService.list(new QueryWrapper<TCoursePackagePayment>()
                .eq("appUserId",student.getAppUserId())
                .eq("studentId",stuId).eq("payStatus",2));

        if (byUserId.size() > 0 ){
            for (TCoursePackagePayment tCoursePackagePayment : byUserId) {
                TCoursePackage tCoursePackage = tcpService.getById(tCoursePackagePayment.getCoursePackageId());
                if (tCoursePackage.getType()==3){
                    continue;
                }
                StuCourseResp resp = new StuCourseResp();
                resp.setCourseId(tCoursePackage.getId());
                resp.setId(tCoursePackagePayment.getId());
                resp.setCourseName(tCoursePackage.getName());
                resp.setTotalCourseNums(tCoursePackagePayment.getTotalClassHours());
                resp.setResidueNums(tCoursePackagePayment.getLaveClassHours());
                resp.setDeductionNums(tCoursePackagePayment.getTotalClassHours()-tCoursePackagePayment.getLaveClassHours());
                resp.setCourseType(tCoursePackage.getType());
                if (tCoursePackage.getType()!=1||tCoursePackage.getState()==2||tCoursePackagePayment.getPayStatus()==1){
                    resp.setIsAble(0);
                }else {
                    resp.setIsAble(1);
                }
                if (tCoursePackagePayment.getUseTime()!=null){
//                String afterDayDate = DateUtil.getAfterDayDate2(tCoursePackage.getInsertTime(),tCoursePackage.getValidDays() + "");
//                resp.setPeriodOfValidity(afterDayDate);


                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                    String str = sdf.format(tCoursePackagePayment.getUseTime());
                    resp.setPeriodOfValidity(str);
                }



                resps.add(resp);
            }
        }
        return resps;
    }

    /**
     *
     * 获取发布的 课包列表
     */
    @ResponseBody
    @PostMapping("/base/coursePack/storeOfCourse")
    public List<CourseOfStoreVo> getStuCourseWithStores(@RequestBody WeeksOfCourseRest courseRest){
        List<CourseOfStoreVo> course = new ArrayList<>();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        try {
            Date parse = simpleDateFormat.parse(courseRest.getTime());
            List<TCoursePackagePayment> list = packagePaymentService.list(new QueryWrapper<TCoursePackagePayment>()
                    .eq("appUserId",courseRest.getAppUserId() )
                    .eq("studentId",courseRest.getStuId())
                    .eq("payStatus",2)
                    .eq("status",1)
                    .eq("state",1)
                    .groupBy("coursePackageId"));
            if (list.size() >  0){
                for (TCoursePackagePayment tCoursePackagePayment : list) {
                    List<CoursePackageStudent> packageStudent = cspsService.list(new LambdaQueryWrapper<CoursePackageStudent>()
                            .eq(CoursePackageStudent::getAppUserId, courseRest.getAppUserId())
                            .eq(CoursePackageStudent::getStudentId,courseRest.getStuId())
                            .eq(CoursePackageStudent::getCoursePackagePaymentId,tCoursePackagePayment.getId())
                            .eq(CoursePackageStudent::getCoursePackageId,tCoursePackagePayment.getCoursePackageId()));
                    if (ToolUtil.isEmpty(packageStudent) || (ToolUtil.isNotEmpty(packageStudent) && packageStudent.get(0).getReservationStatus() == 1)){
//                        没有预约过的/已经取消了的
                        TCoursePackage tCoursePackage = tcpService.getById(tCoursePackagePayment.getCoursePackageId());
                        CoursePackagePaymentConfig paymentConfig = icppcService.getOne(new QueryWrapper<CoursePackagePaymentConfig>()
                                .eq("coursePackageId",tCoursePackage.getId() )
                                .eq("classHours",tCoursePackagePayment.getClassHours()));
//                    获取课程有效结束时间，判断 查询的日期parse 是否在有效期范围内
                        Date expirationDate = DateTimeHelper.getExpirationDate(tCoursePackagePayment.getInsertTime(),tCoursePackage.getValidDays());
                        System.out.println(expirationDate.after(parse));
                        String classWeeks = tCoursePackage.getClassWeeks();
                        System.out.println(StrUtils.dealStrToList(classWeeks).contains(DateTimeHelper.getDayOfWeek(parse)));
                        if (expirationDate.after(parse) && StrUtils.dealStrToList(classWeeks).contains(DateTimeHelper.getDayOfWeek(parse))){
                            CourseOfStoreVo storeVo = new CourseOfStoreVo();
                            storeVo.setCourseId(tCoursePackagePayment.getId());
                            storeVo.setCourseName(tCoursePackage.getName());
                            storeVo.setClassStartTime(tCoursePackage.getClassStartTime());
                            storeVo.setClassEndTime(tCoursePackage.getClassEndTime());
                            storeVo.setStoreId(tCoursePackage.getStoreId());
                            Store store = sreClient.queryStoreById(tCoursePackage.getStoreId());
                            storeVo.setStoreAddress(store.getAddress());
                            storeVo.setLat(store.getLat());
                            storeVo.setLon(store.getLon());
                            storeVo.setCoursePrice(ToolUtil.isEmpty(paymentConfig.getCashPayment()) ? (double) paymentConfig.getPlayPaiCoin():paymentConfig.getCashPayment());
                            storeVo.setStatus(1);
                            // 2.0
                            storeVo.setAllNum(tCoursePackagePayment.getTotalClassHours());
                            storeVo.setLastNum(tCoursePackagePayment.getLaveClassHours());
                            storeVo.setUseNum(tCoursePackagePayment.getTotalClassHours()-tCoursePackagePayment.getLaveClassHours());

                            course.add(storeVo);
                        }
                    }
                }
            }
            System.out.println(course);
            return course;
        } catch (ParseException e) {
            return null;
        }
    }


    /**
     *
     * 课程名称列表
     */
    @PostMapping("/base/coursePack/sessionNames")
    public List<StuSessionDetailsVo> getStuSessionList(@RequestBody CourseDetailRequest request){
        List<StuSessionDetailsVo> detailsVos = new ArrayList<>();
        List<TCoursePackagePayment> byUserId = packagePaymentService.list(new QueryWrapper<TCoursePackagePayment>()
                .between("insertTime", request.getStartTime(),request.getEndTime())
                .eq("appUserId",request.getAppUserId())
                .eq("studentId",request.getStuId()));
        if (byUserId.size() > 0){
            List<Integer> collect = byUserId.stream().map(TCoursePackagePayment::getCoursePackageId).collect(Collectors.toList());
            List<TCoursePackage> list = tcpService.list(new QueryWrapper<TCoursePackage>()
                    .in("id", collect));
            list.forEach(vo -> {
                StuSessionDetailsVo detVo = new StuSessionDetailsVo();
                if (vo.getType()!=2) {
                    detVo.setSessionid(vo.getId());
                    detVo.setSessionName(vo.getName());
                    String afterDayDate = DateUtil.getAfterDayDate2(vo.getInsertTime(), vo.getValidDays() + "");
                    detVo.setPeriodOfValidity(afterDayDate);
                    detailsVos.add(detVo);
                }
            });
        }
        return detailsVos;
    }

    @PostMapping("/base/coursePack/paymentCourse")
    public List<PurchaseRecordVo> queryCourseDetails(@RequestBody GetStuSessionList sessionList) {
        List<PurchaseRecordVo> purchaseRecordVos = new ArrayList<>();

        List<TCoursePackagePayment> coursePackage = packagePaymentService.list(new QueryWrapper<TCoursePackagePayment>()
                .between("insertTime", sessionList.getStartTime(),sessionList.getEndTime())
                .eq("appUserId",sessionList.getAppUserId())
                .eq("studentId",sessionList.getStuId()));
        if (coursePackage.size() > 0 ){
            coursePackage.forEach( cspackage -> {
                PurchaseRecordVo recordVo = new PurchaseRecordVo();
                recordVo.setPurchaseAmount("+"+cspackage.getClassHours());
                recordVo.setPurchaseTime(format.format(cspackage.getInsertTime()));
                recordVo.setPurchaseType("购买课包");
                purchaseRecordVos.add(recordVo);
            });
        }
        return purchaseRecordVos;
    }


    @Autowired
    private CourseCounsumService courseCounsumService;

    @Autowired
    private TCoursePackagePaymentService coursePackagePaymentService;

    @PostMapping("/base/coursePack/getRecord")
    public List<PurchaseRecordVo> getRecord(@RequestBody RecordTimeRequest recordTimeRequest) {
        List<TCoursePackagePayment> list = new ArrayList<>();
        Integer [] changes = {1,0};
        if (recordTimeRequest.getType()==null) {
          list = coursePackagePaymentService.list(new QueryWrapper<TCoursePackagePayment>().eq("studentId", recordTimeRequest.getStuId()).eq("coursePackageId", recordTimeRequest.getLessionId()).orderByDesc("insertTime"));
        }else {

            list = coursePackagePaymentService.list(new QueryWrapper<TCoursePackagePayment>().eq("studentId", recordTimeRequest.getStuId()).eq("coursePackageId", recordTimeRequest.getLessionId()).orderByDesc("insertTime"));

        }
        List<Long> ids = new ArrayList<>();
        for (TCoursePackagePayment coursePackagePayment : list) {
            ids.add(coursePackagePayment.getId());
        }



        QueryWrapper<CourseCounsum> in = new QueryWrapper<CourseCounsum>().in("paymentId", ids).in("changeType", changes);

        if (recordTimeRequest.getType()!=null){
            if (recordTimeRequest.getType()==2){
                recordTimeRequest.setType(0);
            }
            in.eq("changeType",recordTimeRequest.getType());
        }
        List<CourseCounsum> paymentId = courseCounsumService.list(in);
        List<PurchaseRecordVo> recordVos =new ArrayList<>();
        for (CourseCounsum courseCounsum : paymentId) {
            PurchaseRecordVo purchaseRecordVo = new PurchaseRecordVo();
            if (courseCounsum.getChangeType() == 0) {
                purchaseRecordVo.setPurchaseAmount("-" + courseCounsum.getNum());
                purchaseRecordVo.setPurchaseType(courseCounsum.getReason());
                SimpleDateFormat sdf = new SimpleDateFormat("MM-dd HH:mm");
                String formattedDate = sdf.format(courseCounsum.getInsertTime());
                purchaseRecordVo.setPurchaseTime(formattedDate);
            } else {
                purchaseRecordVo.setPurchaseAmount("+" + courseCounsum.getNum());
                purchaseRecordVo.setPurchaseType(courseCounsum.getReason());
                SimpleDateFormat sdf = new SimpleDateFormat("MM-dd HH:mm");
                String formattedDate = sdf.format(courseCounsum.getInsertTime());
                purchaseRecordVo.setPurchaseTime(formattedDate);
            }
            recordVos.add(purchaseRecordVo);
        }

        return recordVos;
    }



    @PostMapping("/base/coursePack/stuOfCourses")
    public StuWithCoursesListVo getStuOfCoursesDetails(@RequestBody GetStuOfCoursesDetails getStuOfCoursesDetails){
        StuWithCoursesListVo lisco = new StuWithCoursesListVo();
        Integer totalNu = 0;
        Integer dedutNu = 0;
        Integer remainNu = 0;
        List<TCoursePackagePayment> byUserId = packagePaymentService.list(new QueryWrapper<TCoursePackagePayment>()
                .eq("appUserId",getStuOfCoursesDetails.getAppUserId())
                .eq("studentId",getStuOfCoursesDetails.getStuId()));
        if (byUserId.size() > 0 ){
            for (TCoursePackagePayment tCoursePackagePayment : byUserId) {
                totalNu = totalNu + tCoursePackagePayment.getTotalClassHours();
                dedutNu = dedutNu + tCoursePackagePayment.getLaveClassHours();
                remainNu = remainNu + (tCoursePackagePayment.getTotalClassHours()-tCoursePackagePayment.getLaveClassHours());
            }
            lisco.setTotalNums(totalNu);
            lisco.setDeductedNums(remainNu);
            lisco.setRemainingNums(dedutNu);
        }
        return lisco;
    }



    @PostMapping("/base/coursePack/continuingCourse")
    public StudentOfCourseVo getStudentCourse(@RequestBody GetStudentCourse getStudentCourse){
        StudentOfCourseVo courseVo = new StudentOfCourseVo();
        List<TCoursePackagePayment> tCoursePackagePayments = packagePaymentService.list(new QueryWrapper<TCoursePackagePayment>()
                .eq("appUserId", getStudentCourse.getAppUserId())
                .eq("coursePackageId", getStudentCourse.getCourseId())
                .eq("studentId", getStudentCourse.getStuId()));
        if (tCoursePackagePayments.size() > 0 ){

            List<CourseHoursType> typeList = new ArrayList<>();
            tCoursePackagePayments.forEach(cou -> {
                CourseHoursType hoursType = new CourseHoursType();
                hoursType.setCourseConfigId(cou.getId());
                hoursType.setCourseHourNums(cou.getClassHours());
                typeList.add(hoursType);
            });
            TCoursePackagePayment tCoursePackagePayment = tCoursePackagePayments.get(0);
            courseVo.setCoursePackageId(tCoursePackagePayment.getCoursePackageId());
            courseVo.setTypeList(typeList);

            TCoursePackage coursePackage = tcpService.getById(tCoursePackagePayment.getCoursePackageId());
            courseVo.setPackageImg(coursePackage.getCoverDrawing());
            courseVo.setCourseName(coursePackage.getName());
            courseVo.setCoachId(coursePackage.getCoachId());
            String classWeeks = coursePackage.getClassWeeks();
            List<Integer> integers = StrUtils.dealStrToList(classWeeks);
            if (integers.size() > 0){
                StringBuilder courWeeks = new StringBuilder("每");
                for (Integer integer : integers) {
                    courWeeks.append(integer).append("、");
                }
                if (courWeeks.length() > 0 && courWeeks.charAt(courWeeks.length() - 1) == '、'){
                    courWeeks.deleteCharAt(courWeeks.length() - 1);
                }
                courseVo.setCourseWeek(courWeeks.toString());
            }

            courseVo.setCourseTime(coursePackage.getClassStartTime()+"-"+coursePackage.getClassEndTime());
            Integer payType = tCoursePackagePayment.getPayType();
            BigDecimal cashPayment = tCoursePackagePayment.getCashPayment();
            double cashPaymentValue = cashPayment.doubleValue();
            Integer playPaiCoin = tCoursePackagePayment.getPlayPaiCoin();
            TCoursePackageDiscount coursePackageDiscount = tcpdService.getOne(new QueryWrapper<TCoursePackageDiscount>()
                    .eq("coursePackageId",coursePackage.getId() )
                    .eq("type",1)
                    .eq("auditStatus",2));
            ObjectMapper objectMapper = new ObjectMapper();
            String content = coursePackageDiscount.getContent();
            double discountMember = 0.0;
            DiscountJsonDto discountJsonDto = null;
            try {
                discountJsonDto = objectMapper.readValue(content, DiscountJsonDto.class);
                discountMember = discountJsonDto.getDiscountMember();
            } catch (JsonProcessingException e) {
                throw new RuntimeException(e);
            }
            switch (payType) {
                case 1:
                case 2:
                    courseVo.setAmount(cashPaymentValue);
                    courseVo.setVipAmount(discountMember);
                    break;
                case 3:
                    courseVo.setWpGold(playPaiCoin);
                    break;
            }
            courseVo.setStoreId(coursePackage.getStoreId());
        }

        return courseVo;
    }


    @PostMapping("/base/coursePack/afterCourseTwos")
    public List<AfterVideoVo> getAfterCourseTwos(@RequestParam("appUserId") Integer appUserId){
        List<AfterVideoVo> videoVos = new ArrayList<>();
        List<UserVideoDetails> list = uvdsService.list(new QueryWrapper<UserVideoDetails>()
                .eq("appUserId",appUserId)
                .eq("state",1));
        if (list.size() > 0 ){
            List<Integer> courseIds = list.stream().map(UserVideoDetails::getCourseId).collect(Collectors.toList());
            List<TCourse> courseList = tcService.list(new QueryWrapper<TCourse>()
                    .in("id",courseIds)
                    .eq("type",1)
                    .eq("state",1)
                    .last("ORDER BY insertTime desc LIMIT 2"));
            for (TCourse tCourse : courseList) {
                AfterVideoVo videoVo = new AfterVideoVo();
                videoVo.setCourseId(tCourse.getId());
                videoVo.setCourseUrl(tCourse.getCourseVideo());
                videoVos.add(videoVo);
            }
        }
        return videoVos;
    }

    @PostMapping("/base/coursePack/allPaymentCourseList")
    @ResponseBody
    public List<CouponPaymentVo> getAppuserCourseList(@RequestBody Integer appUserId){
        List<CouponPaymentVo> paymentVos = new ArrayList<>();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm");
        List<TCoursePackagePayment> list = packagePaymentService.list(new QueryWrapper<TCoursePackagePayment>()
                .eq("appUserId", appUserId)
                .eq("payType", 3)
                .eq("payStatus", 2)
                .eq("state", 1));
        if (list.size() > 0 ){
            for (TCoursePackagePayment tCoursePackagePayment : list) {
                CouponPaymentVo couponPaymentVo = new CouponPaymentVo();
                couponPaymentVo.setTime(simpleDateFormat.format(tCoursePackagePayment.getInsertTime()));
                couponPaymentVo.setAmount( tCoursePackagePayment.getPlayPaiCoin());
                paymentVos.add(couponPaymentVo);
            }
        }
        return paymentVos;
    }


    @ResponseBody
    @PostMapping("/base/coursePack/allAmountPayRecordOfUser")
    public BillingRequestVo getAmountPayRecord(@RequestBody BillingDataRequestVo billingDataRequestVo){
        BillingRequestVo requestVo = new BillingRequestVo();
        List<BillingRequest> billingRequests = packagePaymentService.queryAmountDatas(billingDataRequestVo.getAppUserId(), billingDataRequestVo.getMonthStart(), billingDataRequestVo.getMonthEnd());
        if (billingRequests.size() >0){
            requestVo.setRequests(billingRequests);
        }
        return requestVo;
    }


    @ResponseBody
    @PostMapping("/api/course/queryArrangeCourseList")
    @ApiOperation(value = "课后练习-获取布置课程列表", tags = {"APP-开始上课"})
    @ApiImplicitParams({
    })
    public ResultUtil<List<BaseVo>> queryArrangePackageType(){
        try {
            Integer appUserId = tokenUtil.getUserIdFormRedis();
            if(null == appUserId){
                return ResultUtil.tokenErr();
            }
            List<TCoursePackagePayment> tCoursePackagePayments = packagePaymentService.list(new QueryWrapper<TCoursePackagePayment>()
                    .eq("appUserId",appUserId));
            List<BaseVo> list = new ArrayList<>();
            tCoursePackagePayments.forEach(c -> {
                BaseVo baseVo = new BaseVo();
                baseVo.setId(c.getCoursePackageId());
                TCoursePackage coursePackage = tcpService.getById(c.getCoursePackageId());
                baseVo.setName(coursePackage.getName());
                list.add(baseVo);
            });

            Set<BaseVo> set = new HashSet<>(list);
            List<BaseVo> back = new ArrayList<>(set);

            return ResultUtil.success(back);
        }catch (Exception e){
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }

    /**
     * 课后视频课表
     */
    @ResponseBody
    @PostMapping("/api/startCource/afterSourceList")
    @ApiOperation(value = "课后练习-课后视频列表", tags = {"APP-开始上课"})
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9....."),
    })
    public ResultUtil<List<AppUserVideoResponse>> queryAfterSourceList( CourseOfAfterRequest search) throws Exception {
//        try {
            Integer appUserId = tokenUtil.getUserIdFormRedis();

            if(null == appUserId){
                return ResultUtil.tokenErr();
            }
//
//            List<Integer> courseIds = new ArrayList<>();
//            QueryWrapper<TCoursePackagePayment> queryWrapper = new QueryWrapper<TCoursePackagePayment>().eq("appUserId", appUserId)
//                    .groupBy("coursePackageId");
//            if (ToolUtil.isNotEmpty(search.getCourseTypeId())){
//                queryWrapper.eq("coursePackageId",search.getCourseTypeId());
//            }
//            List<TCoursePackagePayment> tCoursePackagePayments = packagePaymentService.list(queryWrapper);
//            if (tCoursePackagePayments.size() > 0 ){
//                courseIds = tCoursePackagePayments.stream().map(TCoursePackagePayment::getCoursePackageId).collect(Collectors.toList());
//            }


            QueryWrapper<CoursePackageStudent> queryWrapper1 = new QueryWrapper<CoursePackageStudent>().eq("studentId", search.getStuId());
            if (ToolUtil.isNotEmpty(search.getCourseTypeId())){
                queryWrapper1.eq("coursePackageId",search.getCourseTypeId());
            }

            List<CoursePackageStudent> list = coursePackageStudentService.list(queryWrapper1);
            List<Long> longs = new ArrayList<>();
            for (CoursePackageStudent coursePackageStudent : list) {
                longs.add(coursePackageStudent.getCoursePackageSchedulingId());
            }

            System.out.println("======longs========"+longs);
//           List<CoursePackageScheduling> coursePackageSchedulings = coursePackageSchedulingService.list(new QueryWrapper<CoursePackageScheduling>().in("id",longs).isNotNull("courseId"));
           List<AppUserVideoResponse> coursePackageSchedulings1 = coursePackageSchedulingService.queryAll(longs);

           if (search.getSearch()!=null) {
               List<AppUserVideoResponse> filteredList = new ArrayList<>();
               for (AppUserVideoResponse response : coursePackageSchedulings1) {
                   if (response.getVideoName().contains(search.getSearch())) {
                       filteredList.add(response);
                   }
               }
               return ResultUtil.success(filteredList);

           }

            return ResultUtil.success(coursePackageSchedulings1);





//        }catch (Exception e){
//            return ResultUtil.runErr();
//        }
    }

    /**
     * 课后视频详情
     */
    @ResponseBody
    @PostMapping("/api/startCource/afterSourceDetail")
    @ApiOperation(value = "课后练习-课后视频详情", tags = {"APP-开始上课"})
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9....."),
    })
    public ResultUtil<CourseOfVideoResponse> queryAfterSourceDetails( CourseWithDetailsRequest detailsRequest){
        try {
            Integer appUserId = tokenUtil.getUserIdFormRedis();
            if(null == appUserId){
                return ResultUtil.tokenErr();
            }
            return ResultUtil.success(packagePaymentService.queryVideoDetails(detailsRequest,appUserId));
        }catch (Exception e){
            return ResultUtil.runErr();
        }
    }

    @ResponseBody
    @PostMapping("/api/startCource/payCourseInfo")
    @ApiOperation(value = "课后练习-购课详情（用于购课）", tags = {"APP-开始上课"})
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9....."),
    })
    public ResultUtil<PayCourseInfoReq> payCourseInfo(Integer courseId){
        try {
            PayCourseInfoReq payCourseInfoReq = packagePaymentService.payCourseInfo(courseId);

//            Arrays.sort(payCourseInfoReq.getDay(), (a, b) -> a.compareTo(b));

            Collections.sort(payCourseInfoReq.getDay(), Comparator.comparing(String::toString));


            return ResultUtil.success(payCourseInfoReq);
        }catch (Exception e){
            return ResultUtil.runErr();
        }
    }

    @ResponseBody
    @PostMapping("/api/startCource/getMyCourseList")
    @ApiOperation(value = "课后练习-可支付课程列表（用于购课）", tags = {"APP-开始上课"})
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9....."),
    })
    public ResultUtil<List<PayCourseRes>> getMyCourseList(Integer storeId){
        try {
            Integer appUserId = tokenUtil.getUserIdFormRedis();
            if(null == appUserId){
                return ResultUtil.tokenErr();
            }
            return ResultUtil.success(packagePaymentService.getMyCourseList(storeId,appUserId));
        }catch (Exception e){
            return ResultUtil.runErr();
        }
    }

    // 2.0
    @ResponseBody
    @PostMapping("/api/startCource/payCourse")
    @ApiOperation(value = "课后练习-确认购课", tags = {"APP-开始上课"})
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9....."),
    })
    public ResultUtil<?> payCourse(PayCourseReq req){
        try {
            Integer appUserId = tokenUtil.getUserIdFormRedis();
            if(null == appUserId){
                return ResultUtil.tokenErr();
            }
            return packagePaymentService.payCourse(req,appUserId);
        }catch (Exception e){
            return ResultUtil.runErr();
        }
    }

    /**
     * 更新课后视频学习状态
     */
    @ResponseBody
    @PostMapping("/api/startCource/updateVideoStatus")
    @ApiOperation(value = "更新课后视频学习状态", tags = {"APP-开始上课"})
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9....."),
    })
    public ResultUtil updateVideoStatus( UpdateCourseVideoStatusRequest detailsRequest){
        try {
            Integer appUserId = tokenUtil.getUserIdFormRedis();
            if(null == appUserId){
                return ResultUtil.tokenErr();
            }
            return ResultUtil.success(packagePaymentService.updateVideoStatus(detailsRequest,appUserId));
        }catch (Exception e){
            return ResultUtil.runErr();
        }
    }


    @ResponseBody
    @PostMapping("/api/course/getCourseAppUserDetails")
    @ApiOperation(value = "已报名课程-获取课程类型列表", tags = {"APP-课程列表"})
    @ApiImplicitParams({
    })
    public ResultUtil<List<BaseVo>> queryCoursePackageType(){
        try {
            List<TCoursePackageType> coursePackageTypes = coursePackageTypeService.list(new QueryWrapper<TCoursePackageType>().eq("state", 1));
            List<BaseVo> list = new ArrayList<>();
            coursePackageTypes.forEach(c -> {
                BaseVo baseVo = new BaseVo();
                BeanUtils.copyProperties(c, baseVo);
                list.add(baseVo);
            });
            return ResultUtil.success(list);
        }catch (Exception e){
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }


    /**
     * 已报名课程列表
     */
    @ResponseBody
    @PostMapping("/api/startCource/registeredCourses")
    @ApiOperation(value = "已报名课程-课程列表", tags = {"APP-开始上课"})
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9....."),
    })
    public ResultUtil<List<RegisterCourseVo>> queryRegisteredCoursesDetails( CourseOfAfterRequest courseTypeId){
        try {
            Integer appUserId = tokenUtil.getUserIdFormRedis();
            if(null == appUserId){
                return ResultUtil.tokenErr();
            }
            return ResultUtil.success(packagePaymentService.queryRegisteredCourseList(courseTypeId,appUserId));
        }catch (Exception e){
            return ResultUtil.runErr();
        }
    }


    /**
     * 已报名课程详情
     */
    @ResponseBody
    @PostMapping("/api/startCource/RegisteredData")
    @ApiOperation(value = "已报名课程详情", tags = {"APP-开始上课"})
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9....."),
            @ApiImplicitParam(value = "经度", name = "lon", dataType = "string", required = false),
            @ApiImplicitParam(value = "纬度", name = "lat", dataType = "string", required = false),
            @ApiImplicitParam(name = "coursePayId" ,value = "课包记录id",dataType = "long"),
    })
    public ResultUtil<CourseDetailsResponse> getRegisteredData(Long coursePayId, String lon, String lat){
        try {
            Integer appUserId = tokenUtil.getUserIdFormRedis();
            if(null == appUserId){
                return ResultUtil.tokenErr();
            }
            return ResultUtil.success(packagePaymentService.queryRegisteredCourseDetails(coursePayId,appUserId));
        }catch (Exception e){
            e.printStackTrace();
            throw new RuntimeException(e.getMessage());
//            return ResultUtil.runErr();
        }
    }


    /**
     * 已报名课程-支付
     */
    @ResponseBody
    @PostMapping("/api/startCource/payment")
    @ApiOperation(value = "已报名课程-支付", tags = {"APP-开始上课"})
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9....."),
    })
    public ResultUtil continuationOperation(ClasspaymentRequest request){
        try {
            Integer userIdFormRedis = tokenUtil.getUserIdFormRedis();
            if(null == userIdFormRedis){
                return ResultUtil.tokenErr();
            }
            Integer couponId = request.getConponId();
            if(couponId==null || couponId==0){
                request.setConponId(null);
            }
            return packagePaymentService.ContinuationOrpaymentCourse(userIdFormRedis,request);
        }catch (Exception e){
            return ResultUtil.runErr();
        }

    }



    /**
     * 课包续课支付宝支付回调接口
     */
    @PostMapping("/base/coursePackage/alipayRegisteredCoursesCallback")
    public void alipayCallback(HttpServletRequest request, HttpServletResponse response){
        System.err.println("========支付宝支付回调========");
        try {
            Map<String, String> map = payMoneyUtil.alipayCallback(request);
            if(null != map){
                String out_trade_no = map.get("out_trade_no");
                String transaction_id = map.get("transaction_id");
                ResultUtil resultUtil = packagePaymentService.insertVipPaymentCallback(out_trade_no, transaction_id);
                if(resultUtil.getCode() == 200){
                    PrintWriter out = response.getWriter();
                    out.write("success");
                    out.flush();
                    out.close();
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }


    /**
     * 课包续课微信支付回调接口
     */
    @PostMapping("/base/coursePackage/wechatRegisteredCoursesCallback")
    public void weChatCallback(HttpServletRequest request, HttpServletResponse response){
        try {
            Map<String, String> map = payMoneyUtil.weixinpayCallback(request);
            if(null != map){
                String out_trade_no = map.get("out_trade_no");
                String transaction_id = map.get("transaction_id");
                String result = map.get("result");
                ResultUtil resultUtil = packagePaymentService.insertVipPaymentCallback(out_trade_no, transaction_id);
                if(resultUtil.getCode() == 200){
                    PrintWriter out = response.getWriter();
                    out.write(result);
                    out.flush();
                    out.close();
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }




    /**
     * 获取学员剩余课时
     * @param id
     * @return
     */
    @ResponseBody
    @PostMapping("/coursePackagePayment/queryResidueClassHour")
    public Integer queryResidueClassHour(@RequestBody Integer id){
        try {
            List<TCoursePackagePayment> list = packagePaymentService.list(new QueryWrapper<TCoursePackagePayment>().eq("studentId", id).eq("payStatus", 2)
                    .eq("status", 1).eq("state", 1).gt("laveClassHours", 0));
            Integer total = 0;
            for (TCoursePackagePayment coursePackagePayment : list) {
                total += coursePackagePayment.getLaveClassHours();
            }
            return total;
        }catch (Exception e){
            e.printStackTrace();
            return 0;
        }
    }
    /**
     * 获取学员剩余课时
     * @param id
     * @return
     */
    @ResponseBody
    @PostMapping("/coursePackagePayment/queryResidueClassHourById")
    public Integer queryResidueClassHourById(@RequestBody Long id){
        try {
            TCoursePackagePayment list = packagePaymentService.getById(id);
            return list.getLaveClassHours();
        }catch (Exception e){
            e.printStackTrace();
            return 0;
        }
    }


    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;
    }

    @Autowired
    private  TCoursePackageService packageService;
    @Autowired
    CoursePackageStudentService studentService ;
    /**
     * 课程用于支付进行扣减
     * @param paymentDeductionClassHour
     */
    @ResponseBody
    @PostMapping("/coursePackagePayment/paymentDeductionClassHour")
    public void paymentDeductionClassHour(@RequestBody PaymentDeductionClassHour paymentDeductionClassHour){
        try {
            // 2.0 用id进行查询
            TCoursePackagePayment coursePackagePayment= packagePaymentService.getOne(new QueryWrapper<TCoursePackagePayment>().eq("id", paymentDeductionClassHour.getCourseId()).eq("payStatus", 2)
                    .eq("status", 1).eq("state", 1).gt("laveClassHours", 0));
            Integer classHour = paymentDeductionClassHour.getClassHour();
//            for (TCoursePackagePayment coursePackagePayment : list) {
                if (coursePackagePayment.getLaveClassHours().compareTo(classHour) >= 0) {
                    coursePackagePayment.setLaveClassHours(coursePackagePayment.getLaveClassHours() - classHour);
                    coursePackagePayment.setAppUserId(null);
                    packagePaymentService.updateById(coursePackagePayment);

                    CourseCounsum courseCounsum = new CourseCounsum();
                    courseCounsum.setPaymentId(coursePackagePayment.getId());
                    courseCounsum.setChangeType(0);
                    courseCounsum.setNum(classHour);
                    courseCounsum.setInsertTime(new Date());
                    courseCounsum.setReason("报名赛事");
                    courseCounsumService.save(courseCounsum);






                    List<CoursePackageStudent> studentCourse = coursePackageStudentService.list(new QueryWrapper<CoursePackageStudent>().eq("studentId", coursePackagePayment.getStudentId()).eq("coursePackageId", coursePackagePayment.getCoursePackageId()));
                    List<Long> collect = studentCourse.stream().map(CoursePackageStudent::getCoursePackageSchedulingId).collect(Collectors.toList());
                    coursePackageSchedulingService.remove(new QueryWrapper<CoursePackageScheduling>().in("id",collect));
                    coursePackageStudentService.remove(new QueryWrapper<CoursePackageStudent>().eq("studentId", paymentDeductionClassHour.getId()).eq("coursePackageId", coursePackagePayment.getCoursePackageId()));





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

                    TCoursePackagePayment pay = packagePaymentService.getOne(new QueryWrapper<TCoursePackagePayment>().eq("coursePackageId", coursePackagePayment.getCoursePackageId()).eq("studentId", coursePackagePayment.getStudentId()));

                        Date today = new Date();
                    Calendar calendar = Calendar.getInstance();
                    calendar.add(Calendar.DATE, -1);
                    today = calendar.getTime();


                    Integer laveClassHours = pay.getLaveClassHours();
                    Integer codeTime = tCoursePackage.getCodeTime();
                    Integer can = laveClassHours/codeTime;

                    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");

                    Date[] dates = generateDateArray(14,today);
                    for (Date date : dates) {
                        if (count==can){
                            break;
                        }
                        int wei =  cn.hutool.core.date.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.save(coursePackageScheduling);
                                CoursePackageStudent student1 = new CoursePackageStudent();
                                student1.setAppUserId(pay.getAppUserId());
                                student1.setStudentId(pay.getStudentId());
                                student1.setCoursePackageId(pay.getCoursePackageId());
                                student1.setCoursePackagePaymentId(pay.getId());
                                student1.setCoursePackageSchedulingId(coursePackageScheduling.getId());
                                student1.setSignInOrNot(1);
                                student1.setReservationStatus(1);
                                student1.setInsertTime(new Date());
                                studentService.save(student1);
                                count++;
                            }
                        }
                    }




                        // 2.0 少于3课时 推送
                        if (coursePackagePayment.getLaveClassHours() <= 3) {
                            Integer appUserId = coursePackagePayment.getAppUserId();

                            //调用推送
                            HttpHeaders headers = new HttpHeaders();
                            // 以表单的方式提交
                            headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
                            String s1 = appUserId + "_" + "Three";
                            //定时修改排课状态
                            String s = internalRestTemplate.getForObject("http://mb-cloud-gateway/netty/sendMsgToClient?id=" + s1, String.class);
                            JSONObject jsonObject1 = JSON.parseObject(s, JSONObject.class);
                            if (jsonObject1.getIntValue("code") != 200) {
                                System.err.println(jsonObject1.getString("msg"));
                            }
                        }

                        CancelledClasses cancelledClasses = new CancelledClasses();
                        cancelledClasses.setType(2);
                        cancelledClasses.setVoucher(paymentDeductionClassHour.getCode());
                        cancelledClasses.setCoursePackageId(coursePackagePayment.getCoursePackageId());
                        cancelledClasses.setCoursePackagePaymentId(coursePackagePayment.getId());
                        cancelledClasses.setCancelledClassesNumber(classHour);
                        cancelledClasses.setInsertTime(new Date());
                        cancelledClassesService.save(cancelledClasses);

                    }else{
                        CancelledClasses cancelledClasses = new CancelledClasses();
                        cancelledClasses.setType(2);
                        cancelledClasses.setVoucher(paymentDeductionClassHour.getCode());
                        cancelledClasses.setCoursePackageId(coursePackagePayment.getCoursePackageId());
                        cancelledClasses.setCoursePackagePaymentId(coursePackagePayment.getId());
                        cancelledClasses.setCancelledClassesNumber(coursePackagePayment.getLaveClassHours());
                        cancelledClasses.setInsertTime(new Date());
                        cancelledClassesService.save(cancelledClasses);

                        coursePackagePayment.setLaveClassHours(0);
                        packagePaymentService.updateById(coursePackagePayment);

                        classHour -= cancelledClasses.getCancelledClassesNumber();
                    }
//                }


        }catch (Exception e){
            e.printStackTrace();
        }
    }

    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;
    }
    /**
     * 取消赛事回退支付课时
     * @param paymentDeductionClassHour
     */
    @ResponseBody
    @PostMapping("/coursePackagePayment/rollbackPaymentDeductionClassHour")
    public void rollbackPaymentDeductionClassHour(@RequestBody PaymentDeductionClassHour paymentDeductionClassHour){
        try {
            List<CancelledClasses> voucher = cancelledClassesService.list(new QueryWrapper<CancelledClasses>().eq("voucher", paymentDeductionClassHour.getCode()));
            for (CancelledClasses cancelledClasses : voucher) {
                TCoursePackagePayment coursePackagePayment = packagePaymentService.getById(cancelledClasses.getCoursePackagePaymentId());
                coursePackagePayment.setLaveClassHours(coursePackagePayment.getLaveClassHours() + cancelledClasses.getCancelledClassesNumber());
                coursePackagePayment.setAppUserId(null);
                packagePaymentService.updateById(coursePackagePayment);

                cancelledClassesService.removeById(cancelledClasses.getId());
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }


    /**
     * 找出符合门店的课包
     * @param s
     * @return
     */
    @ResponseBody
    @PostMapping("/coursePackagePayment/paymentCompetitionCourseList")
    public List<PayCourseRes> paymentCompetitionCourseList(@RequestBody String s){
        ArrayList<PayCourseRes> objects = new ArrayList<>();

        String[] split = s.split("_");
        // 用户id
        Integer integer = Integer.valueOf(split[0]);
        String s1 = split[1];
        // 门店id
        String[] split1 = s1.split(",");
        ArrayList<Integer> storeIds = new ArrayList<>();
        for (String s2 : split1) {
            storeIds.add(Integer.valueOf(s2));
        }
        List<TCoursePackagePayment> list = packagePaymentService.list(new LambdaQueryWrapper<TCoursePackagePayment>().eq(TCoursePackagePayment::getAppUserId, integer).ge(TCoursePackagePayment::getLaveClassHours, 0).eq(TCoursePackagePayment::getStatus, 1).eq(TCoursePackagePayment::getState, 1));
        for (TCoursePackagePayment tCoursePackagePayment : list) {
            Integer coursePackageId = tCoursePackagePayment.getCoursePackageId();
            TCoursePackage byId = tcpService.getById(coursePackageId);
            if (byId.getType()==3){
                continue;
            }
            if(storeIds.contains(byId.getStoreId())){
                PayCourseRes payCourseRes = new PayCourseRes();
                payCourseRes.setCourseNum(tCoursePackagePayment.getLaveClassHours());
                payCourseRes.setId(tCoursePackagePayment.getId());
                payCourseRes.setName(byId.getName());
                objects.add(payCourseRes);
            }
        }
        return objects;
    }

    @ResponseBody
    @PostMapping("/coursePackagePayment/isHave")
    public Integer isHave(@RequestBody String ids){
        String[] split = ids.split(",");
       return coursePackagePaymentService.count(new QueryWrapper<TCoursePackagePayment>().in("studentId",split));

    }


    /**
     * 课包续费玩湃币支付
     * @param
     */
    @PostMapping("/coursePackagePayment/courseRenewPlayPaiPay")
    public int paymentWanpaiRenewCourse(@RequestBody PlayPaiGoldCoursePackage coursePackage){
        try {
            Integer userIdFormRedis = tokenUtil.getUserIdFormRedis();
            if (null == userIdFormRedis){
                return 2;
            }
            CoursePackagePaymentConfig paymentConfig = icppcService.getById(coursePackage.getCoursePayConfigId());
            AppUser appUser = auClitn.queryAppUser(userIdFormRedis);
            if (appUser.getPlayPaiCoins() < paymentConfig.getPlayPaiCoin()){
                return 3;
            }
            TCoursePackagePayment packagePayment = packagePaymentService.getOne(new QueryWrapper<TCoursePackagePayment>()
                    .eq("code",coursePackage.getCode() ));
            packagePayment.setPayStatus(2);
            packagePayment.setPayUserId(userIdFormRedis);
            packagePayment.setClassHours(paymentConfig.getClassHours());
            packagePayment.setPlayPaiCoin(paymentConfig.getPlayPaiCoin());
            packagePayment.setTotalClassHours(paymentConfig.getClassHours());
            packagePayment.setLaveClassHours(paymentConfig.getClassHours());
            packagePaymentService.updateById(packagePayment);

            appUser.setPlayPaiCoins(appUser.getPlayPaiCoins()-paymentConfig.getPlayPaiCoin());
            auClitn.updateAppUser(appUser);

            // 2.0
            TCourseInfoRecord tCourseInfoRecord = new TCourseInfoRecord();
            tCourseInfoRecord.setUserId(userIdFormRedis);
            tCourseInfoRecord.setCourseId(coursePackage.getCoursePackageId());
            tCourseInfoRecord.setName("续课");
            tCourseInfoRecord.setTime(new Date());
            tCourseInfoRecord.setType(1);
            tCourseInfoRecord.setNum(paymentConfig.getClassHours());
            auClitn.addCourseInfoRecord(tCourseInfoRecord);

            CourseCounsum courseCounsum = new CourseCounsum();
            courseCounsum.setPaymentId(packagePayment.getId());
            courseCounsum.setChangeType(1);
            courseCounsum.setNum(packagePayment.getClassHours());
            courseCounsum.setInsertTime(new Date());
            courseCounsum.setReason("购买课包");
            courseCounsumService.save(courseCounsum);

        } catch (Exception e) {
            return 4;
        }
        return 1;
    }

    @PostMapping("/base/coursePack/getPaymentCoursePackage")
    public TCoursePackagePayment getCoursePackagePaymentByCode(@RequestBody String code){
        return packagePaymentService.getOne(new QueryWrapper<TCoursePackagePayment>()
                .eq("code",code));
    }


    @PostMapping("/base/coursePack/getCoursePackagePaymentById")
    public TCoursePackagePayment getCoursePackagePaymentById(@RequestBody Long id){
        TCoursePackagePayment byId = packagePaymentService.getById(id);
        System.out.println("======byId=========="+byId);
        return byId;
    }


    @PostMapping("/base/coursePack/delPaymentCoursePackage")
    public boolean delPaymentCoursePackage(@RequestBody Integer payId){
        return packagePaymentService.removeById(payId);
    }
    @PostMapping("/base/coursePack/updatePaymentCoursePackage")
    public boolean updatePaymentCoursePackage(@RequestBody TCoursePackagePayment packagePayment){
        boolean id = packagePaymentService.update(packagePayment, new QueryWrapper<TCoursePackagePayment>()
                .eq("id", packagePayment.getId()));
        if(id){
            // 2.0
            TCourseInfoRecord tCourseInfoRecord = new TCourseInfoRecord();
            tCourseInfoRecord.setNum(packagePayment.getTotalClassHours());
            tCourseInfoRecord.setName("续课");
            tCourseInfoRecord.setCourseId(packagePayment.getCoursePackageId());
            tCourseInfoRecord.setUserId(packagePayment.getAppUserId());
            tCourseInfoRecord.setType(1);
            tCourseInfoRecord.setTime(new Date());
            id = appUserClient.addCourseInfoRecord(tCourseInfoRecord);


            CourseCounsum courseCounsum = new CourseCounsum();
            courseCounsum.setPaymentId(packagePayment.getId());
            courseCounsum.setChangeType(1);
            courseCounsum.setNum(packagePayment.getClassHours());
            courseCounsum.setInsertTime(new Date());
            courseCounsum.setReason("续课");
            courseCounsumService.save(courseCounsum);

        }
        return id;
    }

    @PostMapping("/base/coursePack/savePaymentCoursePackage")
    public boolean savePaymentCoursePackage(@RequestBody TCoursePackagePayment packagePayment){

        return packagePaymentService.save(packagePayment);
    }


    @PostMapping("/base/coursePack/orderClass")
    public void orderClass(@RequestBody OrderDto orderDto) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS");
        String code = sdf.format(new Date()) + UUIDUtil.getNumberRandom(5);
        String[] split = orderDto.getStuIds().split(",");
        for (String s : split) {
            TCoursePackagePayment coursePackagePaymentServiceOne = coursePackagePaymentService.getOne(new QueryWrapper<TCoursePackagePayment>().eq("studentId", s).eq("coursePackageId",orderDto.getClassId()));



            if (coursePackagePaymentServiceOne==null) {
                TCoursePackagePayment coursePackagePayment = new TCoursePackagePayment();
                coursePackagePayment.setCode(code);
                coursePackagePayment.setAppUserId(orderDto.getAppUserId());
                coursePackagePayment.setStudentId(Integer.valueOf(s));
                coursePackagePayment.setCoursePackageId(orderDto.getClassId());
                coursePackagePayment.setPayType(4);
                coursePackagePayment.setClassHours(orderDto.getClassHours());
                coursePackagePayment.setTotalClassHours(orderDto.getClassHours());
                coursePackagePayment.setLaveClassHours(orderDto.getClassHours());
                coursePackagePayment.setAbsencesNumber(0);
                coursePackagePayment.setPayUserType(1);
                coursePackagePayment.setPayStatus(2);
                coursePackagePayment.setPayUserId(orderDto.getAppUserId());
                coursePackagePayment.setStatus(1);
                coursePackagePayment.setState(1);
                coursePackagePayment.setInsertTime(new Date());
                coursePackagePaymentService.save(coursePackagePayment);
                Integer sId = null;
                Student student = studentClient.queryDefaultStudent(orderDto.getAppUserId());
                if (student != null) {
                    sId = student.getId();
                }
                addPackageStudent(orderDto.getClassId(), orderDto.getAppUserId(), Integer.valueOf(s), coursePackagePayment.getId());


                CourseCounsum courseCounsum = new CourseCounsum();
                courseCounsum.setPaymentId(coursePackagePayment.getId());
                courseCounsum.setChangeType(1);
                courseCounsum.setNum(orderDto.getClassHours());
                courseCounsum.setInsertTime(new Date());
                courseCounsum.setReason("积分兑换");
                courseCounsumService.save(courseCounsum);

            }else {
                coursePackagePaymentServiceOne.setClassHours(coursePackagePaymentServiceOne.getClassHours()+orderDto.getClassHours());
                coursePackagePaymentServiceOne.setTotalClassHours(coursePackagePaymentServiceOne.getTotalClassHours()+orderDto.getClassHours());
                coursePackagePaymentServiceOne.setLaveClassHours(coursePackagePaymentServiceOne.getLaveClassHours()+orderDto.getClassHours());
                coursePackagePaymentServiceOne.setAppUserId(null);
                coursePackagePaymentService.updateById(coursePackagePaymentServiceOne);

                Integer sId = null;
                Student student = studentClient.queryDefaultStudent(orderDto.getAppUserId());
                if (student != null) {
                    sId = student.getId();
                }
                addPackageStudent(orderDto.getClassId(), orderDto.getAppUserId(), Integer.valueOf(s), coursePackagePaymentServiceOne.getId());


                CourseCounsum courseCounsum = new CourseCounsum();
                courseCounsum.setPaymentId(coursePackagePaymentServiceOne.getId());
                courseCounsum.setChangeType(1);
                courseCounsum.setNum(orderDto.getClassHours());
                courseCounsum.setInsertTime(new Date());
                courseCounsum.setReason("积分兑换");
                courseCounsumService.save(courseCounsum);


            }

        }

    }


    public static Date[] generateDateArray1(Date startDate, Date endDate) {
        List<Date> dateList = new ArrayList<>();
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(startDate);

        while (!calendar.getTime().after(endDate)) {
            Date currentDate = calendar.getTime();
            dateList.add(currentDate);
            calendar.add(Calendar.DAY_OF_MONTH, 1);
        }

        return dateList.toArray(new Date[0]);
    }

    @Autowired
    private TCoursePackageService coursePackageService;
    private void addPackageStudent(Integer courseId, Integer userId, Integer sId,Long paymentId) throws ParseException {
        // 课包
        TCoursePackage tCoursePackage = coursePackageService.getById(courseId);

        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");

            //查出当前用户当前学员当前课包最后一天的排课数据
            List<CoursePackageStudent> studentCourse = coursePackageStudentService.list(new QueryWrapper<CoursePackageStudent>().eq("studentId", sId).eq("coursePackageId", courseId));
            List<Long> collect = studentCourse.stream().map(CoursePackageStudent::getCoursePackageSchedulingId).collect(Collectors.toList());
            //拿到最后一天的排课记录
            if (collect.size() > 0) {
                coursePackageSchedulingService.remove(new QueryWrapper<CoursePackageScheduling>().in("id", collect));
                coursePackageStudentService.remove(new QueryWrapper<CoursePackageStudent>().eq("studentId", sId).eq("coursePackageId", courseId));
            }
            Date today = new Date();
            TCoursePackagePayment pay = coursePackagePaymentService.getById(paymentId);
            Integer laveClassHours = pay.getLaveClassHours();
            Integer codeTime = tCoursePackage.getCodeTime();
            Integer can = 0;
            int count = 0;
            // 本周周几
            Date[] dates = generateDateArray(14, today);
            if (tCoursePackage.getType() == 1) {
                can = laveClassHours / codeTime;
            }
            if (tCoursePackage.getType() == 2) {
                Date startDate = tCoursePackage.getStartTime();
                Date endDate = tCoursePackage.getEndTime();
                dates = generateDateArray1(startDate, endDate);
                can = 999;
            }
            for (Date date : dates) {
                if (count == can) {
                    break;
                }
                int wei = cn.hutool.core.date.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.save(coursePackageScheduling);
                        CoursePackageStudent student1 = new CoursePackageStudent();
                        student1.setAppUserId(userId);
                        student1.setStudentId(sId);
                        student1.setCoursePackageId(tCoursePackage.getId());
                        student1.setCoursePackagePaymentId(paymentId);
                        student1.setCoursePackageSchedulingId(coursePackageScheduling.getId());
                        student1.setSignInOrNot(1);
                        student1.setReservationStatus(1);
                        student1.setInsertTime(new Date());
                        coursePackageStudentService.save(student1);
                        count++;
                    }
                }
            }

        }else if (tCoursePackage.getType()==2){
            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);

            TCoursePackagePayment pay = coursePackagePaymentService.getById(paymentId);


            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.save(coursePackageScheduling);
                        CoursePackageStudent student1 = new CoursePackageStudent();
                        student1.setAppUserId(userId);
                        student1.setStudentId(sId);
                        student1.setCoursePackageId(tCoursePackage.getId());
                        student1.setCoursePackagePaymentId(pay.getId());
                        student1.setCoursePackageSchedulingId(coursePackageScheduling.getId());
                        student1.setSignInOrNot(1);
                        student1.setReservationStatus(1);
                        student1.setInsertTime(new Date());
                        coursePackageStudentService.save(student1);
                        count++;
                    }
                }
            }
        }


        // 2.0
        TCourseInfoRecord tCourseInfoRecord = new TCourseInfoRecord();
        tCourseInfoRecord.setUserId(userId);
        tCourseInfoRecord.setCourseId(courseId);
        tCourseInfoRecord.setName("报名运动营");
        tCourseInfoRecord.setNum(tCoursePackage.getNeedNum());
        tCourseInfoRecord.setTime(new Date());
        tCourseInfoRecord.setType(2);
        appUserClient.addCourseInfoRecord(tCourseInfoRecord);


    }

    @ResponseBody
    @PostMapping("/base/coursePack/obtainStudentClassDetails")
    public List<RecordAppoint> obtainStudentClassDetailsData(@RequestBody WeeksOfCourseRest stuId){
//        try {
            return packagePaymentService.obtainStuClassDetails(stuId.getStuId(),stuId.getAppUserId(),stuId.getPageNum());
//        }catch (Exception e){
//            e.printStackTrace();
//            throw new RuntimeException();
//        }
    }


    @PostMapping("/base/coursePack/getCoursePackageConfig")
    public List<CoursePackagePaymentConfig> getCourseConfigList(@RequestBody Integer coursePackageId){
        return icppcService.list(new QueryWrapper<CoursePackagePaymentConfig>()
                .eq("coursePackageId",coursePackageId));
    }



    @PostMapping("/base/coursePack/getCoursePackagePaymentOfCode")
    public List<TCoursePackagePayment> getCoursePackagePaymentOfCode(@RequestBody String code){
        return packagePaymentService.list(new QueryWrapper<TCoursePackagePayment>()
                .eq("code",code));
    }


    // 2.0 送课时
    @PostMapping("/base/coursePack/sendHours")
    public Integer sendHours(@RequestBody  String s) throws ParseException {
        String[] split2 = s.split("_");
        TCoursePackagePayment byId = packagePaymentService.getById(Long.valueOf(split2[0]));
        byId.setTotalClassHours(byId.getTotalClassHours()+Integer.valueOf(split2[2]));
        boolean b = packagePaymentService.updateHoursById(byId,Integer.valueOf(split2[2]));

        CourseCounsum courseCounsum = new CourseCounsum();
        courseCounsum.setPaymentId(byId.getId());
        courseCounsum.setChangeType(1);
        courseCounsum.setNum(Integer.valueOf(split2[2]));
        courseCounsum.setInsertTime(new Date());
        courseCounsum.setReason("介绍有礼");
        courseCounsumService.save(courseCounsum);


        List<CoursePackageStudent> studentCourse = coursePackageStudentService.list(new QueryWrapper<CoursePackageStudent>().eq("studentId", byId.getStudentId()).eq("coursePackageId", byId.getCoursePackageId()));
        List<Long> collect = studentCourse.stream().map(CoursePackageStudent::getCoursePackageSchedulingId).collect(Collectors.toList());
        coursePackageSchedulingService.remove(new QueryWrapper<CoursePackageScheduling>().in("id",collect));
        coursePackageStudentService.remove(new QueryWrapper<CoursePackageStudent>().eq("studentId", byId.getStudentId()).eq("coursePackageId", byId.getCoursePackageId()));





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

        TCoursePackagePayment pay = packagePaymentService.getOne(new QueryWrapper<TCoursePackagePayment>().eq("coursePackageId", byId.getCoursePackageId()).eq("studentId", byId.getStudentId()));

        Date today = new Date();

        Integer laveClassHours = pay.getLaveClassHours();
        Integer codeTime = tCoursePackage.getCodeTime();
        Integer can = laveClassHours/codeTime;

        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");

        Date[] dates = generateDateArray(14,today);
        for (Date date : dates) {
            if (count==can){
                break;
            }
            int wei =  cn.hutool.core.date.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.save(coursePackageScheduling);
                    CoursePackageStudent student1 = new CoursePackageStudent();
                    student1.setAppUserId(pay.getAppUserId());
                    student1.setStudentId(pay.getStudentId());
                    student1.setCoursePackageId(pay.getCoursePackageId());
                    student1.setCoursePackagePaymentId(pay.getId());
                    student1.setCoursePackageSchedulingId(coursePackageScheduling.getId());
                    student1.setSignInOrNot(1);
                    student1.setReservationStatus(1);
                    student1.setInsertTime(new Date());
                    studentService.save(student1);
                    count++;
                }
            }
        }









        if(b){
            return 1;
        }else {

            return 0;
        }
    }


    /**
     * 查询课时
     * @param courseConfigId
     * @return
     */
    @PostMapping("/base/coursePack/getClassHour")
    public Integer getClassHour(@RequestBody Integer courseConfigId){
        CoursePackagePaymentConfig byId = icppcService.getById(courseConfigId);
        return byId.getClassHours();
    }

    /**
     * 获取课包报名信息列表
     * @param queryRegistrationRecord
     * @return
     */
    @ResponseBody
    @PostMapping("/coursePackagePayment/queryRegistrationRecord")
    public Page<Map<String, Object>> queryRegistrationRecord(@RequestBody QueryRegistrationRecord queryRegistrationRecord){
        Page<Map<String, Object>> page = new PageFactory<Map<String, Object>>().defaultPage(queryRegistrationRecord.getLimit(), queryRegistrationRecord.getOffset(), queryRegistrationRecord.getSort(), queryRegistrationRecord.getOrder());
        Page<Map<String, Object>> mapPage = page.setRecords(packagePaymentService.queryRegistrationRecord(page, queryRegistrationRecord));
        return mapPage;
    }


    /**
     * 获取未预约排课学员列表
     * @param queryWalkInStudentList
     * @return
     */
    @ResponseBody
    @PostMapping("/coursePackagePayment/queryWalkInStudentList")
    public Page<Map<String, Object>> queryWalkInStudentList(@RequestBody QueryWalkInStudentList queryWalkInStudentList){
        Page<Map<String, Object>> page = new PageFactory<Map<String, Object>>().defaultPage(queryWalkInStudentList.getLimit(), queryWalkInStudentList.getOffset(), queryWalkInStudentList.getSort(), queryWalkInStudentList.getOrder());
        Page<Map<String, Object>> mapPage = page.setRecords(packagePaymentService.queryWalkInStudentList(page, queryWalkInStudentList));
        return mapPage;
    }


    /**
     * 根据id获取数据
     * @param id
     * @return
     */
    @ResponseBody
    @PostMapping("/coursePackagePayment/queryCoursePackagePaymentById")
    public TCoursePackagePayment queryCoursePackagePaymentById(@RequestParam("id")Long id){
        return packagePaymentService.getById(id);
    }


    @ResponseBody
    @PostMapping("/coursePackagePayment/CountqueryByClassId")
   public   Integer  CountqueryByClassId(@RequestBody Integer id){
        int coursePackageId = packagePaymentService.count(new QueryWrapper<TCoursePackagePayment>().eq("coursePackageId", id));


        return coursePackageId;
    }


    /**
     * 修改数据
     * @param coursePackagePayment
     */
    @ResponseBody
    @PostMapping("/coursePackagePayment/editCoursePackagePayment")
    public void editCoursePackagePayment(TCoursePackagePayment coursePackagePayment){
        coursePackagePayment.setAppUserId(null);
        packagePaymentService.updateById(coursePackagePayment);
    }



    /**
     * 修改数据
     * @param coursePackagePayment
     */
    @ResponseBody
    @PostMapping("/coursePackagePayment/editCoursePackagePayment1")
    public void editCoursePackagePayment1(@RequestBody TCoursePackagePayment coursePackagePayment){
        System.out.println("editCoursePackagePayment1====coursePackagePayment"+coursePackagePayment);
//        coursePackagePayment.setCoursePackageId(null);
        packagePaymentService.updateBytime(coursePackagePayment);
    }


    /**
     * 上课主页-预约操作
     */
    @ResponseBody
    @PostMapping("/api/startCource/reverse")
    @ApiOperation(value = "上课主页-预约操作--2.0改请假操作", tags = {"APP-开始上课"})
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9....."),
            @ApiImplicitParam(value = "课包id", name = "courseID", required = true, dataType = "String"),
            @ApiImplicitParam(value = "时间 yyyy-MM-dd", name = "time", required = true, dataType = "String"),
            @ApiImplicitParam(value = "学员id", name = "stuId", required = true, dataType = "int"),
    })
    public ResultUtil reverse(String courseID,String time,Integer stuId){
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        try {
            Integer appUserId = tokenUtil.getUserIdFormRedis();
            if(null == appUserId){
                return ResultUtil.tokenErr();
            }
            List<TCoursePackagePayment> packagePayment = packagePaymentService.list(new LambdaQueryWrapper<TCoursePackagePayment>()
                    .eq(TCoursePackagePayment::getCoursePackageId,courseID )
                    .eq(TCoursePackagePayment::getAppUserId,appUserId)
                    .eq(TCoursePackagePayment::getStudentId,stuId)
            );

            if (ToolUtil.isEmpty(packagePayment) || packagePayment.size()==0){
                return ResultUtil.error("该用户未购买该课包");
            }
            List<CoursePackageScheduling> coursePackageSchedulings = coursePackageSchedulingMapper.selectList(new LambdaQueryWrapper<CoursePackageScheduling>()
                    .eq(CoursePackageScheduling::getCoursePackageId, Integer.valueOf(courseID))
                    .like(CoursePackageScheduling::getClassDate, time)
            );

            List<CoursePackageStudent> coursePackageStudent = cspsService.list(new LambdaQueryWrapper<CoursePackageStudent>()
                    .in(CoursePackageStudent::getCoursePackagePaymentId,packagePayment.stream().map(TCoursePackagePayment::getId).collect(Collectors.toList()))
                    .in(CoursePackageStudent::getCoursePackageSchedulingId,coursePackageSchedulings.stream().map(CoursePackageScheduling::getId).collect(Collectors.toList()))
                    .eq(CoursePackageStudent::getCoursePackageId,courseID)
                    .eq(CoursePackageStudent::getStudentId,stuId)
                    .eq(CoursePackageStudent::getAppUserId,appUserId)
            );

            if (ToolUtil.isNotEmpty(coursePackageStudent)){
                for (CoursePackageStudent packageStudent : coursePackageStudent) {
                    if(packageStudent.getReservationStatus()==1){
                        packageStudent.setSignInOrNot(2);
                        cspsService.updateSignInOrNotById(packageStudent.getId());
                    }
                }

            }else {
            }
            return ResultUtil.success();
        }catch (Exception e){
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }



    @ResponseBody
    @PostMapping("/base/coursePack/getConsumes")
    List<CourseCounsum> getConsumes(@RequestBody BillingDataRequestVo requestVo) {
        Integer[] integers = {2,3};
        QueryWrapper<CourseCounsum> courseCounsumQueryWrapper = new QueryWrapper<CourseCounsum>().in("changeType",integers).eq("appUserId",requestVo.getAppUserId());
        if (requestVo.getMonthEnd()!=null){
            courseCounsumQueryWrapper.ge("insertTime",requestVo.getMonthStart());
            courseCounsumQueryWrapper.le("insertTime",requestVo.getMonthEnd());
        }
    return     courseCounsumService.list(courseCounsumQueryWrapper);

    }

    @ResponseBody
    @PostMapping("/base/coursePack/weeksOfCourseDetailsList")
    HashMap<String, Object> weeksOfCourseDetailsList(@RequestBody CourseDetailReq courseDetailReq){
        HashMap<String, Object> map = new HashMap<>();
        ArrayList<DetailsListVo> objects = new ArrayList<>();
//        try {
            String time = courseDetailReq.getTime();
        Date parse = null;
        try {
            parse = new SimpleDateFormat("yyyy-MM-dd").parse(time);
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }
        int i = cn.hutool.core.date.DateUtil.dayOfWeek(parse)-1;
            String week = week(i);
            Store store = sreClient.queryStoreById(courseDetailReq.getStoreId());
            String lat = store.getLat();
            String lon = store.getLon();

            Map<String, Double> distance = GeodesyUtil.getDistance(courseDetailReq.getLon() + "," + courseDetailReq.getLat(), lon + "," + lat);
            double wgs84 = distance.get("WGS84") / 1000;
            map.put("distance",wgs84);
            map.put("name",store.getName());
            map.put("lon",lon);
            map.put("lat",lat);

            String time1 = courseDetailReq.getTime();

            // 找出门店的所有课程 排出体验
            List<TCoursePackage> list = tcpService.list(new LambdaQueryWrapper<TCoursePackage>().eq(TCoursePackage::getStoreId, courseDetailReq.getStoreId()).ne(TCoursePackage::getType, 3).eq(TCoursePackage::getState,1).like(TCoursePackage::getClassWeeks,week));
            List<Integer> collect = list.stream().map(TCoursePackage::getId).collect(Collectors.toList());
            if(collect.size()==0){
                collect.add(-1);
            }
            // 找出购买的课包
            List<TCoursePackagePayment> list1 = packagePaymentService.list(new LambdaQueryWrapper<TCoursePackagePayment>().eq(TCoursePackagePayment::getAppUserId, courseDetailReq.getAppUserId()).eq(TCoursePackagePayment::getStudentId, courseDetailReq.getStuId()).in(TCoursePackagePayment::getCoursePackageId, collect));
            List<Integer> collect1 = list1.stream().map(TCoursePackagePayment::getCoursePackageId).collect(Collectors.toList());
            List<Long> ids = list1.stream().map(TCoursePackagePayment::getId).collect(Collectors.toList());


            for (TCoursePackage tCoursePackage : list) {
                DetailsListVo detailsListVo = new DetailsListVo();
                detailsListVo.setId(tCoursePackage.getId());
                detailsListVo.setName(tCoursePackage.getName());
                detailsListVo.setCourseType(tCoursePackage.getType());
                String classStartTime = tCoursePackage.getClassStartTime();
                String[] split = classStartTime.split(",");
                String classEndTime = tCoursePackage.getClassEndTime();
                String[] split1 = classEndTime.split(",");
                ArrayList<String> strings = new ArrayList<>();
                if(ToolUtil.isNotEmpty(classStartTime)){
                    for (int i1 = 0; i1 < split.length; i1++) {
                        String s = split[i1].substring(0,5) + "-" + split1[i1].substring(0,5);
                        strings.add(s);
                    }
                }
                if (detailsListVo.getCourseType()==1) {
                    detailsListVo.setTime(strings);
                }else {
                    Date startTime = tCoursePackage.getStartTime();
                    Date endTime = tCoursePackage.getEndTime();
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                    String formattedStartTime = sdf.format(startTime);
                    String formattedEndTime = sdf.format(endTime);

                    String result = formattedStartTime + "至" + formattedEndTime;
                    List<String> stringLists = new ArrayList<>();
                    stringLists.add(result);
                    detailsListVo.setTime(stringLists);

                }
                //价格
                List<CoursePackagePaymentConfig> list2 = icppcService.list(new LambdaQueryWrapper<CoursePackagePaymentConfig>().eq(CoursePackagePaymentConfig::getCoursePackageId, tCoursePackage.getId()).orderByAsc(CoursePackagePaymentConfig::getCashPayment));
                if (list2.size() > 0) {
                    Double cashPayment = list2.get(0).getCashPayment();
                    detailsListVo.setMoney(cashPayment);
                }
                detailsListVo.setNum(tCoursePackage.getNeedNum());
                if (collect1.contains(tCoursePackage.getId())) {
                    // 找出排课记录
                    List<CoursePackageScheduling> list3 = coursePackageSchedulingMapper.selectList(new LambdaQueryWrapper<CoursePackageScheduling>()
                            .eq(CoursePackageScheduling::getCoursePackageId, tCoursePackage.getId())
                            .like(CoursePackageScheduling::getClassDate, courseDetailReq.getTime())
                    );
                    if(list3.size()==0){
                        detailsListVo.setType(2);
                        objects.add(detailsListVo);
                        continue;
                    }
                    //排课的ids
                    List<Long> collect2 = list3.stream().map(CoursePackageScheduling::getId).collect(Collectors.toList());
                    if(collect2.size()==0){
                        collect2.add(-1l);
                    }


                    List<CoursePackageStudent> list4 = cspsService.list(new LambdaQueryWrapper<CoursePackageStudent>()
                            .eq(CoursePackageStudent::getAppUserId, courseDetailReq.getAppUserId())
                            .eq(CoursePackageStudent::getCoursePackageId, tCoursePackage.getId())
                            .in(CoursePackageStudent::getCoursePackageSchedulingId, collect2).
                                    in(CoursePackageStudent::getCoursePackagePaymentId, ids)
                    );

                    List<CoursePackageStudent> list5 = cspsService.list(new QueryWrapper<CoursePackageStudent>().eq("studentId", courseDetailReq.getStuId()).eq("coursePackageId",tCoursePackage.getId()));

                    if(list5.size()>0&&list4.size()>0){
                        Integer signInOrNot = list4.get(0).getSignInOrNot();
                        detailsListVo.setType(1);

                        if(signInOrNot==2){
                            detailsListVo.setType(3);
                        }
                        detailsListVo.setIsType(list4.get(0).getType());

                        for (CoursePackageStudent coursePackageStudent : list4) {
                            Integer signInOrNot1 = coursePackageStudent.getSignInOrNot();
                            detailsListVo.setType(1);

                            if(signInOrNot1==2){
                                detailsListVo.setType(3);
                            }
                            detailsListVo.setIsType(coursePackageStudent.getType());
                            CoursePackageScheduling coursePackageScheduling = coursePackageSchedulingMapper.selectById(coursePackageStudent.getCoursePackageSchedulingId());
                            Date classDate = coursePackageScheduling.getClassDate();
                            Date endDate = coursePackageScheduling.getEndDate();
                            SimpleDateFormat sdf = new SimpleDateFormat("HH:mm");
                            String formattedClassDate = sdf.format(classDate);
                            String formattedEndDate = sdf.format(endDate);

                            String result = formattedClassDate + "-" + formattedEndDate;
                            List<String> strings1 =new ArrayList<>();
                            strings1.add(result);
                            detailsListVo.setTime(strings1);
                            DetailsListVo detailsListVo1 = new DetailsListVo();

//                            detailsListVo1.setId(coursePackageStudent.getId());
                            BeanUtils.copyProperties(detailsListVo,detailsListVo1);
                            objects.add(detailsListVo1);
                        }





                    }else {
                        detailsListVo.setType(2);
                        objects.add(detailsListVo);

                    }

                } else {
                    detailsListVo.setType(2);
                    objects.add(detailsListVo);

                }
//                objects.add(detailsListVo);
            }
            map.put("data",objects);

            return map;
//        } catch (ParseException e) {
//            e.printStackTrace();
//        }
//        return map;
    }

    private String week(int i){
        String a = "";
        switch (i){
            case 1:
                a="周一";
                break;
            case 2:
                a="周二";
                break;
            case 3:
                a="周三";
                break;
            case 4:
                a="周四";
                break;
            case 5:
                a="周五";
                break;
            case 6:
                a="周六";
                break;
            case 7:
                a="周日";
                break;
        }
        return a;
    }


    @ResponseBody
    @PostMapping("/coursePackagePayment/queryCourseData")
    public List<Map<String,Object>> queryCourseData(@RequestBody List<Integer> ids){
        // 找出课程类型  找出剩余的课时数
        List<TCoursePackageType> list = coursePackageTypeService.list();
        if(ids.size()==0){
            ids.add(-1);
        }
        List<TCoursePackagePayment> list1 = packagePaymentService.listOne(ids);
        List<Integer> collect = list1.stream().map(TCoursePackagePayment::getCoursePackageId).collect(Collectors.toList());
        if(collect.size()==0){
            collect.add(-1);
        }
        List<TCoursePackage> list2 = tcpService.list(new LambdaQueryWrapper<TCoursePackage>().in(TCoursePackage::getId, collect));
        for (TCoursePackagePayment tCoursePackagePayment : list1) {
            for (TCoursePackage tCoursePackage : list2) {
                if(tCoursePackagePayment.getCoursePackageId().equals(tCoursePackage.getId())){
                    tCoursePackagePayment.setType(tCoursePackage.getType());
                }
            }
        }


        List<Map<String,Object>> mapList = new ArrayList<>();
        for (TCoursePackageType tCoursePackageType : list) {
            HashMap<String, Object> map = new HashMap<>();
            map.put("name",tCoursePackageType.getName());
            int a =0;
            for (TCoursePackagePayment tCoursePackagePayment : list1) {
                if(tCoursePackagePayment.getType().equals(tCoursePackageType.getId())){
                    a += tCoursePackagePayment.getLaveClassHours();
                }
            }
            map.put("value",a);
            mapList.add(map);
        }


        return mapList;
    }



    @ResponseBody
    @PostMapping("/coursePackagePayment/coursePt")
    HashMap<String, Object> coursePt(@RequestBody List<Integer> userPt){
        if(userPt.size()==0){
            userPt.add(-1);
        }
        HashMap<String, Object> map = new HashMap<>();
        List<TCoursePackagePayment> tCoursePackagePayments = packagePaymentService.listOne(userPt);
        int sum = tCoursePackagePayments.stream().mapToInt(TCoursePackagePayment::getTotalClassHours).sum();
        int sum1 = tCoursePackagePayments.stream().mapToInt(TCoursePackagePayment::getLaveClassHours).sum();
        map.put("allCourse",sum-sum1);

        //所有课包
        List<TCoursePackage> coursePackages = tcpService.list();


        // 年
        List<CoursePackageStudent> list = cspsService.list(new LambdaQueryWrapper<CoursePackageStudent>().in(CoursePackageStudent::getAppUserId, userPt));


        for (CoursePackageStudent coursePackageStudent : list) {
            for (TCoursePackage coursePackage : coursePackages) {
                if(coursePackageStudent.getCoursePackageId().equals(coursePackage.getId())){
                    if(ToolUtil.isEmpty(coursePackage.getNeedNum())){
                        coursePackageStudent.setNeedNum(0);
                    }else {
                        coursePackageStudent.setNeedNum(coursePackage.getNeedNum());
                    }
                }
            }
        }

        ArrayList<Object> integers = new ArrayList<>();
        int year = cn.hutool.core.date.DateUtil.year(new Date());
        for (int i = 0; i < 10; i++) {
            integers.add(year-i);
        }
        List<Object> collect = integers.stream().sorted().collect(Collectors.toList());
        // 年
        ArrayList<Integer> years = new ArrayList<>();
        for (Object o : collect) {
            String s = o.toString();
            List<CoursePackageStudent> collect1 = list.stream().filter(e -> e.getInsertTime().toString().contains(s)).filter(student -> student.getNeedNum() != null).collect(Collectors.toList());
            int sum2 = collect1.stream().mapToInt(CoursePackageStudent::getNeedNum).sum();
            years.add(sum2);
        }

        map.put("yearData",years);



        ArrayList<Integer> months = new ArrayList<>();

        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");


        // 月
        for (int i = 1; i <= 12; i++) {
            String m=i+"";
            if(i<10){
                m="0"+i;
            }
            String s = year + "-" + m;
            List<CoursePackageStudent> collect1 = list.stream().filter(e -> format.format(e.getInsertTime()).contains(s)).filter(student -> student.getNeedNum() != null).collect(Collectors.toList());
            int sum2 = collect1.stream().mapToInt(CoursePackageStudent::getNeedNum).sum();
            months.add(sum2);
        }
        map.put("monthData",months);

        // 周
        // 获取最近四周
        LocalDateTime minNow = LocalDateTime.now().with(LocalTime.MIN);
        LocalDateTime maxNow = LocalDateTime.now().with(LocalTime.MAX);
        // 周度数据
        LocalDateTime s1 = minNow.minusDays(6);
        LocalDateTime s2 = maxNow;

        LocalDateTime s3 = minNow.minusDays(13);
        LocalDateTime s4 = maxNow.minusDays(6);


        LocalDateTime s5 = minNow.minusDays(20);
        LocalDateTime s6 = maxNow.minusDays(13);

        LocalDateTime s7 = minNow.minusDays(27);
        LocalDateTime s8 = maxNow.minusDays(20);
        ArrayList<Object> weekData = new ArrayList<>();

        int count  = 0;

        int count1 = 0;

        int count2 = 0;

        int count3 = 0;
        for (CoursePackageStudent coursePackageStudent : list) {
            if (coursePackageStudent.getNeedNum()==null){
                continue;
            }
            // 如果到课状态为否 则不计算
            if (coursePackageStudent.getSignInOrNot() != 0) {
                Date insertTime = coursePackageStudent.getInsertTime();
                Instant instant = insertTime.toInstant();
                ZoneId zoneId = ZoneId.systemDefault();
                LocalDateTime dateTime = instant.atZone(zoneId).toLocalDateTime();
                if (dateTime.isAfter(s1) && dateTime.isBefore(s2)){

                    count+=coursePackageStudent.getNeedNum();
                }else if(dateTime.isAfter(s3) && dateTime.isBefore(s4)){
                    count1+=coursePackageStudent.getNeedNum();
                }else if(dateTime.isAfter(s5) && dateTime.isBefore(s6)){
                    count2+=coursePackageStudent.getNeedNum();
                }else if(dateTime.isAfter(s7) && dateTime.isBefore(s8)){
                    count3+=coursePackageStudent.getNeedNum();
                }

            }
        }
        weekData.add(count3);
        weekData.add(count2);
        weekData.add(count1);
        weekData.add(count);

        map.put("weekData",weekData);


        LocalDateTime currentDateTime = LocalDateTime.now();
        List<Integer> amountByDay = new ArrayList<>(Collections.nCopies(7,0));
        for (CoursePackageStudent coursePackageStudent : list) {
            Date insertTime = coursePackageStudent.getInsertTime();
            // 将 Date 转换为 LocalDateTime
            LocalDateTime insertDateTime = LocalDateTime.ofInstant(insertTime.toInstant(), ZoneId.systemDefault());
            // 计算日期与当前日期的差距
            long daysDifference = ChronoUnit.DAYS.between(insertDateTime.toLocalDate(), currentDateTime.toLocalDate());
            // 如果日期在七天内，累加金额
            if (daysDifference >= 0 && daysDifference < 7) {
                int index = (int) (6 - daysDifference); // 计算对应的索引位置
                Integer needNum = coursePackageStudent.getNeedNum();
                if (needNum!=null){
                    int i = amountByDay.get(index) + needNum;
                    amountByDay.set(index, i);
                }

            }
        }
        map.put("dayData", amountByDay);

        return map;

    }
    @ResponseBody
    @PostMapping("/coursePackagePayment/courseYys")
    HashMap<String, Object> courseYys(@RequestBody List<Integer> userPt){
        if(userPt.size()==0){
            userPt.add(-1);
        }
        HashMap<String, Object> map = new HashMap<>();
        List<TCoursePackagePayment> tCoursePackagePayments = packagePaymentService.listOne(userPt);
        int sum = tCoursePackagePayments.stream().mapToInt(TCoursePackagePayment::getTotalClassHours).sum();
        int sum1 = tCoursePackagePayments.stream().mapToInt(TCoursePackagePayment::getLaveClassHours).sum();
        map.put("allCourse",sum-sum1);

        //所有课包
        List<TCoursePackage> coursePackages = tcpService.list();


        // 年
        List<CoursePackageStudent> list = cspsService.list(new LambdaQueryWrapper<CoursePackageStudent>().in(CoursePackageStudent::getAppUserId, userPt));


        for (CoursePackageStudent coursePackageStudent : list) {
            for (TCoursePackage coursePackage : coursePackages) {
                if(coursePackageStudent.getCoursePackageId().equals(coursePackage.getId())){
                    if(ToolUtil.isEmpty(coursePackage.getNeedNum())){
                        coursePackageStudent.setNeedNum(0);
                    }else {
                        coursePackageStudent.setNeedNum(coursePackage.getNeedNum());
                    }
                }
            }
        }

        ArrayList<Object> integers = new ArrayList<>();
        int year = cn.hutool.core.date.DateUtil.year(new Date());
        for (int i = 0; i < 10; i++) {
            integers.add(year-i);
        }
        List<Object> collect = integers.stream().sorted().collect(Collectors.toList());
        // 年
        ArrayList<Integer> years = new ArrayList<>();
        for (Object o : collect) {
            String s = o.toString();
            List<CoursePackageStudent> collect1 = list.stream().filter(e -> e.getInsertTime().toString().contains(s)).filter(student -> student.getNeedNum() != null).collect(Collectors.toList());
            int sum2 = collect1.stream().mapToInt(CoursePackageStudent::getNeedNum).sum();
            years.add(sum2);
        }

        map.put("yearData",years);



        ArrayList<Integer> months = new ArrayList<>();

        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");


        // 月
        for (int i = 1; i <= 12; i++) {
            String m=i+"";
            if(i<10){
                m="0"+i;
            }
            String s = year + "-" + m;
            List<CoursePackageStudent> collect1 = list.stream().filter(e -> format.format(e.getInsertTime()).contains(s)).filter(student -> student.getNeedNum() != null).collect(Collectors.toList());
            int sum2 = collect1.stream().mapToInt(CoursePackageStudent::getNeedNum).sum();
            months.add(sum2);
        }
        map.put("monthData",months);

        // 周
        // 获取最近四周
        LocalDateTime minNow = LocalDateTime.now().with(LocalTime.MIN);
        LocalDateTime maxNow = LocalDateTime.now().with(LocalTime.MAX);
        // 周度数据
        LocalDateTime s1 = minNow.minusDays(6);
        LocalDateTime s2 = maxNow;

        LocalDateTime s3 = minNow.minusDays(13);
        LocalDateTime s4 = maxNow.minusDays(6);


        LocalDateTime s5 = minNow.minusDays(20);
        LocalDateTime s6 = maxNow.minusDays(13);

        LocalDateTime s7 = minNow.minusDays(27);
        LocalDateTime s8 = maxNow.minusDays(20);
        ArrayList<Object> weekData = new ArrayList<>();

        int count  = 0;

        int count1 = 0;

        int count2 = 0;

        int count3 = 0;
        for (CoursePackageStudent coursePackageStudent : list) {
            if (coursePackageStudent.getNeedNum()==null){
                continue;
            }
            // 如果到课状态为否 则不计算
            if (coursePackageStudent.getSignInOrNot() != 0) {
                Date insertTime = coursePackageStudent.getInsertTime();
                Instant instant = insertTime.toInstant();
                ZoneId zoneId = ZoneId.systemDefault();
                LocalDateTime dateTime = instant.atZone(zoneId).toLocalDateTime();
                if (dateTime.isAfter(s1) && dateTime.isBefore(s2)){

                    count+=coursePackageStudent.getNeedNum();
                }else if(dateTime.isAfter(s3) && dateTime.isBefore(s4)){
                    count1+=coursePackageStudent.getNeedNum();
                }else if(dateTime.isAfter(s5) && dateTime.isBefore(s6)){
                    count2+=coursePackageStudent.getNeedNum();
                }else if(dateTime.isAfter(s7) && dateTime.isBefore(s8)){
                    count3+=coursePackageStudent.getNeedNum();
                }

            }
        }
        weekData.add(count3);
        weekData.add(count2);
        weekData.add(count1);
        weekData.add(count);

        map.put("weekData",weekData);


        LocalDateTime currentDateTime = LocalDateTime.now();
        List<Integer> amountByDay = new ArrayList<>(Collections.nCopies(7,0));
        for (CoursePackageStudent coursePackageStudent : list) {
            Date insertTime = coursePackageStudent.getInsertTime();
            // 将 Date 转换为 LocalDateTime
            LocalDateTime insertDateTime = LocalDateTime.ofInstant(insertTime.toInstant(), ZoneId.systemDefault());
            // 计算日期与当前日期的差距
            long daysDifference = ChronoUnit.DAYS.between(insertDateTime.toLocalDate(), currentDateTime.toLocalDate());
            // 如果日期在七天内，累加金额
            if (daysDifference >= 0 && daysDifference < 7) {
                int index = (int) (6 - daysDifference); // 计算对应的索引位置
                Integer needNum = coursePackageStudent.getNeedNum();
                if (needNum!=null){
                    int i = amountByDay.get(index) + needNum;
                    amountByDay.set(index, i);
                }

            }
        }
        map.put("dayData", amountByDay);

        return map;

    }
    @ResponseBody
    @PostMapping("/coursePackagePayment/courseStore")
    HashMap<String, Object> courseStore(@RequestBody List<Integer> userPt){
        if(userPt.size()==0){
            userPt.add(-1);
        }
        HashMap<String, Object> map = new HashMap<>();
        List<TCoursePackagePayment> tCoursePackagePayments = packagePaymentService.listOne(userPt);
        int sum = tCoursePackagePayments.stream().mapToInt(TCoursePackagePayment::getTotalClassHours).sum();
        int sum1 = tCoursePackagePayments.stream().mapToInt(TCoursePackagePayment::getLaveClassHours).sum();
        map.put("allCourse",sum-sum1);

        //所有课包
        List<TCoursePackage> coursePackages = tcpService.list();


        // 年
        List<CoursePackageStudent> list = cspsService.list(new LambdaQueryWrapper<CoursePackageStudent>().in(CoursePackageStudent::getAppUserId, userPt));


        for (CoursePackageStudent coursePackageStudent : list) {
            for (TCoursePackage coursePackage : coursePackages) {
                if(coursePackageStudent.getCoursePackageId().equals(coursePackage.getId())){
                    if(ToolUtil.isEmpty(coursePackage.getNeedNum())){
                        coursePackageStudent.setNeedNum(0);
                    }else {
                        coursePackageStudent.setNeedNum(coursePackage.getNeedNum());
                    }
                }
            }
        }

        ArrayList<Object> integers = new ArrayList<>();
        int year = cn.hutool.core.date.DateUtil.year(new Date());
        for (int i = 0; i < 10; i++) {
            integers.add(year-i);
        }
        List<Object> collect = integers.stream().sorted().collect(Collectors.toList());
        // 年
        ArrayList<Integer> years = new ArrayList<>();
        for (Object o : collect) {
            String s = o.toString();
            List<CoursePackageStudent> collect1 = list.stream().filter(e -> e.getInsertTime().toString().contains(s)).filter(student -> student.getNeedNum() != null).collect(Collectors.toList());
            int sum2 = collect1.stream().mapToInt(CoursePackageStudent::getNeedNum).sum();
            years.add(sum2);
        }

        map.put("yearData",years);



        ArrayList<Integer> months = new ArrayList<>();

        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");


        // 月
        for (int i = 1; i <= 12; i++) {
            String m=i+"";
            if(i<10){
                m="0"+i;
            }
            String s = year + "-" + m;
            List<CoursePackageStudent> collect1 = list.stream().filter(e -> format.format(e.getInsertTime()).contains(s)).filter(student -> student.getNeedNum() != null).collect(Collectors.toList());
            int sum2 = collect1.stream().mapToInt(CoursePackageStudent::getNeedNum).sum();
            months.add(sum2);
        }
        map.put("monthData",months);

        // 周
        // 获取最近四周
        LocalDateTime minNow = LocalDateTime.now().with(LocalTime.MIN);
        LocalDateTime maxNow = LocalDateTime.now().with(LocalTime.MAX);
        // 周度数据
        LocalDateTime s1 = minNow.minusDays(6);
        LocalDateTime s2 = maxNow;

        LocalDateTime s3 = minNow.minusDays(13);
        LocalDateTime s4 = maxNow.minusDays(6);


        LocalDateTime s5 = minNow.minusDays(20);
        LocalDateTime s6 = maxNow.minusDays(13);

        LocalDateTime s7 = minNow.minusDays(27);
        LocalDateTime s8 = maxNow.minusDays(20);
        ArrayList<Object> weekData = new ArrayList<>();

        int count  = 0;

        int count1 = 0;

        int count2 = 0;

        int count3 = 0;
        for (CoursePackageStudent coursePackageStudent : list) {
            if (coursePackageStudent.getNeedNum()==null){
                continue;
            }
            // 如果到课状态为否 则不计算
            if (coursePackageStudent.getSignInOrNot() != 0) {
                Date insertTime = coursePackageStudent.getInsertTime();
                Instant instant = insertTime.toInstant();
                ZoneId zoneId = ZoneId.systemDefault();
                LocalDateTime dateTime = instant.atZone(zoneId).toLocalDateTime();
                if (dateTime.isAfter(s1) && dateTime.isBefore(s2)){

                    count+=coursePackageStudent.getNeedNum();
                }else if(dateTime.isAfter(s3) && dateTime.isBefore(s4)){
                    count1+=coursePackageStudent.getNeedNum();
                }else if(dateTime.isAfter(s5) && dateTime.isBefore(s6)){
                    count2+=coursePackageStudent.getNeedNum();
                }else if(dateTime.isAfter(s7) && dateTime.isBefore(s8)){
                    count3+=coursePackageStudent.getNeedNum();
                }

            }
        }
        weekData.add(count3);
        weekData.add(count2);
        weekData.add(count1);
        weekData.add(count);

        map.put("weekData",weekData);


        LocalDateTime currentDateTime = LocalDateTime.now();
        List<Integer> amountByDay = new ArrayList<>(Collections.nCopies(7,0));
        for (CoursePackageStudent coursePackageStudent : list) {
            Date insertTime = coursePackageStudent.getInsertTime();
            // 将 Date 转换为 LocalDateTime
            LocalDateTime insertDateTime = LocalDateTime.ofInstant(insertTime.toInstant(), ZoneId.systemDefault());
            // 计算日期与当前日期的差距
            long daysDifference = ChronoUnit.DAYS.between(insertDateTime.toLocalDate(), currentDateTime.toLocalDate());
            // 如果日期在七天内，累加金额
            if (daysDifference >= 0 && daysDifference < 7) {
                int index = (int) (6 - daysDifference); // 计算对应的索引位置
                Integer needNum = coursePackageStudent.getNeedNum();
                if (needNum!=null){
                    int i = amountByDay.get(index) + needNum;
                    amountByDay.set(index, i);
                }

            }
        }
        map.put("dayData", amountByDay);

        return map;

    }
}