package com.ruoyi.web.service;

import cn.hutool.core.lang.Dict;
import com.alibaba.fastjson2.JSONObject;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.ruoyi.common.annotation.Excel;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.enums.ExamType;
import com.ruoyi.common.enums.SubjectType;
import com.ruoyi.common.utils.CommonUtils;
import com.ruoyi.common.utils.NumberUtils;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.dz.domain.DzClasses;
import com.ruoyi.dz.domain.DzSubject;
import com.ruoyi.dz.mapper.DzClassesMapper;
import com.ruoyi.dz.service.IDzSubjectService;
import com.ruoyi.enums.ExamineeStatus;
import com.ruoyi.enums.PaperStatus;
import com.ruoyi.enums.PaperType;
import com.ruoyi.ie.domain.AMarjorPlan;
import com.ruoyi.ie.mapper.AMarjorPlanMapper;
import com.ruoyi.learn.domain.*;
import com.ruoyi.learn.mapper.*;
import com.ruoyi.learn.service.ILearnTestService;
import com.ruoyi.syzy.domain.BBusiWishUniversities;
import com.ruoyi.syzy.mapper.BBusiWishUniversitiesMapper;
import lombok.Data;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.Pair;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import javax.validation.ValidationException;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

@Service
public class LearnTeacherService {
    private final DzClassesMapper dzClassesMapper;
    private final LearnKnowledgeTreeMapper learnKnowledgeTreeMapper;
    private final LearnStudentMapper learnStudentMapper;
    private final AMarjorPlanMapper marjorPlanMapper;
    private final BBusiWishUniversitiesMapper busiWishUniversitiesMapper;
    private final LearnDirectedKnowledgeMapper learnDirectedKnowledgeMapper;
    private final PaperService paperService;
    private final CommService commService;
    private final LearnTestPaperMapper learnTestPaperMapper;
    private final LearnQuestionsMapper learnQuestionsMapper;
    private final LearnKnowledgeCourseMapper learnKnowledgeCourseMapper;
    private final LearnTestStudentMapper learnTestStudentMapper;
    private final IDzSubjectService dzSubjectService;
    private final ILearnTestService learnTestService;
    private final LearnAnswerMapper learnAnswerMapper;

    public LearnTeacherService(DzClassesMapper dzClassesMapper, LearnKnowledgeTreeMapper learnKnowledgeTreeMapper, LearnStudentMapper learnStudentMapper, AMarjorPlanMapper marjorPlanMapper, BBusiWishUniversitiesMapper busiWishUniversitiesMapper, LearnDirectedKnowledgeMapper learnDirectedKnowledgeMapper, PaperService paperService, CommService commService, LearnTestPaperMapper learnTestPaperMapper, LearnQuestionsMapper learnQuestionsMapper, LearnKnowledgeCourseMapper learnKnowledgeCourseMapper, LearnTestStudentMapper learnTestStudentMapper, IDzSubjectService dzSubjectService, ILearnTestService learnTestService, LearnAnswerMapper learnAnswerMapper) {
        this.dzClassesMapper = dzClassesMapper;
        this.learnKnowledgeTreeMapper = learnKnowledgeTreeMapper;
        this.learnStudentMapper = learnStudentMapper;
        this.marjorPlanMapper = marjorPlanMapper;
        this.busiWishUniversitiesMapper = busiWishUniversitiesMapper;
        this.learnDirectedKnowledgeMapper = learnDirectedKnowledgeMapper;
        this.paperService = paperService;
        this.commService = commService;
        this.learnTestPaperMapper = learnTestPaperMapper;
        this.learnQuestionsMapper = learnQuestionsMapper;
        this.learnKnowledgeCourseMapper = learnKnowledgeCourseMapper;
        this.learnTestStudentMapper = learnTestStudentMapper;
        this.dzSubjectService = dzSubjectService;
        this.learnTestService = learnTestService;
        this.learnAnswerMapper = learnAnswerMapper;
    }

