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.math.BigDecimal;
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("/openClass")
    public R openClass(@RequestBody Map<String,Object> params){
        return classEntityService.openClass(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("考试周禁止提交作业");
        }
        int res = classEntityService.addClassTaskAndQuesReply(classTaskAndQuesReply);
        if (res==2){
            return R.error("已提交");
        }else if (res==1){
            return R.ok();
        }else {
            return R.error("提交失败");
        }
    }

    //通过任务获取作业列表
    @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("/closeClass")
    @Transactional
    public R closeClass(@RequestBody Map<String,Object> params){
        //结班限制
        R r = classEntityService.closeClass(params);
        //结班后给合格学员发放证书
        if ("0".equals(r.get("code").toString())){
            ClassEntity classEntity = classEntityService.getById(params.get("classId").toString());
            List<Map<String,Object>> userScoreList = classEntityService.userScoreList(params);
            for (Map<String, Object> userScoreMap : userScoreList) {
                if (new BigDecimal(userScoreMap.get("userScore").toString()).compareTo(new BigDecimal(60))>=0){
                    UserCertificate userCertificate = new UserCertificate();
                    userCertificate.setTitle(classEntity.getTitle());
                    String type = "B";
                    if (new BigDecimal(userScoreMap.get("userScore").toString()).compareTo(new BigDecimal(70))>=0){
                        type = "A";
                    }
                    userCertificate.setType(type);
                    MyUserEntity user = (MyUserEntity)userScoreMap.get("user");
                    userCertificate.setUserId(user.getId());
                    userCertificate.setClassId(classEntity.getId());
                    //查询小班下得课程信息
                    List<Map<String,Object>> classCourseInfoLlist = classEntityService.classCourseInfoClassId(classEntity.getId(),0);
                    for (Map<String,Object> classCourseInfo:classCourseInfoLlist){
                        if (StringUtils.isNotEmpty(classCourseInfo.get("titleAbbr").toString())
                                &&StringUtils.isNotEmpty(classCourseInfo.get("courseETitle").toString())){
                            String certificateNo = classEntityService.getNextCertificateNo(type,classCourseInfo.get("titleAbbr").toString());
                            userCertificate.setCertificateNo(certificateNo);
                            userCertificate.setCourseId((Integer) classCourseInfo.get("courseId"));
                            if (StringUtils.isNotEmpty(user.getPhoto())&&StringUtils.isNotEmpty(user.getName())){
                                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())+"";
                                double keshiTotal = (double)classCourseInfo.get("keshi");
                                String keshi = (keshiTotal+"").replace(".0","");
                                String courseTitle = classCourseInfo.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 = {classCourseInfo.get("courseETitle").toString(),keshi};
                                String url = userCertificateService.generateCertificate(type,certificateNo,user.getPhoto(),user.getName(),
                                        des, edes, endYear,endMonth,endDay);
                                userCertificate.setCertificateUrl(url);
                            }
                            userCertificateService.save(userCertificate);
                        }else {
                            R.error("课程未设置英文名或缩写");
                        }
                    }
                }
            }
            return R.ok();
        }else {
            return r;
        }
    }

    //生成证书图片
    @RequestMapping("/generateCertificateClass")
    public R generateCertificateClass(@RequestBody Map<String,Object> params) {
        MyUserEntity user = ShiroUtils.getUser();
        String photoUrl = user.getPhoto();//证书人照片
        String realName = user.getName();//真实姓名
        UserCertificate userCertificate = userCertificateService.getById(params.get("id").toString());
        String type = userCertificate.getType();//证书类型A a证 B b证 ZK自考
        if ("ZK".equals(type)){
            CourseEntity courseEntity = courseService.getById(userCertificate.getCourseId());
            String courseTitle = userCertificate.getTitle();
            ClassExamUser classExamUser = classExamUserService.getOne(new LambdaQueryWrapper<ClassExamUser>()
                    .eq(ClassExamUser::getUserId,ShiroUtils.getUId())
                    .eq(ClassExamUser::getRelationId,userCertificate.getCourseId()));
            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 = userCertificate.getCertificateNo();//证书编号
            String url = userCertificateService.generateCertificate(type,certificateNo,photoUrl,realName, description, edes, endYear,endMonth,endDay);
            userCertificate.setCertificateUrl(url);
            userCertificateService.updateById(userCertificate);
        }else {
            ClassEntity classEntity = classEntityService.getById(userCertificate.getClassId());
            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(),userCertificate.getCourseId());
            for (Map<String,Object> map:list){
                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 = userCertificate.getCertificateNo();
                String url = userCertificateService.generateCertificate(type,certificateNo,photoUrl,realName,des, edes, endYear,endMonth,endDay);
                userCertificate.setCertificateUrl(url);
                userCertificateService.updateById(userCertificate);
            }
        }
        return R.ok();
    }

    //获取小班证书
    @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);
    }



}