package com.dsh.guns.modular.system.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.dsh.course.entity.CoursePackageOrderStudent;
import com.dsh.course.feignClient.account.StudentHonorClient;
import com.dsh.course.feignClient.account.model.StudentHonor;
import com.dsh.course.feignClient.course.*;
import com.dsh.course.feignClient.course.model.*;
import com.dsh.guns.config.UserExt;
import com.dsh.guns.core.support.HttpKit;
import com.dsh.guns.core.util.ToolUtil;
import com.dsh.guns.modular.system.model.CourseCounsum;
import com.dsh.guns.modular.system.model.TStore;
import com.dsh.guns.modular.system.service.ICoursePackageService;
import com.dsh.guns.modular.system.service.IStoreService;
import com.dsh.guns.modular.system.util.ResultUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @author zhibing.pu
 * @Date 2023/8/1 11:51
 */
@Service
public class CoursePackageService implements ICoursePackageService {

    @Resource
    private CoursePackageClient coursePackageClient;

    @Autowired
    private IStoreService storeService;

    @Resource
    private CoursePackagePaymentConfigClient coursePackagePaymentConfigClient;

    @Resource
    private CoursePackageDiscountClient coursePackageDiscountClient;

    @Resource
    private CoursePackagePaymentClient coursePackagePaymentClient;

    @Resource
    private CoursePackageSchedulingClient coursePackageSchedulingClient;

    @Resource
    private CoursePackageStudentClient coursePackageStudentClient;

    @Resource
    private CancelledClassesClient cancelledClassesClient;

    @Resource
    private StudentHonorClient studentHonorClient;





    /**
     * 获取列表数据
     * @param provinceCode
     * @param cityCode
     * @param coursePackageTypeId
     * @param name
     * @param status
     * @param state
     * @return
     */
    @Override
    public Page<Map<String, Object>> queryCoursePackageLists(String provinceCode, String cityCode, Integer coursePackageTypeId, List<Integer> storeId, String name, Integer status, Integer state) {
        QueryCoursePackageLists queryCoursePackageLists = new QueryCoursePackageLists();
        queryCoursePackageLists.setProvinceCode(provinceCode);
        queryCoursePackageLists.setCityCode(cityCode);
        queryCoursePackageLists.setCoursePackageTypeId(coursePackageTypeId);
        queryCoursePackageLists.setStoreIds(storeId);
        queryCoursePackageLists.setName(name);
        queryCoursePackageLists.setState(state);
        queryCoursePackageLists.setStatus(status);
        HttpServletRequest request = HttpKit.getRequest();
        queryCoursePackageLists.setLimit(Integer.valueOf(request.getParameter("limit")));
        queryCoursePackageLists.setOffset(Integer.valueOf(request.getParameter("offset")));
        queryCoursePackageLists.setSort(request.getParameter("sort"));
        queryCoursePackageLists.setOrder(request.getParameter("order"));
        Page<Map<String, Object>> mapPage = coursePackageClient.queryCoursePackageLists(queryCoursePackageLists);
        List<Map<String, Object>> records = mapPage.getRecords();
        for (Map<String, Object> record : records) {
            TStore store = storeService.getById(Integer.valueOf(record.get("storeId").toString()));
            record.put("store", store.getName());
        }
        return mapPage;
    }


    /**
     * 添加课包数据
     * @param coursePackage
     * @param coursePackagePaymentConfig
     */
    @Override
    public void addCoursePackage(TCoursePackage coursePackage, String coursePackagePaymentConfig) {
        Integer integer = coursePackageClient.addCoursePackage(coursePackage);
        JSONArray jsonArray = JSON.parseArray(coursePackagePaymentConfig);
        for (int i = 0; i < jsonArray.size(); i++) {
            JSONObject jsonObject = jsonArray.getJSONObject(i);
            Integer classHours = jsonObject.getInteger("classHours");
            Double cashPayment = jsonObject.getDouble("cashPayment");
            Integer playPaiCoin = jsonObject.getInteger("playPaiCoin");
            String couponIds = jsonObject.getString("couponIds");
            CoursePackagePaymentConfig coursePackagePaymentConfig1 = new CoursePackagePaymentConfig();
            coursePackagePaymentConfig1.setCoursePackageId(integer);
            coursePackagePaymentConfig1.setClassHours(classHours);
            coursePackagePaymentConfig1.setCashPayment(cashPayment);
            coursePackagePaymentConfig1.setPlayPaiCoin(playPaiCoin);
            coursePackagePaymentConfig1.setCouponIds(couponIds);
            coursePackagePaymentConfigClient.addCoursePackagePaymentConfig(coursePackagePaymentConfig1);
        }
    }


