package com.peanut.modules.master.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.peanut.common.utils.R;
import com.peanut.modules.common.entity.*;
import com.peanut.modules.common.service.*;
import com.peanut.modules.master.service.CourseMedicalService;
import com.peanut.modules.master.service.CourseService;
import com.peanut.modules.master.service.CourseToMedicalService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 证书管理
 */
@Slf4j
@RestController("masterUserCertificate")
@RequestMapping("master/userCertificate")
public class UserCertificateController {

    @Autowired
    private UserCertificateService userCertificateService;
    @Autowired
    private UserCertificateLabelService userCertificateLabelService;
    @Autowired
    private MyUserService myUserService;
    @Autowired
    private CourseService courseService;
    @Autowired
    private CourseMedicalService courseMedicalService;
    @Autowired
    private CourseToMedicalService courseToMedicalService;

    //小班自考证书列表
    @RequestMapping("/userClassAndZKCertificateList")
    public R userClassAndZKCertificateList(@RequestBody Map<String,Object> params) {
        List list = new ArrayList<>();
        //查询顶级标签下子标签
        if ("13".equals(params.get("labelId").toString())) {
            bottomLabel(1,list);
        }else {
            bottomLabel(2,list);
        }
        //标签下课程
        List<Integer> bixiuList = courseToMedicalService.list(new LambdaQueryWrapper<CourseToMedicine>()
                .eq(CourseToMedicine::getSelective,1)
                .in(CourseToMedicine::getMedicalId,list)).stream().map(CourseToMedicine::getCourseId).collect(Collectors.toList());
        List<Integer> xuanxiuList = courseToMedicalService.list(new LambdaQueryWrapper<CourseToMedicine>()
                .eq(CourseToMedicine::getSelective,2)
                .in(CourseToMedicine::getMedicalId,list)).stream().map(CourseToMedicine::getCourseId).collect(Collectors.toList());
        //拥有小班证书的人
        MPJLambdaWrapper<MyUserEntity> wrapper = new MPJLambdaWrapper();
        wrapper.rightJoin(UserCertificate.class,UserCertificate::getUserId,MyUserEntity::getId);
        wrapper.in(UserCertificate::getLabelId,5,8);
        wrapper.and(t->t.in(UserCertificate::getCourseId,bixiuList)
                .or().in(UserCertificate::getCourseId,xuanxiuList));
        //过滤获得国际中医师证和国际针灸师证得人
        wrapper.notExists("select 1 from user_certificate where label_id = "+params.get("labelId")+" and user_id = t.id ");
        wrapper.select("count(1) as count,user_id userId,name,tel,email");
        wrapper.groupBy(UserCertificate::getUserId);
        wrapper.orderByDesc("count");
        List<Map<String,Object>> certificateMaps = myUserService.listMaps(wrapper);
        List<Map<String,Object>> resList = new ArrayList<>();
        for (Map<String,Object> map:certificateMaps){
            if ((long)map.get("count")>0){
                //用户获取得证书
                List<UserCertificate> certificateList = userCertificateService.list(new LambdaQueryWrapper<UserCertificate>()
                        .eq(UserCertificate::getUserId,map.get("userId"))
                        .in(UserCertificate::getLabelId,5,8)
                        .and(t->t.in(UserCertificate::getCourseId,bixiuList)
                                .or().in(UserCertificate::getCourseId,xuanxiuList)));
                map.put("msg","");
                if (certificateList.size()>0){
                    int bACount=0,bBCount=0,bZKCount=0,xCount=0;
                    for (UserCertificate uc : certificateList) {
                        if (bixiuList.contains(uc.getCourseId())){
                            uc.setSelective("必修");
                            if (uc.getCertificateNo().contains("ZK0")){
                                bZKCount++;
                            }else {
                                if (uc.getCertificateNo().contains("-B")){
                                    bBCount++;
                                }else {
                                    bACount++;
                                }
                            }
                        }else if (xuanxiuList.contains(uc.getCourseId())){
                            uc.setSelective("选修");
                            xCount++;
                        }
                    }
                    map.put("msg","A证："+bACount+"，B证："+bBCount+"，自考："+bZKCount+"，选修："+xCount);
                }
                map.put("certificate",certificateList);
                resList.add(map);
            }
        }
        resList = resList.stream().sorted((map1,map2)->{
            return Long.compare(((List)map2.get("certificate")).size(),((List)map1.get("certificate")).size());
        }).collect(Collectors.toList());
        Page<Map<String,Object>> page = new Page();
        page.setRecords(resList);
        page.setTotal(resList.size());
        page.setCurrent((int)params.get("current"));
        page.setSize((int)params.get("limit"));
        return R.ok().put("certificateList", page);
    }

    //查询顶级标签下子标签
    public void bottomLabel(int labelId,List list) {
        CourseMedicine cm = courseMedicalService.getById(labelId);
        if (cm != null) {
            if (cm.getIsLast()==1){
                list.add(cm.getId());
            }else {
                List<CourseMedicine> cms = courseMedicalService.list(new LambdaQueryWrapper<CourseMedicine>()
                        .eq(CourseMedicine::getPid,cm.getId()));
                for (CourseMedicine ccm:cms){
                    bottomLabel(ccm.getId(),list);
                }
            }
        }
    }

