package com.peanut.modules.common.controller;

import cn.hutool.core.date.DateUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.github.promeg.pinyinhelper.Pinyin;
import com.peanut.common.utils.DateUtils;
import com.peanut.common.utils.R;
import com.peanut.common.utils.ShiroUtils;
import com.peanut.modules.common.dao.ClassExamUserDao;
import com.peanut.modules.common.entity.*;
import com.peanut.modules.common.service.ClassEntityService;
import com.peanut.modules.common.service.ClassExamUserService;
import com.peanut.modules.common.service.MyUserService;
import com.peanut.modules.common.service.UserCertificateService;
import com.peanut.modules.medical.service.CourseService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.imageio.ImageIO;
import java.net.URL;
import java.util.HashSet;
import java.util.List;
import java.util.Map;

@Slf4j
@RestController("commonClass")
@RequestMapping("common/class")
public class ClassController {

    @Autowired
    private ClassEntityService classEntityService;
    @Autowired
    private UserCertificateService userCertificateService;
    @Autowired
    private CourseService courseService;
    @Autowired
    private ClassExamUserService classExamUserService;
    @Autowired
    private StringRedisTemplate redisTemplate;

    //班级模型列表
    @RequestMapping("/getClassModelList")
    public R getClassModelList(@RequestBody Map<String,Object> params){
        Page classModelList = classEntityService.getClassModelList(params);
        return R.ok().put("page",classModelList);
    }

    //新增班级模型
    @RequestMapping("/addClassModel")
    public R addClassModel(@RequestBody ClassModel classModel){
        String[] courseIds = classModel.getCourseIds().split(",");
        if(courseIds.length > 0){
            HashSet<String> set = new HashSet<>();
            for (String courseId : courseIds) {
                if (!set.add(courseId)){
                    return R.error("课程不能重复");
                }
            }
        }
        int score = 0;
        if (classModel.getIsQuestion()==1){
            score += classModel.getQuestionScore();
        }
        if (classModel.getIsTask()==1){
            score += classModel.getTaskScore();
        }
        if (classModel.getIsMedicalcase()==1){
            score += classModel.getMedicalcaseScore();
        }
        if (classModel.getIsExperience()==1){
            score += classModel.getExperienceScore();
        }
        if (classModel.getIsExam()==1){
            score += classModel.getExamScore();
        }
        if (score==100){
            return classEntityService.addClassModel(classModel);
        }else {
            return R.error("请设置各模块占比总和为100");
        }
    }

    //修改班级模型
    @RequestMapping("/editClassModel")
    public R editClassModel(@RequestBody ClassModel classModel){
        String[] courseIds = classModel.getCourseIds().split(",");
        if(courseIds.length > 0){
            HashSet<String> set = new HashSet<>();
            for (String courseId : courseIds) {
                if (!set.add(courseId)){
                    return R.error("课程不能重复");
                }
            }
        }
        int score = 0;
        if (classModel.getIsQuestion()==1){
            score += classModel.getQuestionScore();
        }
        if (classModel.getIsTask()==1){
            score += classModel.getTaskScore();
        }
        if (classModel.getIsMedicalcase()==1){
            score += classModel.getMedicalcaseScore();
        }
        if (classModel.getIsExperience()==1){
            score += classModel.getExperienceScore();
        }
        if (classModel.getIsExam()==1){
            score += classModel.getExamScore();
        }
        if (score==100){
            return classEntityService.editClassModel(classModel);
        }else {
            return R.error("请设置各模块占比总和为100");
        }
    }

    //获取模型可选课程
    @RequestMapping("/getClassModelCourseList")
    public R getClassModelCourseList(@RequestBody Map<String,Object> params){
        List<CourseEntity> courseList = classEntityService.getClassModelCourseList(params);
        return R.ok().put("courseList",courseList);
    }