    /**
     * 根据id获取数据
     * @param id
     * @return
     */
    @Override
    public TCoursePackage queryById(Integer id) {
        return coursePackageClient.queryById(id);
    }


    /**
     * 编辑数据
     * @param coursePackage
     * @param coursePackagePaymentConfig
     */
    @Override
    public void updateCoursePackage(TCoursePackage coursePackage, String coursePackagePaymentConfig) {
        String holitime = coursePackage.getHolitime();
        if (holitime!=null){
            // 如果为空字符串 则默认未修改
            if (holitime.equals("")){
                TCoursePackage tCoursePackage = coursePackageClient.queryById(coursePackage.getId());
                coursePackage.setStartTime(tCoursePackage.getStartTime());
                coursePackage.setEndTime(tCoursePackage.getEndTime());
            }else{
                String[] split = holitime.split(" - ");
                String startTime = split[0];
                String endTime = split[1];
                SimpleDateFormat format1 = new SimpleDateFormat("yyyy-MM-dd");
                SimpleDateFormat format2 = new SimpleDateFormat("yyyy-MM-dd");
                try {
                    Date parse1 = format1.parse(startTime);
                    parse1.setHours(0);
                    parse1.setMinutes(0);
                    parse1.setSeconds(0);
                    Date parse2 = format2.parse(endTime);
                    parse2.setHours(23);
                    parse2.setMinutes(59);
                    parse2.setSeconds(59);
                    coursePackage.setStartTime(parse1);
                    coursePackage.setEndTime(parse2);
                } catch (ParseException e) {
                    e.printStackTrace();
                }
            }
        }
        coursePackageClient.updateCoursePackage(coursePackage);
        coursePackagePaymentConfigClient.delCoursePackagePaymentConfig(coursePackage.getId());
        List<TCoursePackageDiscount> tCoursePackageDiscounts = coursePackageDiscountClient
                .queryByCoursePackageId(coursePackage.getId());

        JSONArray jsonArray = JSON.parseArray(coursePackagePaymentConfig);
        for (int i = 0; i < jsonArray.size(); i++) {
            JSONObject jsonObject = jsonArray.getJSONObject(i);
            Integer classHours = jsonObject.getInteger("classHours");
            Double cashPayment = jsonObject.getDouble("cashPayment");
            Integer playPaiCoin = jsonObject.getInteger("playPaiCoin");
            String couponIds = jsonObject.getString("couponIds");
            CoursePackagePaymentConfig coursePackagePaymentConfig1 = new CoursePackagePaymentConfig();
            coursePackagePaymentConfig1.setCoursePackageId(coursePackage.getId());
            coursePackagePaymentConfig1.setClassHours(classHours);
            coursePackagePaymentConfig1.setCashPayment(cashPayment);
            coursePackagePaymentConfig1.setPlayPaiCoin(playPaiCoin);
            coursePackagePaymentConfig1.setCouponIds(couponIds);
            int i1 = coursePackagePaymentConfigClient.addCoursePackagePaymentConfig(coursePackagePaymentConfig1);
//            for (TCoursePackageDiscount tCoursePackageDiscount : tCoursePackageDiscounts) {
//                tCoursePackageDiscount.setCoursePackagePaymentConfigId(coursePackagePaymentConfig1.getId());
//                coursePackageDiscountClient.update(tCoursePackageDiscount);
//            }
        }
    }


    /**
     * 修改数据
     * @param coursePackage
     */
    @Override
    public void editCoursePackageState(TCoursePackage coursePackage) {
        coursePackageClient.updateCoursePackage(coursePackage);
    }