    public List<LearnQuestions> getQuestionTypes(Long subjectId, Collection<Long> knowledgeIds) {
        return learnQuestionsMapper.statQuestionTypes(subjectId, knowledgeIds);
    }

    public List<JSONObject> getClassesBuildStats(TestPaperVO.TestPaperBuildReq req, Long teacherId) {
        req.setTeacherId(teacherId);
        String buildType = req.getBuildType();
        if(buildType.startsWith("Exact")) {
            req.setSubjectId(11L);
        }
        if("ExactIntelligent".equals(buildType)){
            return dzClassesMapper.selectClassesDirectedBuildStats(req.toMap());
        } else if("ExactHand".equals(buildType)){
            return dzClassesMapper.selectClassesDirectedBuildStats(req.toMap());
        }
        return dzClassesMapper.selectClassesBuildStats(req.toMap());
    }

    public List<JSONObject> getPaperClassRecords(TestPaperVO.TestPaperBuildReq req, Long teacherId) {
        req.setTeacherId(teacherId);
        String buildType = req.getBuildType();
        if(buildType.startsWith("Exact")) {
            req.setSubjectId(11L);
        }
        if("ExactIntelligent".equals(buildType)){
            return dzClassesMapper.selectClassesDirectedBuildStats(req.toMap());
        } else if("ExactHand".equals(buildType)){
            return dzClassesMapper.selectClassesDirectedBuildStats(req.toMap());
        }
        return dzClassesMapper.selectClassesBuildStats(req.toMap());
    }

    public List<JSONObject> getPaperStudentRecords(TestPaperVO.TestPaperBuildReq req) {
        return dzClassesMapper.getPaperStudentRecords(req.toMap());
    }

    public List<JSONObject> getPaperStudentDetail(Long examineeId) {
        List<JSONObject> list = learnAnswerMapper.selectPaperKnowledgeStats(Dict.create().set("examineeId", examineeId));
        list.forEach(o -> {
            CommonUtils.normalRate(o);
        });
        return list;
    }

    public List<LearnTestPaper> getBuiltTestPaper(TestPaperVO.TestPaperBuildReq req) {
        LearnTestPaper cond = new LearnTestPaper();
        BeanUtils.copyProperties(req, cond);
        if(null != req.getMajorPlanId()) {
            AMarjorPlan plan = marjorPlanMapper.selectAMarjorPlanById(req.getMajorPlanId());
            LearnDirectedKnowledge dkCond = new LearnDirectedKnowledge();
            dkCond.setUniversityId(plan.getUniversityId());
            dkCond.setYear(plan.getYear());
            SysUser sysUser = SecurityUtils.getLoginUser().getUser();
            dkCond.setLocations(sysUser.getLocation());
            dkCond.setExamineeTypes(sysUser.getExamType().name());
            Map<String, LearnDirectedKnowledge> directedKnowledgeMap = learnDirectedKnowledgeMapper.selectLearnDirectedKnowledgeList(dkCond).stream().collect(Collectors.toMap(LearnDirectedKnowledge::getDirectKey, t -> t));
            LearnDirectedKnowledge directedKnowledge = getBestLearnDirectedKnowledge(plan, directedKnowledgeMap);
            cond.setDirectKey(buildDirectKey(directedKnowledge));
        }
        return learnTestPaperMapper.selectLearnTestPaperList(cond);
    }

    public List<DzClasses> getClasses(Long teacherId)
    {
        return dzClassesMapper.selectClassesForTeacher(teacherId);
    }

    public List<LearnStudent> getStudents(Long batchId, Long classId) {
        return learnStudentMapper.selectClassStudents(batchId, new Long[] {classId});
    }

    public List<BBusiWishUniversities> selectUniversityList(Long teacherId, Long batchId) {
        return busiWishUniversitiesMapper.selectUniversityListForTeacher(teacherId, batchId);
    }