    //获取主任下的班级模型
    @RequestMapping("/getClassModelByUserid")
    public R getClassModelByUserid(@RequestBody Map<String,Object> params){
        List<ClassModel> classModelList = classEntityService.getClassModelByUserid(params);
        return R.ok().put("classModelList",classModelList);
    }

    //获取主任下的班级
    @RequestMapping("/getClassByDirectorid")
    public R getClassByDirectorid(@RequestBody Map<String,Object> params){
        return R.ok().put("classEntityList",classEntityService.getClassByDirectorid(params));
    }

    //获取班级列表
    @RequestMapping("/getClassList")
    public R getClassList(@RequestBody Map<String,Object> params){
        Page classList = classEntityService.getClassList(params);
        return R.ok().put("page",classList);
    }

    //新增班级
    @RequestMapping("/addClass")
    public R addClass(@RequestBody ClassEntity classEntity){
        return classEntityService.addClass(classEntity);
    }

    //修改班级状态
    @RequestMapping("/updateClassState")
    public R updateClassState(@RequestBody Map<String,Object> params){
        return classEntityService.updateClassState(params);
    }

    //修改班级
    @RequestMapping("/editClass")
    public R editClass(@RequestBody Map<String,Object> params){
        if (classEntityService.editClass(params)){
            return R.ok();
        }else {
            return R.error("修改出错");
        }
    }

    //设置班委
    @RequestMapping("/setUserRole")
    public R setUserRole(@RequestBody Map<String,Object> params){
        return classEntityService.setUserRole(params);
    }

    //获取用户在班级中角色
    @RequestMapping("/getUserRole")
    public R getUserRole(@RequestBody Map<String,Object> params){
        return R.ok().put("result",classEntityService.getUserRole(params));
    }

    //获取用户拥有角色类型
    @RequestMapping("/getRoleType")
    public R getRoleType(){
        return R.ok().put("result",classEntityService.getRoleType());
    }

    //删除班级
    @RequestMapping("/delClass")
    public R delClass(@RequestBody Map<String,Object> params){
        return classEntityService.delClass(params);
    }

    //获取班级详情
    @RequestMapping("/getClassInfo")
    public R getClassInfo(@RequestBody Map<String,Object> params){
        return R.ok().put("result",classEntityService.getClassInfo(params));
    }

    //同一小班未开班小班
    @RequestMapping("/getNoOpenClassSameClass")
    public R getNoOpenClassSameClass(@RequestBody Map<String,Object> params){
        return R.ok().put("result",classEntityService.getNoOpenClassSameClass(params));
    }

    //查询未加入小班
    @RequestMapping("/getClassNoUser")
    public R getClassNoUser(){
        return R.ok().put("result",classEntityService.getClassNoUser());
    }

    //查询包含课程的小班(登陆人未加入)
    @RequestMapping("/getClassByCourseIdNoUser")
    public R getClassByCourseIdNoUser(@RequestBody Map<String,Object> params){
        return R.ok().put("result",classEntityService.getClassByCourseIdNoUser(params));
    }

    //查询登陆人已加入小班
    @RequestMapping("/getClassByUser")
    public R getClassByUser(@RequestBody Map<String,Object> params){
        return R.ok().put("result",classEntityService.getClassByUser(params));
    }

    //加入小班前查询用户买课情况
    @RequestMapping("/getUserCourseBuy")
    public R getUserCourseBuy(@RequestBody Map<String,Object> params){
        return classEntityService.getUserCourseBuy(params);
    }

    //加入小班
    @RequestMapping("/joinClass")
    public R joinClass(@RequestBody Map<String,Object> params){
        return classEntityService.joinClass(params);
    }

    //退出小班
    @RequestMapping("/quitClass")
    public R quitClass(@RequestBody Map<String,Object> params){
        classEntityService.quitClass(params);
        return R.ok();
    }

    //我的小班列表
    @RequestMapping("/MyClassList")
    public R MyClassList(@RequestBody Map<String,Object> params){
        return R.ok().put("result",classEntityService.MyClassList(params));
    }