    /**
     * 编辑课包折扣
     * @param json
     * @return
     */
    @Override
    public ResultUtil setCoursePackageDiscount(Integer id, String json) {
        List<TCoursePackageDiscount> list = new ArrayList<>();
        JSONArray jsonArray = JSON.parseArray(json);
        for (int i = 0; i < jsonArray.size(); i++) {
            JSONObject jsonObject = jsonArray.getJSONObject(i);
            Integer coursePackagePaymentConfigId = jsonObject.getInteger("coursePackagePaymentConfigId");
            JSONArray coursePackageDiscount = jsonObject.getJSONArray("coursePackageDiscount");
            if(coursePackageDiscount.size() == 0){
                continue;
            }
            for (int j = 0; j < coursePackageDiscount.size(); j++) {
                JSONObject cpd = coursePackageDiscount.getJSONObject(j);
                Integer type = cpd.getInteger("type");
                switch (type){
                    case 1:
                        JSONObject content1 = cpd.getJSONObject("content");
                        if(null == content1){
                            return ResultUtil.error("请填写有效的会员折扣");
                        }
                        Double discountMember = content1.getDouble("discountMember");
                        if(null == discountMember){
                            return ResultUtil.error("请填写有效的会员折扣价格");
                        }
                        break;
                    case 2:
                        JSONObject content2 = cpd.getJSONObject("content");
                        if(null == content2){
                            return ResultUtil.error("请填写有效的续课优惠");
                        }
                        Double continuingMember = content2.getDouble("continuingMember");
                        if(null == continuingMember){
                            return ResultUtil.error("请填写有效的会员续课价格");
                        }
                        Double continuingUser = content2.getDouble("continuingUser");
                        if(null == continuingUser){
                            return ResultUtil.error("请填写有效的用户续课价格");
                        }
                        break;
                    case 3:
                        JSONArray content3 = cpd.getJSONArray("content");
                        if(content3.size() == 0){
                            return ResultUtil.error("请配置有效的限时折扣");
                        }
                        for (int k = 0; k < content3.size(); k++) {
                            JSONObject jsonObject1 = content3.getJSONObject(k);
                            String startDate = jsonObject1.getString("startDate");
                            String endDate = jsonObject1.getString("endDate");
                            String startTime = jsonObject1.getString("startTime");
                            String endTime = jsonObject1.getString("endTime");
                            JSONArray weeks = jsonObject1.getJSONArray("weeks");
                            Double cashPayment = jsonObject1.getDouble("cashPayment");
                            if(ToolUtil.isEmpty(startDate)){
                                return ResultUtil.error("请填写有效的折扣有效期");
                            }
                            if(ToolUtil.isEmpty(endDate)){
                                return ResultUtil.error("请填写有效的折扣有效期");
                            }
                            if(ToolUtil.isEmpty(startTime)){
                                return ResultUtil.error("请填写有效的折扣时间");
                            }
                            if(ToolUtil.isEmpty(endTime)){
                                return ResultUtil.error("请填写有效的折扣时间");
                            }
                            if(null == weeks || weeks.size() == 0){
                                return ResultUtil.error("请选择有效的折扣时间星期天");
                            }
                            if(null == cashPayment){
                                return ResultUtil.error("请填写有效的折扣金额");
                            }
                        }
                        break;
                    case 4:
                        JSONArray content4 = cpd.getJSONArray("content");
                        if(content4.size() == 0){
                            return ResultUtil.error("请配置有效的赠送课时");
                        }
                        for (int k = 0; k < content4.size(); k++) {
                            JSONObject jsonObject1 = content4.getJSONObject(k);
                            String startDate = jsonObject1.getString("startDate");
                            String endDate = jsonObject1.getString("endDate");
                            String startTime = jsonObject1.getString("startTime");
                            String endTime = jsonObject1.getString("endTime");
                            JSONArray weeks = jsonObject1.getJSONArray("weeks");
                            Double hour = jsonObject1.getDouble("hour");
                            if(ToolUtil.isEmpty(startDate)){
                                return ResultUtil.error("请填写有效的赠送有效期");
                            }
                            if(ToolUtil.isEmpty(endDate)){
                                return ResultUtil.error("请填写有效的赠送有效期");
                            }
                            if(ToolUtil.isEmpty(startTime)){
                                return ResultUtil.error("请填写有效的赠送时间");
                            }
                            if(ToolUtil.isEmpty(endTime)){
                                return ResultUtil.error("请填写有效的赠送时间");
                            }
                            if(null == weeks || weeks.size() == 0){
                                return ResultUtil.error("请选择有效的赠送时间星期天");
                            }
                            if(null == hour){
                                return ResultUtil.error("请填写有效的赠送课时数");
                            }
                        }
                        break;
                }

                TCoursePackageDiscount coursePackageDiscount1 = new TCoursePackageDiscount();
                coursePackageDiscount1.setCoursePackageId(id);
                coursePackageDiscount1.setCoursePackagePaymentConfigId(coursePackagePaymentConfigId);
                coursePackageDiscount1.setType(type);
                coursePackageDiscount1.setContent(cpd.getString("content"));
                if (UserExt.getUser().getObjectType() == 1){
                    coursePackageDiscount1.setAuditStatus(2);
                }else if (UserExt.getUser().getObjectType() == 2){
                    coursePackageDiscount1.setAuditStatus(1);
                }

                coursePackageDiscount1.setInsertTime(new Date());
                list.add(coursePackageDiscount1);
            }
        }
        coursePackageDiscountClient.setCoursePackageDiscount(list);
        return ResultUtil.success();
    }