    public List<Dict> selectMajorList(Long universityId, Integer year, Long batchId, String examType) {
        // TODO 由于未区分考生类型，好些会重复，暂取最小计划，使用这个去匹配相关的类型
        return marjorPlanMapper.selectMajorForUniversity(universityId, year, "ExactHand", batchId, 11L, examType).stream().map(t -> Dict.create().set("id", t.getId()).set("majorGroup", t.getMajorGroup())
                .set("majorName", t.getMajorName()).set("count", t.getXuefei()).set("total", t.getPlanTotal())).collect(Collectors.toList());
    }

    public String buildDirectKey(LearnDirectedKnowledge dk) {
        return dk.getUniversityId() + "_" + dk.getExamineeTypes() + "_" + StringUtils.trimToEmpty(dk.getDirectKey());
    }
    public String buildDirectKey(LearnStudent dk) {
        return dk.getUniversityId() + "_" + dk.getExamType() + "_" + StringUtils.trimToEmpty(dk.getDirectKey());
    }

    @Transactional(rollbackFor = Exception.class)
    public String buildPapersDirect(TestPaperVO.TestPaperBuildReq req) {
        // 查询待生成或发布的学生列表
        List<LearnStudent> studentList = learnStudentMapper.selectLearnStudentsByMap(req.toMap());
        if(CollectionUtils.isEmpty(studentList)) {
            throw new ValidationException("无学生可发布");
        }
        // 定向手动是精准到一个计划，定向自动是对应一组计划
        Map<Long, Map<String, List<LearnStudent>>> universityDirectStudentMap = studentList.stream()
                .collect(Collectors.groupingBy(LearnStudent::getUniversityId, Collectors.groupingBy(this::buildDirectKey, Collectors.toList())));
        // 查询已经生成的
        Map<Long, Map<String, LearnTestPaper>> universityDirectPaperMap = learnTestPaperMapper.selectByBatchAndUniversityIds(req.getBuildType(), req.getBatchId(), req.getSubjectId(), universityDirectStudentMap.keySet()).stream()
                .collect(Collectors.groupingBy(LearnTestPaper::getUniversityId, Collectors.toMap(t -> StringUtils.trimToEmpty(t.getDirectKey()), a -> a)));
        // 补充发卷
        if("ExactHand".equals(req.getBuildType())) { // 肯定只有一个计划
            for(Long universityId : universityDirectStudentMap.keySet()) {
                Map<String, List<LearnStudent>> directedStudentsMap = universityDirectStudentMap.get(universityId);
                Map<String, LearnTestPaper> directPaperMap = universityDirectPaperMap.get(universityId);
                buildPapersDirect(req, universityId, req.getExamType(), null, directedStudentsMap, directPaperMap);
            }
        } else {
            // directKey = universityId_examType_directKey
            Map<Long, Map<String, LearnDirectedKnowledge>> universityDirectedKnowledgeMap = learnDirectedKnowledgeMapper.selectByUniversityIds(universityDirectStudentMap.keySet().toArray(new Long[universityDirectStudentMap.size()])).stream().collect(
                    Collectors.groupingBy(LearnDirectedKnowledge::getUniversityId, Collectors.toMap(this::buildDirectKey, a -> a)));
            for(Long universityId : universityDirectedKnowledgeMap.keySet()) {
                Map<String, LearnDirectedKnowledge> directedKnowledgeMap = universityDirectedKnowledgeMap.get(universityId);
                Map<String, List<LearnStudent>> directedStudentsMap = universityDirectStudentMap.get(universityId);
                Map<String, LearnTestPaper> directPaperMap = universityDirectPaperMap.get(universityId);
                if(null == directedKnowledgeMap) {
                    throw new ValidationException("院校无定向定义");
                }
                buildPapersDirect(req, universityId, req.getExamType(), directedKnowledgeMap, directedStudentsMap, directPaperMap);
            }
        }
        return "";
    }