    //新增班级任务医案心得
    @RequestMapping("/addClassTask")
    public R addClassTask(@RequestBody ClassTask classTask){
        classEntityService.addClassTask(classTask);
        return R.ok();
    }

    //删除任务
    @RequestMapping("/delClassTask")
    public R delClassTask(@RequestBody Map<String,Object> params){
        classEntityService.delClassTask(params);
        return R.ok();
    }

    //生成班级任务
    @RequestMapping("/generateClassTask")
    public R generateClassTask(@RequestBody Map<String,Object> params){
        classEntityService.generateClassTask(params);
        return R.ok();
    }

    //获取班级任务列表
    @RequestMapping("/getClassTaskList")
    public R getClassTaskList(@RequestBody Map<String,Object> params){
        Page classTaskList = classEntityService.getClassTaskList(params);
        return R.ok().put("page",classTaskList);
    }

    //获取班级任务列表(学员)
    @RequestMapping("/getClassTaskListStudent")
    public R getClassTaskListStudent(@RequestBody Map<String,Object> params){
        Page classTaskList = classEntityService.getClassTaskListStudent(params);
        return R.ok().put("page",classTaskList);
    }

    //编辑班级任务医案心得
    @RequestMapping("/editClassTask")
    public R editClassTask(@RequestBody ClassTask classTask){
        classEntityService.editClassTask(classTask);
        return R.ok();
    }

    //获取任务详情
    @RequestMapping("/getClassTaskInfo")
    public R getClassTaskInfo(@RequestBody Map<String,Object> params){
        return R.ok().put("result",classEntityService.getClassTaskInfo(params));
    }

    //获取任务详情学员
    @RequestMapping("/getClassTaskInfoStudent")
    public R getClassTaskInfoStudent(@RequestBody Map<String,Object> params){
        ClassTask classTask = classEntityService.getClassTaskInfoStudent(params);
        return R.ok().put("classTask",classTask);
    }

    //新增作业
    @RequestMapping("/addClassTaskAndQuesReply")
    public R addClassTaskAndQuesReply(@RequestBody ClassTaskAndQuesReply classTaskAndQuesReply){
        ClassEntity classEntity = classEntityService.getById(classTaskAndQuesReply.getClassId());
        if ("3".equals(classEntity.getState())) {
            return R.error("考试周禁止提交作业");
        }
        classEntityService.addClassTaskAndQuesReply(classTaskAndQuesReply);
        return R.ok();
    }

    //通过任务获取作业列表
    @RequestMapping("/getReplyListByTaskId")
    public R getReplyListByTaskId(@RequestBody Map<String,Object> params){
        Page classTaskAndQuesReplyList = classEntityService.getReplyListByTaskId(params);
        return R.ok().put("page",classTaskAndQuesReplyList);
    }

    //通过任务获取作业列表(学员)
    @RequestMapping("/getReplyListByTaskIdStudent")
    public R getReplyListByTaskIdStudent(@RequestBody Map<String,Object> params){
        Page classTaskAndQuesReplyList = classEntityService.getReplyListByTaskIdStudent(params);
        return R.ok().put("page",classTaskAndQuesReplyList);
    }

    //心得评分
    @RequestMapping("/editTaskScore")
    public R editTaskScore(@RequestBody Map<String,Object> params){
        return classEntityService.editTaskScore(params);
    }

    //打分
    @RequestMapping("/editScore")
    public R editScore(@RequestBody Map<String,Object> params){
        return classEntityService.editScore(params);
    }

    //编辑作业
    @RequestMapping("/editClassTaskAndQuesReply")
    public R editClassTaskAndQuesReply(@RequestBody ClassTaskAndQuesReply classTaskAndQuesReply){
        classEntityService.editClassTaskAndQuesReply(classTaskAndQuesReply);
        return R.ok();
    }