    /**
     * 获取课程报名信息
     * @param id
     * @param userName
     * @param studentName
     * @return
     */
    @Override
    public Page<Map<String, Object>> queryRegistrationRecord(Integer id, String userName, String studentName) {
        QueryRegistrationRecord queryRegistrationRecord = new QueryRegistrationRecord();
        queryRegistrationRecord.setCoursePackageId(id);
        queryRegistrationRecord.setUserName(userName);
        queryRegistrationRecord.setStudentName(studentName);
        HttpServletRequest request = HttpKit.getRequest();
        queryRegistrationRecord.setLimit(Integer.valueOf(request.getParameter("limit")));
        queryRegistrationRecord.setOffset(Integer.valueOf(request.getParameter("offset")));
        queryRegistrationRecord.setSort(request.getParameter("sort"));
        queryRegistrationRecord.setOrder(request.getParameter("order"));
        Page<Map<String, Object>> mapPage = coursePackagePaymentClient.queryRegistrationRecord(queryRegistrationRecord);
        return mapPage;
    }


    /**
     * 获取课包上课信息
     * @param id
     * @return
     */
    @Override
    public Page<Map<String, Object>> queryCoursePackageSchedulingList(Integer id) {
        QueryCoursePackageSchedulingList queryClassRecord = new QueryCoursePackageSchedulingList();
        queryClassRecord.setCoursePackageId(id);
        HttpServletRequest request = HttpKit.getRequest();
        queryClassRecord.setLimit(Integer.valueOf(request.getParameter("limit")));
        queryClassRecord.setOffset(Integer.valueOf(request.getParameter("offset")));
        queryClassRecord.setSort(request.getParameter("sort"));
        queryClassRecord.setOrder(request.getParameter("order"));
        Page<Map<String, Object>> mapPage = coursePackageSchedulingClient.queryCoursePackageSchedulingList(queryClassRecord);
        return mapPage;
    }


    /**
     * 获取排课对应学员数据
     * @param id
     * @return
     */
    @Override
    public Page<Map<String, Object>> queryCoursePackageStudentList(Long id, String userName, String studentName) {
        QueryCoursePackageStudentList queryCoursePackageStudentList = new QueryCoursePackageStudentList();
        queryCoursePackageStudentList.setCoursePackageSchedulingId(id);
        queryCoursePackageStudentList.setUserName(userName);
        queryCoursePackageStudentList.setStudentName(studentName);
        HttpServletRequest request = HttpKit.getRequest();
        queryCoursePackageStudentList.setLimit(Integer.valueOf(request.getParameter("limit")));
        queryCoursePackageStudentList.setOffset(Integer.valueOf(request.getParameter("offset")));
        queryCoursePackageStudentList.setSort(request.getParameter("sort"));
        queryCoursePackageStudentList.setOrder(request.getParameter("order"));
        return coursePackageStudentClient.queryCoursePackageStudentList(queryCoursePackageStudentList);
    }