    private void buildPapersDirect(TestPaperVO.TestPaperBuildReq req, Long universityId, String examType, Map<String, LearnDirectedKnowledge> directedKnowledgeMap, Map<String, List<LearnStudent>> directedStudentsMap, Map<String, LearnTestPaper> directPaperMap) {
        if(null == directPaperMap) {
            directPaperMap = Maps.newHashMap();
        }
        DzSubject dzSubject = dzSubjectService.selectDzSubjectBySubjectId(req.getSubjectId());
        LearnTest learnTest = learnTestService.selectLearnTestByBatchId(req.getBatchId());
        for(String directedKey : directedStudentsMap.keySet()) {
            LearnTestPaper learnTestPaper;
            if(null == (learnTestPaper = directPaperMap.get(directedKey))) {
                LearnPaper paper = new LearnPaper();
                paper.setSubjectId(req.getSubjectId());
                String paperName = StringUtils.isBlank(req.getName()) ? learnTest.getName() + "_" + dzSubject.getSubjectName() + "_" + directedKey : req.getName();
                paper.setPaperName(paperName.length() > 254 ? paperName.substring(0, 254) : paperName);
                paper.setYear(Calendar.getInstance().get(Calendar.YEAR)); // TODO  年度
                paper.setPaperType(PaperType.Test.name());
                paper.setDirectKey(directedKey);
                paper.setFenshu(0);
                if(null == directedKnowledgeMap) {
                    List<LearnPaperQuestion> pqList = Lists.newArrayList();
                    for (LearnPaperQuestion q : req.getQuestions()) {
                        LearnPaperQuestion pq = new LearnPaperQuestion();
                        pq.setQuestionId(q.getId()); // 没传questionId?
                        pq.setSeq(pqList.size() + 1);
                        pq.setKnowledgeId(q.getKnowledgeId());
                        pq.setScore(null == q.getScore() ? 1.0 : q.getScore());
                        pqList.add(pq);
                    }
                    paperService.savePaper(paper, pqList);
                } else {
                    LearnDirectedKnowledge directedKnowledge = directedKnowledgeMap.get(directedKey);
                    TestPaperVO.PaperDef paperDef = req.getPaperDef();
                    examType = directedKnowledge.getExamineeTypes();
                    paperDef.setKnowIds(Stream.of(directedKnowledge.getKnowledges().split(",")).map(t -> Long.parseLong(t.trim())).collect(Collectors.toList()));
                    if (CollectionUtils.isEmpty(paperDef.getTypes())) {
                        paperDef.setTypes(getQuestionTypes(null, paperDef.getKnowIds()).stream().map(t -> {
                            TestPaperVO.TypeDef typeDef = new TestPaperVO.TypeDef();
                            typeDef.setType(t.getQtpye());
                            typeDef.setScore(1);
                            typeDef.setTitle(t.getQtpye());
                            return typeDef;
                        }).collect(Collectors.toList()));
                    }
                    if(paperDef.getTotal().equals(0L)) { // TODO  总数怎么定？
                        paperDef.setTotal(15L);
                    }
                    Pair<LearnPaper, List<LearnPaperQuestion>> paperResult = paperService.buildPaper(null, paper, paperDef);
                    paperService.savePaper(paperResult.getKey(), paperResult.getValue());
                }
                LearnTestPaper testPaper = new LearnTestPaper();
                testPaper.setBuildType(req.getBuildType());
                testPaper.setUniversityId(universityId);
                testPaper.setExamType(examType);
                testPaper.setBatchId(req.getBatchId());
                testPaper.setSubjectId(req.getSubjectId());
                testPaper.setDirectKey(directedKey);
                testPaper.setPaperId(paper.getId());
                testPaper.setConditions(JSONObject.toJSONString(req));
                testPaper.setCreatorId(SecurityUtils.getUserId());
                learnTestPaperMapper.insertLearnTestPaper(testPaper);
                directPaperMap.put(directedKey, testPaper);
                learnTestPaper = testPaper;
            }
            for(LearnStudent student : directedStudentsMap.get(directedKey)) {
                LearnTestStudent lts = new LearnTestStudent();
                lts.setBatchId(req.getBatchId());
                lts.setStudentId(student.getStudentId());
                lts.setBuildType(req.getBuildType());
                lts.setSubjectId(req.getSubjectId());
                lts.setDirectKey(directedKey);
                lts.setPaperId(learnTestPaper.getPaperId());
                lts.setClassId(student.getClassId());
                lts.setStatus(ExamineeStatus.Sign.getVal());
                learnTestStudentMapper.insertLearnTestStudent(lts);
            }
        }
    }