    //新增证书
    @RequestMapping("/addCertificate")
    public R addCertificate(@RequestBody UserCertificate userCertificate) {
        CourseEntity courseEntity = courseService.getById(userCertificate.getCourseId());
        if (courseEntity != null) {
            userCertificate.setTitle(courseEntity.getTitle());
        }
        userCertificateService.save(userCertificate);
        return R.ok();
    }

    //编辑证书
    @RequestMapping("/editCertificate")
    public R editCertificate(@RequestBody UserCertificate userCertificate) {
        userCertificateService.updateById(userCertificate);
        return R.ok();
    }

    //删除证书
    @RequestMapping("/delCertificate")
    public R delCertificate(@RequestBody UserCertificate userCertificate) {
        userCertificateService.removeById(userCertificate.getId());
        return R.ok();
    }

    //标签列表
    @RequestMapping("/userCertificateLabelList")
    public R userCertificateLabelList() {
        List<UserCertificateLabel> labelList = userCertificateLabelService.userCertificateLabelList();
        return R.ok().put("labelList", labelList);
    }

    //证书列表
    @RequestMapping("/userCertificateList")
    public R userCertificateList(@RequestBody Map<String,Object> params) {
        MPJLambdaWrapper<UserCertificate> wrapper = new MPJLambdaWrapper();
        wrapper.leftJoin(MyUserEntity.class,MyUserEntity::getId,UserCertificate::getUserId);
        wrapper.selectAll(UserCertificate.class);
        if (params.containsKey("labelId")&&StringUtils.isNotBlank(params.get("labelId").toString())) {
            wrapper.eq(UserCertificate::getLabelId,params.get("labelId"));
        }
        if (params.containsKey("userId")&&StringUtils.isNotBlank(params.get("userId").toString())) {
            wrapper.eq(MyUserEntity::getId,params.get("userId"));
        }
        if (params.containsKey("tel")&&StringUtils.isNotBlank(params.get("tel").toString())) {
            wrapper.like(MyUserEntity::getTel,params.get("tel"));
        }
        if (params.containsKey("title")&&StringUtils.isNotBlank(params.get("title").toString())) {
            wrapper.like(UserCertificate::getTitle,params.get("title"));
        }
        wrapper.orderByDesc(UserCertificate::getCreateTime);
        Page<UserCertificate> certificatePage = userCertificateService.page(new Page<>(
                Long.parseLong(params.get("current").toString()),Long.parseLong(params.get("limit").toString())),wrapper);
        for (UserCertificate certificate:certificatePage.getRecords()){
            certificate.setUser(myUserService.getById(certificate.getUserId()));
        }
        return R.ok().put("certificateList", certificatePage);
    }

    //新增标签
    @RequestMapping("/saveUserCertificateLabel")
    public R saveUserCertificate(@RequestBody UserCertificateLabel label) {
        userCertificateLabelService.save(label);
        return R.ok().put("labelId",label.getId());
    }

    //修改标签
    @RequestMapping("/editUserCertificateLabel")
    public R editUserCertificateLabel(@RequestBody UserCertificateLabel label) {
        UserCertificateLabel oldLabel = userCertificateLabelService.getById(label.getId());
        if(oldLabel.getIsLast()==0&& label.getIsLast()==1){
            List<UserCertificateLabel> childrens = userCertificateLabelService.list(new LambdaQueryWrapper<UserCertificateLabel>()
                    .eq(UserCertificateLabel::getPid, label.getId()));
            if(childrens.size()>0){
                return R.error("更新失败，请先清空此项的下级标签，才能将此标签变成终极标签");
            }
        }
        if(oldLabel.getIsLast()==1&& label.getIsLast()==0){
            Long integer = userCertificateService.count(new LambdaQueryWrapper<UserCertificate>()
                    .eq(UserCertificate::getLabelId, label.getId()));
            if(integer>0){
                return R.error("更新失败，标签下存在证书");
            }
        }
        userCertificateLabelService.updateById(label);
        return R.ok().put("labelId",label.getId());
    }

    //删除标签
    @RequestMapping("/delUserCertificateLabel")
    public R delUserCertificateLabel(@RequestBody Map<String,Object> params) {
        //查看下一级是否存在
        Long count = userCertificateLabelService.count(new LambdaQueryWrapper<UserCertificateLabel>()
                .eq(UserCertificateLabel::getPid, params.get("id")));
        if(count>0){
            return R.error("删除失败，请先删除子项目后再尝试");
        }
        //查看绑定关系是否存在
        Long integer = userCertificateService.count(new LambdaQueryWrapper<UserCertificate>()
                .eq(UserCertificate::getLabelId, params.get("id")));
        if(integer>0){
            return R.error("删除失败，标签下存在证书");
        }
        userCertificateLabelService.removeById((int)params.get("id"));
        return R.ok();
    }




}