    /**
     * 取消预约
     * @param id
     * @return
     */
    @Override
    public ResultUtil cancelReservation(Long id) {
        CoursePackageStudent coursePackageStudent = coursePackageStudentClient.queryCoursePackageStudentById(id);
//        if(coursePackageStudent.getSignInOrNot() == 1){
//            return ResultUtil.error("当前学员已到课不能请假");
//        }
//        TCoursePackagePayment payment = coursePackagePaymentClient.queryCoursePackagePaymentById(coursePackageStudent.getCoursePackagePaymentId());
//        payment.setAbsencesNumber(payment.getAbsencesNumber()+1);
//        coursePackagePaymentClient.editCoursePackagePayment(payment);


        coursePackageStudent = new CoursePackageStudent();
        coursePackageStudent.setId(id);
//        coursePackageStudent.setReservationStatus(0);
        coursePackageStudent.setSignInOrNot(2);


        coursePackageStudent.getCoursePackagePaymentId();

        coursePackageStudentClient.editCoursePackageStudent(coursePackageStudent);
        return ResultUtil.success();
    }


    /**
     * 修改缺席状态
     * @param id
     * @return
     */
    @Override
    public ResultUtil setAbsenceStatus(Long id) {
        CoursePackageStudent coursePackageStudent = coursePackageStudentClient.queryCoursePackageStudentById(id);
        if(coursePackageStudent.getReservationStatus() == 0){
            return ResultUtil.error("该数据已取消预约");
        }
        coursePackageStudent = new CoursePackageStudent();
        coursePackageStudent.setId(id);
        coursePackageStudent.setSignInOrNot(0);
        coursePackageStudentClient.editCoursePackageStudent(coursePackageStudent);
        return ResultUtil.success();
    }


    /**
     * 取消本次排课
     * @param id
     * @return
     */
    @Override
    public ResultUtil cancelClassSchedule(Long id) {

//        List<CoursePackageScheduling> coursePackageSchedulings =  coursePackageSchedulingClient.queryCoursePackageSchedulingsById(id);
//        List<Long> integers = new ArrayList<>();
//        for (CoursePackageScheduling coursePackageScheduling : coursePackageSchedulings) {
//            integers.add(coursePackageScheduling.getId());
//        }
        List<CoursePackageScheduling> coursePackageSchedulings =  coursePackageSchedulingClient.queryCoursePackageSchedulingsById(id);
        List<Long> integers = new ArrayList<>();
        for (CoursePackageScheduling coursePackageScheduling : coursePackageSchedulings) {
            integers.add(coursePackageScheduling.getId());
            coursePackageScheduling.setStatus(4);
        }

        coursePackageSchedulingClient.editCoursePackageScheduling(coursePackageSchedulings);



//        CoursePackageScheduling coursePackageScheduling = coursePackageSchedulingClient.queryCoursePackageSchedulingById(id);
//        if(coursePackageScheduling.getStatus() != 1){
//            return ResultUtil.error("不能取消本次");
//        }





//        List<CoursePackageStudent> coursePackageStudents = coursePackageStudentClient.queryByCoursePackageSchedulingId(id);
//        if(coursePackageStudents.size() > 0){
////            return ResultUtil.error("不能取消本次");
//        }
//        coursePackageScheduling = new CoursePackageScheduling();
//        coursePackageScheduling.setId(id);
//        coursePackageScheduling.setStatus(4);
//        coursePackageSchedulingClient.editCoursePackageScheduling(coursePackageScheduling);
        return ResultUtil.success();
    }