    @Transactional(rollbackFor = Exception.class)
    public String buildPapersFull(TestPaperVO.TestPaperBuildReq req) {
        List<LearnStudent> studentList = learnStudentMapper.selectLearnStudentsByMap(req.toMap());
        if(CollectionUtils.isEmpty(studentList)) {
            throw new ValidationException("无学生可发布");
        }
        DzSubject dzSubject = dzSubjectService.selectDzSubjectBySubjectId(req.getSubjectId());
        LearnTest learnTest = learnTestService.selectLearnTestByBatchId(req.getBatchId());
        // 查询已经生成的
        List<LearnTestPaper> learnTestPaperList = learnTestPaperMapper.selectByBatchAndUniversityIds(req.getBuildType(), req.getBatchId(), req.getSubjectId(),null);
        LearnTestPaper learnTestPaper;
        if(CollectionUtils.isEmpty(learnTestPaperList)) {
            LearnPaper paper = new LearnPaper();
            paper.setSubjectId(req.getSubjectId());
            String paperName = StringUtils.isBlank(req.getName()) ? learnTest.getName() + "_" + dzSubject.getSubjectName() : req.getName();
            paper.setPaperName(paperName.length() > 254 ? paperName.substring(0, 254) : paperName);
            paper.setYear(Calendar.getInstance().get(Calendar.YEAR)); // TODO  年度
            paper.setPaperType(PaperType.Test.name());
            paper.setDirectKey("");
            paper.setStatus(PaperStatus.Valid.getVal());
            paper.setRelateId(req.getBatchId().longValue());
            paper.setFenshu(0);
            if("FullHand".equals(req.getBuildType())) {
                List<LearnPaperQuestion> pqList = Lists.newArrayList();
                Double fenScore = 0.0;
                for (LearnPaperQuestion q : req.getQuestions()) {
                    LearnPaperQuestion pq = new LearnPaperQuestion();
                    pq.setQuestionId(q.getId()); // 没传questionId?
                    pq.setSeq(pqList.size() + 1);
                    pq.setKnowledgeId(q.getKnowledgeId());
                    pq.setScore(null == q.getScore() ? 1.0 : q.getScore());
                    fenScore += q.getScore();
                    pqList.add(pq);
                }
                paper.setFenshu((int) Math.round(fenScore));
                paperService.savePaper(paper, pqList);
            } else {
                Pair<LearnPaper, List<LearnPaperQuestion>> paperResult = paperService.buildPaper(null, paper, req.getPaperDef());
                paperService.savePaper(paperResult.getKey(), paperResult.getValue());
            }
            LearnTestPaper testPaper = new LearnTestPaper();
            testPaper.setBuildType(req.getBuildType());
            testPaper.setBatchId(req.getBatchId());
            testPaper.setExamType(req.getExamType());
            testPaper.setSubjectId(req.getSubjectId());
            testPaper.setDirectKey("");
            testPaper.setPaperId(paper.getId());
            testPaper.setConditions(JSONObject.toJSONString(req));
            testPaper.setCreatorId(SecurityUtils.getUserId());
            learnTestPaperMapper.insertLearnTestPaper(testPaper);
            learnTestPaper = testPaper;
        } else {
            learnTestPaper = learnTestPaperList.get(0);
        }
        for(LearnStudent student : studentList) {
            LearnTestStudent lts = new LearnTestStudent();
            lts.setBatchId(req.getBatchId());
            lts.setStudentId(student.getStudentId());
            lts.setBuildType(req.getBuildType());
            lts.setSubjectId(req.getSubjectId());
            lts.setDirectKey("");
            lts.setPaperId(learnTestPaper.getPaperId());
            lts.setClassId(student.getClassId());
            lts.setStatus(ExamineeStatus.Sign.getVal());
            learnTestStudentMapper.insertLearnTestStudent(lts);
        }
        return "";
    }