    //作业详情
    @RequestMapping("/getClassTaskAndQuesReplyInfo")
    public R getClassTaskAndQuesReplyInfo(@RequestBody Map<String,Object> params){
        ClassTaskAndQuesReply classTaskAndQuesReply = classEntityService.getClassTaskAndQuesReplyInfo(params);
        return R.ok().put("classTaskAndQuesReply", classTaskAndQuesReply);
    }

    //课后题详情
    @RequestMapping("/getQuesReplyInfo")
    public R getQuesReplyInfo(@RequestBody Map<String,Object> params){
        ClassTaskAndQuesReply classTaskAndQuesReply = classEntityService.getQuesReplyInfo(params);
        return R.ok().put("classTaskAndQuesReply", classTaskAndQuesReply);
    }

    //思考题列表
    @RequestMapping("/getThinkQuestionList")
    public R getThinkQuestionList(@RequestBody Map<String,Object> params){
        return R.ok().put("thinkQuestionList",classEntityService.getThinkQuestionList(params));
    }

    //思考题列表(学员)
    @RequestMapping("/getThinkQuestionListStudent")
    public R getThinkQuestionListStudent(@RequestBody Map<String,Object> params){
        return R.ok().put("getThinkQuestionListStudent",classEntityService.getThinkQuestionListStudent(params));
    }

    //学员成绩
    @RequestMapping("/getUserScore")
    public R getUserScore(@RequestBody Map<String,Object> params){
        return R.ok().put("result",classEntityService.getUserScore(params));
    }

    //学员成绩列表
    @RequestMapping("/userScoreList")
    public R userScoreList(@RequestBody Map<String,Object> params){
        return R.ok().put("result",classEntityService.userScoreList(params));
    }

    //获取小班证书
    @RequestMapping("/getUserCertificateByClassId")
    public R getUserCertificateByClassId(@RequestBody Map<String,Object> params) {
        LambdaQueryWrapper<UserCertificate> wrapper = new LambdaQueryWrapper<>();
        if (StringUtils.isNotBlank(params.get("classId").toString())){
            wrapper.eq(UserCertificate::getClassId,params.get("classId"));
        }
        wrapper.eq(UserCertificate::getUserId,params.get("userId"));
        List<UserCertificate> userCertificate = userCertificateService.list(wrapper);
        return R.ok().put("userCertificate",userCertificate);
    }