    /**
     * 添加课后练习
     * @param id
     * @param courseId
     * @param integral
     * @return
     */
    @Override
    public ResultUtil afterClassExercises(Long id, Integer courseId, Integer integral) {
//        CoursePackageScheduling coursePackageScheduling = coursePackageSchedulingClient.queryCoursePackageSchedulingById(id);

//        List<CoursePackageScheduling> coursePackageSchedulings =  coursePackageSchedulingClient.queryCoursePackageSchedulingsById(id);


        List<CoursePackageScheduling> coursePackageSchedulings =  coursePackageSchedulingClient.queryCoursePackageSchedulingsById(id);
        List<Long> integers = new ArrayList<>();
        for (CoursePackageScheduling coursePackageScheduling : coursePackageSchedulings) {
            integers.add(coursePackageScheduling.getId());
            coursePackageScheduling.setCourseId(courseId);
            coursePackageScheduling.setIntegral(integral);
        }

        coursePackageSchedulingClient.editCoursePackageScheduling(coursePackageSchedulings);

//        for (CoursePackageScheduling coursePackageScheduling : coursePackageSchedulings) {
//            integers.add(coursePackageScheduling.getId());
//            if(coursePackageScheduling.getStatus() != 3){
//                return ResultUtil.error("不能发布课后练习");
//            }
//            coursePackageScheduling.setCourseId(courseId);
//            coursePackageScheduling.setIntegral(integral);
//            coursePackageSchedulingClient.editCoursePackageScheduling(coursePackageScheduling);
//        }

//        if(coursePackageScheduling.getStatus() != 3){
//            return ResultUtil.error("不能发布课后练习");
//        }
//        coursePackageScheduling.setCourseId(courseId);
//        coursePackageScheduling.setIntegral(integral);
//        coursePackageSchedulingClient.editCoursePackageScheduling(coursePackageScheduling);
        return ResultUtil.success();
    }



    /**
     * 上传消课凭证
     * @param id
     * @param cancelClasses
     * @param deductClassHour
     * @return
     */
    @Override
    public ResultUtil cancellationRecord(Long id, String cancelClasses, Integer deductClassHour) {
        List<CoursePackageScheduling> coursePackageSchedulings =  coursePackageSchedulingClient.queryCoursePackageSchedulingsById(id);
        CoursePackageScheduling coursePackageScheduling1 = coursePackageSchedulings.get(0);
        Date classDate = coursePackageScheduling1.getEndDate();

        if (new Date().before(classDate)){
            return ResultUtil.error("课程未结束，无法消课");
        }
        List<Long> integers = new ArrayList<>();
        for (CoursePackageScheduling coursePackageScheduling : coursePackageSchedulings) {
            integers.add(coursePackageScheduling.getId());
            coursePackageScheduling.setCancelClasses(cancelClasses);
            coursePackageScheduling.setDeductClassHour(deductClassHour);
            coursePackageScheduling.setStatus(3);
        }
        coursePackageSchedulingClient.editCoursePackageScheduling(coursePackageSchedulings);

        List<CoursePackageStudent> coursePackageStudents = coursePackageStudentClient.queryByCoursePackageSchedulingId(integers);
        for (CoursePackageStudent coursePackageStudent : coursePackageStudents) {
            if(coursePackageStudent.getSignInOrNot() == 2){
                continue;
            }
            CoursePackageOrderStudent coursePackageOrderStudent = coursePackagePaymentClient.queryCoursePackagePaymentById1(coursePackageStudent.getCoursePackagePaymentId());

            if (deductClassHour!=null) {
                if (coursePackageOrderStudent.getLaveClassHours() - deductClassHour < 0) {
                    coursePackageStudentClient.editCoursePackageStudent(coursePackageStudent);
                    continue;
                }
                coursePackageOrderStudent.setLaveClassHours(coursePackageOrderStudent.getLaveClassHours() - deductClassHour);
            }

            if(coursePackageStudent.getReservationStatus() == 0){
                coursePackageOrderStudent.setAbsencesNumber(coursePackageOrderStudent.getAbsencesNumber() + 1);
            }
            System.out.println("====tCoursePackagePayment====="+coursePackageOrderStudent);
            coursePackagePaymentClient.editCoursePackagePayment2(coursePackageOrderStudent);


            CancelledClasses cancelledClasses = new CancelledClasses();
            cancelledClasses.setType(1);
            cancelledClasses.setCoursePackageId(coursePackageStudent.getCoursePackageId());
            cancelledClasses.setCoursePackagePaymentId(coursePackageOrderStudent.getId());
            cancelledClasses.setCoursePackageSchedulingId(coursePackageStudent.getCoursePackageSchedulingId());
            cancelledClasses.setVoucher(cancelClasses);
            if (deductClassHour!=null) {
                cancelledClasses.setCancelledClassesNumber(deductClassHour);
            }
            cancelledClasses.setInsertTime(new Date());
            cancelledClassesClient.addCancelledClasses(cancelledClasses);

            //添加勋章数据
            QueryCoursePackageStudent queryCoursePackageStudent = new QueryCoursePackageStudent();
            queryCoursePackageStudent.setAppUserId(coursePackageStudent.getAppUserId());
            queryCoursePackageStudent.setSignInOrNot(1);
            queryCoursePackageStudent.setReservationStatus(1);
            List<CoursePackageStudent> coursePackageStudents1 = coursePackageStudentClient.queryCoursePackageStudent(queryCoursePackageStudent);
            StudentHonor studentHonor = new StudentHonor();
            studentHonor.setAppUserId(coursePackageStudent.getAppUserId());
            studentHonor.setHonorType(1);
            studentHonor.setNumber(coursePackageStudents1.size());
            studentHonorClient.saveStudentHonor(studentHonor);
        }

        return ResultUtil.success();
    }