    public List<TreeNode> getKnowledgeTree(String examineeType, Long subjectId, Set<Long> knowledgeIdSet, Long studentId) {
        LearnKnowledgeTree ktCond = new LearnKnowledgeTree();
        if (null != subjectId && !subjectId.equals(100L)) {
            ktCond.setSubjectId(subjectId);
        }
        ktCond.setExamineeTypes(examineeType);
        List<LearnKnowledgeTree> ktList = learnKnowledgeTreeMapper.selectLearnKnowledgeTreeList(ktCond);
        Map<Long, Integer[]> knowCountMap = null;
        if(NumberUtils.isPositive(studentId) && !CollectionUtils.isEmpty(ktList)) {
            Map cond = Maps.newHashMap();
            cond.put("studentId", studentId);
            cond.put("knowIds", ktList.stream().map(LearnKnowledgeTree::getId).collect(Collectors.toList()));
            knowCountMap = Maps.newHashMap();
            for(LearnQuestions qs : learnQuestionsMapper.statByKnowledge(cond)) {
                knowCountMap.put(qs.getKnowledgeId(), new Integer[] { qs.getNumber().intValue(), qs.getId().intValue(), qs.getYear().intValue()} );
            }
        }
        return commService.buildTree(ktList, knowledgeIdSet, knowCountMap);
    }

    public List<TreeNode> getCourseKnowledgeTree(Long studentId) {
        LearnKnowledgeCourse ktCond = new LearnKnowledgeCourse();
        List<LearnKnowledgeCourse> ktList = learnKnowledgeCourseMapper.selectLearnKnowledgeCourseList(ktCond);
        Map<Long, Integer[]> knowCountMap = null;
        if(NumberUtils.isPositive(studentId) && !CollectionUtils.isEmpty(ktList)) {
            Map<Long, Set<Long>> q2coursesMap = Maps.newHashMap();
            for(LearnKnowledgeCourse kt : ktList) {
                if(StringUtils.isNotBlank(kt.getKnowledges())) {
                    for(String idStr : kt.getKnowledges().split(",")) {
                        Long id = Long.parseLong(idStr);
                        Set<Long> courseSet = q2coursesMap.computeIfAbsent(id, k -> Sets.newHashSet());
                        courseSet.add(kt.getId());
                    }
                }
            }
            Map cond = Maps.newHashMap();
            cond.put("studentId", studentId);
            cond.put("knowIds", q2coursesMap.keySet());
            knowCountMap = Maps.newHashMap();
            for(LearnQuestions qs : learnQuestionsMapper.statByKnowledge(cond)) {
                for(Long qnId : q2coursesMap.get(qs.getKnowledgeId())) {
                    Integer[] counts = knowCountMap.get(qnId);
                    if(null == counts) {
                        knowCountMap.put(qnId, new Integer[] { qs.getNumber().intValue(), qs.getId().intValue(), qs.getYear().intValue()} );
                    } else {
                        knowCountMap.put(qnId, new Integer[] { counts[0] + qs.getNumber().intValue(), counts[1] + qs.getId().intValue(), counts[2] + qs.getYear().intValue()} );
                    }
                }
            }
        }
        return commService.buildCourseKnowledgeTree(ktList, knowCountMap);
    }