    //生成证书
    @RequestMapping("/generateCertificateClass")
    @Transactional
    public R generateCertificateClass(@RequestBody Map<String,Object> params) {
        //抢锁
        Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", "123");
        if(lock) {
            try {
                //证书类型A a证 B b证 ZK自考
                String type = params.get("type").toString();
                MyUserEntity user = ShiroUtils.getUser();
                String photoUrl = user.getPhoto();//证书人照片
                String realName = user.getName();//真是姓名
                UserCertificate userCertificate = new UserCertificate();
                userCertificate.setType(type);
                userCertificate.setUserId(ShiroUtils.getUId());
                if ("ZK".equals(type)){
                    CourseEntity courseEntity = courseService.getById(params.get("relationId").toString());
                    String courseTitle = courseEntity.getTitle();
                    if (courseTitle.contains("【")){
                        courseTitle = courseEntity.getTitle().substring(0,courseEntity.getTitle().indexOf("【"));
                    }
                    userCertificate.setTitle(courseTitle);
                    ClassExamUser classExamUser = classExamUserService.getOne(new LambdaQueryWrapper<ClassExamUser>()
                            .eq(ClassExamUser::getUserId,ShiroUtils.getUId())
                            .eq(ClassExamUser::getRelationId,params.get("relationId").toString()));
                    String endYear = DateUtil.year(classExamUser.getEndTime())+"";
                    String endMonth = DateUtil.month(classExamUser.getEndTime())+1+"";
                    String endDay = DateUtil.dayOfMonth(classExamUser.getEndTime())+"";
                    String[] description= {endYear,endMonth,endDay,courseTitle};
                    String[] edes = {courseEntity.getEtitle()};
                    String certificateNo = getNextCertificateNo(type,courseEntity.getTitleAbbr());//证书编号
                    String url = userCertificateService.generateCertificate(type,certificateNo,photoUrl,realName, description, edes, endYear,endMonth,endDay);
                    userCertificate.setCertificateNo(certificateNo);
                    userCertificate.setCertificateUrl(url);
                    userCertificate.setCourseId(courseEntity.getId());
                    userCertificateService.save(userCertificate);
                }else {
                    ClassEntity classEntity = classEntityService.getById(params.get("relationId").toString());
                    String startYear = DateUtil.year(classEntity.getStartTime())+"";
                    String startMonth = DateUtil.month(classEntity.getStartTime())+1+"";
                    String startDay = DateUtil.dayOfMonth(classEntity.getStartTime())+"";
                    String endYear = DateUtil.year(classEntity.getEndTime())+"";
                    String endMonth = DateUtil.month(classEntity.getEndTime())+1+"";
                    String endDay = DateUtil.dayOfMonth(classEntity.getEndTime())+"";
                    List<Map<String,Object>> list = classEntityService.classCourseInfoClassId(classEntity.getId());
                    for (Map<String,Object> map:list){
                        userCertificate.setCourseId((Integer) map.get("courseId"));
                        double keshiTotal = (double)map.get("keshi");
                        String keshi = (keshiTotal+"").replace(".0","");
                        String courseTitle = map.get("courseTitle").toString();
                        if (courseTitle.contains("【")){
                            courseTitle = courseTitle.substring(0,courseTitle.indexOf("【"));
                        }
                        String[] des = {startYear,startMonth,startDay,endYear,endMonth,endDay,
                                classEntity.getTitle(),courseTitle,keshi};
                        String[] edes = {map.get("courseETitle").toString(),keshi};
                        String certificateNo = getNextCertificateNo(type,map.get("titleAbbr").toString());
                        String url = userCertificateService.generateCertificate(type,certificateNo,photoUrl,realName,des, edes, endYear,endMonth,endDay);
                        userCertificate.setCertificateUrl(url);
                        userCertificate.setCertificateNo(certificateNo);
                        userCertificate.setTitle(classEntity.getTitle());
                        userCertificate.setClassId(classEntity.getId());
                        userCertificateService.save(userCertificate);
                    }
                }
            }finally {
                //解锁
                redisTemplate.delete("lock");
            }
        }else {
            generateCertificateClass(params);
        }
        return R.ok();
    }

    //获取下一个编号
    public String getNextCertificateNo(String type,String courseNamePinyin){
        List<UserCertificate> userCertificateList = userCertificateService.list(new LambdaQueryWrapper<UserCertificate>()
                .orderByDesc(UserCertificate::getId));
        String res = "";
        if (userCertificateList.size() > 0){
            UserCertificate u0 = userCertificateList.get(0);
            String certificateNo = u0.getCertificateNo();
            int no = 0;
            if (certificateNo.contains("ZK")){
                no = Integer.parseInt(certificateNo.substring(5,11))+1;
            }else {
                no = Integer.parseInt(certificateNo.substring(3,9))+1;
            }
            if ("A".equals(type)){
                res = "NO."+String.format("%06d", no);
            }else if ("B".equals(type)){
                res = "NO."+String.format("%06d", no);
            }else if ("ZK".equals(type)){
                res = "NO.ZK"+String.format("%06d", no);
            }
        }else {
            if ("A".equals(type)){
                res = "NO.000001";
            }else if ("B".equals(type)){
                res = "NO.000001";
            }else if ("ZK".equals(type)){
                res = "NO.ZK000001";
            }
        }
        return res+courseNamePinyin;
    }



}