    /**
     * 获取未预约排课学员列表
     * @param coursePackageSchedulingId
     * @param userName
     * @param studentName
     * @return
     */
    @Override
    public Page<Map<String, Object>> queryWalkInStudentList(Long coursePackageSchedulingId, String userName, String studentName) {
        QueryWalkInStudentList queryWalkInStudentList = new QueryWalkInStudentList();
        queryWalkInStudentList.setCoursePackageSchedulingId(coursePackageSchedulingId);
        queryWalkInStudentList.setUserName(userName);
        queryWalkInStudentList.setStudentName(studentName);
        HttpServletRequest request = HttpKit.getRequest();
        queryWalkInStudentList.setLimit(Integer.valueOf(request.getParameter("limit")));
        queryWalkInStudentList.setOffset(Integer.valueOf(request.getParameter("offset")));
        queryWalkInStudentList.setSort(request.getParameter("sort"));
        queryWalkInStudentList.setOrder(request.getParameter("order"));
        return coursePackagePaymentClient.queryWalkInStudentList(queryWalkInStudentList);
    }


    /**
     * 手动预约课程
     * @param coursePackagePaymentId
     * @param coursePackageSchedulingId
     * @return
     */
    @Override
    public ResultUtil courseReservation(Long coursePackagePaymentId, Long coursePackageSchedulingId) {
        QueryCoursePackageStudent queryCoursePackageStudent = new QueryCoursePackageStudent();
        queryCoursePackageStudent.setCoursePackagePaymentId(coursePackagePaymentId);
        queryCoursePackageStudent.setCoursePackageSchedulingId(coursePackageSchedulingId);
        queryCoursePackageStudent.setReservationStatus(1);
        List<CoursePackageStudent> coursePackageStudents = coursePackageStudentClient.queryCoursePackageStudent(queryCoursePackageStudent);
        if(coursePackageStudents.size() > 0){
            return ResultUtil.error("不能重复预约");
        }

        CoursePackageScheduling coursePackageScheduling = coursePackageSchedulingClient.queryCoursePackageSchedulingById(coursePackageSchedulingId);
        TCoursePackage tCoursePackage = coursePackageClient.queryById(coursePackageScheduling.getCoursePackageId());
        queryCoursePackageStudent = new QueryCoursePackageStudent();
        queryCoursePackageStudent.setCoursePackageId(coursePackageScheduling.getCoursePackageId());
        queryCoursePackageStudent.setReservationStatus(1);
        List<CoursePackageStudent> coursePackageStudents1 = coursePackageStudentClient.queryCoursePackageStudent(queryCoursePackageStudent);
        if(coursePackageStudents1.size() >= tCoursePackage.getMaxSubscribeNumber()){
            return ResultUtil.error("已达到最多预约人数");
        }

        TCoursePackagePayment coursePackagePayment = coursePackagePaymentClient.queryCoursePackagePaymentById(coursePackagePaymentId);
        CoursePackageStudent coursePackageStudent = new CoursePackageStudent();
        coursePackageStudent.setAppUserId(coursePackagePayment.getAppUserId());
        coursePackageStudent.setStudentId(coursePackagePayment.getStudentId());
        coursePackageStudent.setCoursePackageId(coursePackagePayment.getCoursePackageId());
        coursePackageStudent.setCoursePackagePaymentId(coursePackagePaymentId);
        coursePackageStudent.setCoursePackageSchedulingId(coursePackageSchedulingId);
        coursePackageStudent.setSignInOrNot(1);
        coursePackageStudent.setReservationStatus(1);
        coursePackageStudent.setInsertTime(new Date());
        coursePackageStudentClient.addCoursePackageStudent(coursePackageStudent);
        return ResultUtil.success();
    }