    public String updateDirected(Long studentId, Long universityId, Long planId) {
        LearnStudent upStudent = new LearnStudent();
        upStudent.setStudentId(studentId);
        upStudent.setUniversityId(universityId);
        upStudent.setMajorPlanId(planId);
        upStudent.setDirectKey("");
        AMarjorPlan plan = marjorPlanMapper.selectAMarjorPlanById(planId);
        LearnDirectedKnowledge dkCond = new LearnDirectedKnowledge();
        dkCond.setUniversityId(plan.getUniversityId());
        dkCond.setYear(plan.getYear());
        SysUser sysUser = SecurityUtils.getLoginUser().getUser();
        dkCond.setLocations(sysUser.getLocation());
        dkCond.setExamineeTypes(sysUser.getExamType().name());
        Map<String, LearnDirectedKnowledge> directedKnowledgeMap = learnDirectedKnowledgeMapper.selectLearnDirectedKnowledgeList(dkCond).stream().collect(Collectors.toMap(LearnDirectedKnowledge::getDirectKey, t -> t));
        LearnDirectedKnowledge directedKnowledge = getBestLearnDirectedKnowledge(plan, directedKnowledgeMap);
        String modules = null;
        if(null != directedKnowledge) {
            upStudent.setDirectKey(directedKnowledge.getDirectKey());
            modules = directedKnowledge.getModules();
            upStudent.setModules(modules);
        }
        learnStudentMapper.updateLearnStudent(upStudent);
        Set<String> moduleSet = Sets.newHashSet(StringUtils.trimToEmpty(modules).split(","));
        return moduleSet.size() == 1 && moduleSet.contains("技能展示/实践操作") ? "该专业只考技能展示/实践操作" : "";
    }

    private LearnDirectedKnowledge getBestLearnDirectedKnowledge(AMarjorPlan plan, Map<String, LearnDirectedKnowledge> directedKnowledgeMap) {
        LearnDirectedKnowledge directedKnowledge = null;
        String groupName = StringUtils.trimToEmpty(plan.getMajorGroup());
        if(null != (directedKnowledge = directedKnowledgeMap.get(groupName + "_" + plan.getMajorName()))) {
            return directedKnowledge;
        }
        for(String directKey : directedKnowledgeMap.keySet()) {
            if(directKey.contains("、") && (directKey.startsWith(groupName + "_"))) {
                Set<String> marjorSet = Arrays.stream(directKey.split("_|、")).filter(t -> !t.isEmpty()).collect(Collectors.toSet());
                if(marjorSet.contains(plan.getMajorName())) {
                    return directedKnowledgeMap.get(directKey);
                }
            }
        }
        if(null != (directedKnowledge = directedKnowledgeMap.get(groupName))) {
            return directedKnowledge;
        }
        if(null != (directedKnowledge = directedKnowledgeMap.get(""))) {
            return directedKnowledge;
        }
        return directedKnowledge;
    }

    public Set<Long> getSubjectIdSet(Long[] planIds) {
        Set<Long> subjectIdSet = Sets.newHashSet();
        if(ArrayUtils.isNotEmpty(planIds)) {
            List<AMarjorPlan> planList = marjorPlanMapper.selectAMarjorPlanByIds(planIds);
            AMarjorPlan curr = planList.get(0);
            LearnDirectedKnowledge dkCond = new LearnDirectedKnowledge();
            dkCond.setUniversityId(curr.getUniversityId());
            dkCond.setYear(curr.getYear());
            SysUser sysUser = SecurityUtils.getLoginUser().getUser();
            dkCond.setLocations(sysUser.getLocation());
            dkCond.setExamineeTypes(sysUser.getExamType().name());
            Map<String, LearnDirectedKnowledge> directedKnowledgeMap = learnDirectedKnowledgeMapper.selectLearnDirectedKnowledgeList(dkCond).stream().collect(Collectors.toMap(LearnDirectedKnowledge::getDirectKey, t -> t));
            LearnDirectedKnowledge directedKnowledge = null;
            for(AMarjorPlan plan : planList) {
                if(null != (directedKnowledge = getBestLearnDirectedKnowledge(plan, directedKnowledgeMap)) && StringUtils.isNotBlank(directedKnowledge.getSubjects())) {
                    subjectIdSet.addAll(Stream.of(directedKnowledge.getSubjects().split(",")).map(t -> Long.parseLong(t.trim())).collect(Collectors.toList()));
                }
            }
        }
        return subjectIdSet;
    }

    public Set<Long> getKnowledgeIdSet(Long planId) {
        if(NumberUtils.isPositive(planId)) {
            SysUser sysUser = SecurityUtils.getLoginUser().getUser();
            List<AMarjorPlan> planList = marjorPlanMapper.selectAMarjorPlanByIds(new Long[] { planId });
            if(CollectionUtils.isEmpty(planList)) {
                return Sets.newHashSet();
            }
            return getStudentKnowledgeIdSet(planList.get(0), sysUser.getLocation(), sysUser.getExamType().name());
        }
        return Sets.newHashSet();
    }

    public Set<Long> getStudentKnowledgeIdSet(AMarjorPlan curr, String location, String examType) {
        Set<Long> knowledgeIdSet = Sets.newHashSet();
        LearnDirectedKnowledge dkCond = new LearnDirectedKnowledge();
        dkCond.setUniversityId(curr.getUniversityId());
        dkCond.setYear(curr.getYear());

        dkCond.setLocations(location);
        dkCond.setExamineeTypes(examType);
        Map<String, LearnDirectedKnowledge> directedKnowledgeMap = learnDirectedKnowledgeMapper.selectLearnDirectedKnowledgeList(dkCond).stream().collect(Collectors.toMap(LearnDirectedKnowledge::getDirectKey, t -> t));
        LearnDirectedKnowledge directedKnowledge = null;
        if(null != (directedKnowledge = getBestLearnDirectedKnowledge(curr, directedKnowledgeMap)) && StringUtils.isNotBlank(directedKnowledge.getKnowledges())) {
            knowledgeIdSet.addAll(Stream.of(directedKnowledge.getKnowledges().split(",")).map(t -> Long.parseLong(t.trim())).collect(Collectors.toList()));
        }
        return knowledgeIdSet;
    }

    @Data
    public static class TreeNode {
        private Long id;
        private String name;
        private Integer status;
        private Integer questionCount;
        private Integer finishedCount;
        private Integer rightCount;
        private Double finishedRatio;

        List<TreeNode> children = Lists.newArrayList();
        public TreeNode(Long id, String name, Integer[] counts) {
            this.id = id;
            this.name = name;
            this.status = 0;
            this.questionCount = null != counts ? counts[0] : 0;
            this.finishedCount = null != counts ? counts[1] : 0;
            this.rightCount = null != counts ? counts[2] : 0;
            calcRatio();
        }

        public void calcRatio() {
            this.finishedRatio = finishedCount > 0 ? Math.max(Math.round(rightCount * 1000.0 / finishedCount) / 10.0, 0.1) : 0.0;
        }

        public boolean setChecked(Set<Long> idSet) {
            boolean checkSelf = idSet.contains(id);
            if(CollectionUtils.isEmpty(children)) {
                this.status = checkSelf ? 1 : 0;
                return true;
            }
            int count = 0;
            for(TreeNode tn : children) {
                if(checkSelf || idSet.contains(tn.getId())) {
                    tn.setStatus(1);
                    count++;
                }
            }
            if(children.size() == count) {
                this.status = 1;
                return true;
            }
            return false;
        }
    }
}