    /**
     * 退课操作
     * @param coursePackagePaymentId
     * @param certificate
     * @return
     */
    @Override
    public ResultUtil dropTheClass(Long coursePackagePaymentId, String certificate) {
        TCoursePackagePayment coursePackagePayment = coursePackagePaymentClient.queryCoursePackagePaymentById(coursePackagePaymentId);
        if(coursePackagePayment.getStatus() == 2){
            return ResultUtil.error("不能重复操作");
        }
        coursePackagePayment.setStatus(2);
        coursePackagePayment.setCertificate(certificate);
        coursePackagePayment.setWithdrawalTime(new Date());
        //修改课时，费用线下自己处理不走线上
        Integer laveClassHours = coursePackagePayment.getLaveClassHours();
        if(laveClassHours == 0){
            return ResultUtil.error("无可退数量");
        }
        coursePackagePayment.setDropoutsNumber(laveClassHours);
        coursePackagePayment.setLaveClassHours(0);
        coursePackagePaymentClient.editCoursePackagePayment(coursePackagePayment);
        return ResultUtil.success();
    }


    /**
     * 补课操作
     * @param coursePackagePaymentId
     * @return
     */
    @Override
    public ResultUtil makeUpMissedLessons(Integer coursePackagePaymentId){
//        try {
            Integer is = coursePackagePaymentClient.consumeCourse(coursePackagePaymentId);
            if (is==1){
                return ResultUtil.error("课时数不足");
            }else {
                return ResultUtil.success("补课成功");
            }
//            return  resultUtil;
//            return  ResultUtil.success("补课成功");
//        }catch (Exception e){
//            return  ResultUtil.success("课时数不足");
//
//        }

//        return resultUtil;
    }


    /**
     * 获取课包审核列表
     * @param provinceCode
     * @param cityCode
     * @param coursePackageTypeId
     * @param name
     * @param auditStatus
     * @return
     */
    @Override
    public Page<Map<String, Object>> queryExamineCoursePackageLists(String provinceCode, String cityCode, Integer coursePackageTypeId, String name, Integer auditStatus) {
        QueryExamineCoursePackageLists queryExamineCoursePackageLists = new QueryExamineCoursePackageLists();
        queryExamineCoursePackageLists.setProvinceCode(provinceCode);
        queryExamineCoursePackageLists.setCityCode(cityCode);
        queryExamineCoursePackageLists.setCoursePackageTypeId(coursePackageTypeId);
        queryExamineCoursePackageLists.setName(name);
        queryExamineCoursePackageLists.setAuditStatus(auditStatus);
        HttpServletRequest request = HttpKit.getRequest();
        queryExamineCoursePackageLists.setLimit(Integer.valueOf(request.getParameter("limit")));
        queryExamineCoursePackageLists.setOffset(Integer.valueOf(request.getParameter("offset")));
        queryExamineCoursePackageLists.setSort(request.getParameter("sort"));
        queryExamineCoursePackageLists.setOrder(request.getParameter("order"));
        Page<Map<String, Object>> mapPage = coursePackageClient.queryExamineCoursePackageLists(queryExamineCoursePackageLists);
        List<Map<String, Object>> records = mapPage.getRecords();
        for (Map<String, Object> record : records) {
            TStore store = storeService.getById(Integer.valueOf(record.get("storeId").toString()));
            record.put("store", store.getName());
        }
        return mapPage;
    }


    /**
     * 审核课包
     * @param id
     * @param auditStatus
     * @param authRemark
     * @return
     */
    @Override
    public ResultUtil setCoursePackageAuditStatus(Integer id, Integer auditStatus, String authRemark) {
        TCoursePackage tCoursePackage = coursePackageClient.queryById(id);
        if(tCoursePackage.getAuditStatus() != 1){
            return ResultUtil.error("不能重复审核");
        }
        tCoursePackage.setAuditStatus(auditStatus);
        tCoursePackage.setAuditUserId(UserExt.getUser().getId());
        tCoursePackage.setAuthRemark(authRemark);
        coursePackageClient.updateCoursePackage(tCoursePackage);
        return ResultUtil.success();
    }
}