package com.seecoder.dataanalysis.analysis.impl;

import com.seecoder.dataanalysis.analysis.EvalDataAnalysisService;
import com.seecoder.dataanalysis.data.dao.competency.CompetencyTreeDao;
import com.seecoder.dataanalysis.data.dao.eval.EvalExamInfoDao;
import com.seecoder.dataanalysis.data.dao.eval.EvalExamRecordDao;
import com.seecoder.dataanalysis.data.dao.eval.QuestionDao;
import com.seecoder.dataanalysis.data.entity.competency.*;
import com.seecoder.dataanalysis.data.entity.eval.EvalExamInfo;
import com.seecoder.dataanalysis.data.entity.eval.EvalExamRecord;
import com.seecoder.dataanalysis.data.entity.eval.Question;
import com.sun.xml.internal.bind.v2.TODO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;

/**
 * @author Peng Yiyan
 * @since 2022/02/03
 */

@Service
public class EvalDataAnalysisServiceImpl implements EvalDataAnalysisService {
    @Autowired
    private EvalExamRecordDao evalExamRecordDao;
    @Autowired
    private EvalExamInfoDao evalExamInfoDao;
    @Autowired
    private CompetencyTreeDao competencyTreeDao;
    @Autowired
    private QuestionDao questionDao;

    @Override
    public CompetencyTree getTreeById(int userId){

        Competencies competencies = new Competencies();
        CompetencyTree modelTree = new CompetencyTree(competencies);

        Optional<CompetencyTree> result = competencyTreeDao.findById(userId);
        if(!result.isPresent()){
            System.out.println("该学生的能力树不存在");
        }

        CompetencyTree competencyTree = competencyTreeDao.findById(userId).get();
        modelTree.setTreeScore(competencyTree.getTreeScore());

        List<KSDScore> modelKSD = modelTree.getSubCompetencyTree();
        List<KSDScore> tarKSD = competencyTree.getSubCompetencyTree();

        for(KSDScore ksdScore : tarKSD){
            String tarCom = ksdScore.getCompetency();
            List<KSScore> tarKS = ksdScore.getKSScore();
            List<DScore> tarD = ksdScore.getDScore();

            //找到对应的KSD树，开始进行KS和D的匹配
            for(KSDScore KSDModel : modelKSD){
                if(KSDModel.getCompetency().equals(tarCom)){
                    KSDModel.setTotalScore(ksdScore.getTotalScore());
                    //进行KS的匹配
                    List<KSScore> modelKS = KSDModel.getKSScore();
                    for(KSScore ksScore : tarKS){
                        String tarSub = ksScore.getKnowledge();
                        List<Double> tarSkillScore = ksScore.getSkillsAndScore();

                        for(KSScore KSModel : modelKS){
                            if(KSModel.getKnowledge().equals(tarSub)){
                                List<Double> after = KSModel.getSkillsAndScore();
                                for(int i=0;i<tarSkillScore.size();i++){
                                    after.set(i,tarSkillScore.get(i));
                                }
                                KSModel.setSkillsAndScore(after);
                                break;
                            }
                        }
                    }
                    KSDModel.setKSScore(modelKS);
                    //进行D的匹配
                    List<DScore> modelD = KSDModel.getDScore();
                    for(DScore dScore : tarD){
                        String tarName = dScore.getName();

                        for(DScore DModel : modelD){
                            if(DModel.getName().equals(tarName)){
                                DModel.setScore(dScore.getScore());
                                break;
                            }
                        }
                    }
                    KSDModel.setDScore(modelD);
                    break;
                }
            }
        }

        modelTree.setSubCompetencyTree(modelKSD);

        return modelTree;
    }

    @Override
    public CompetencyTree getTreeAfterExam(int recordId){
        //TODO 测试检查

        EvalExamRecord evalExamRecord = evalExamRecordDao.findById(recordId).get();

        Optional<EvalExamInfo> result1 = evalExamInfoDao.findById(evalExamRecord.getExamId());
        if(!result1.isPresent()){
            System.out.println("考试信息不存在");
            return null;
        }

        EvalExamInfo evalExamInfo = evalExamInfoDao.findById(evalExamRecord.getExamId()).get();
        CompetencyTree competencyTree;

        Optional<CompetencyTree> result2 = competencyTreeDao.findById(evalExamRecord.getUserId());
        if(!result2.isPresent()){
            competencyTree = new CompetencyTree(evalExamRecord.getUserId());
        }else {
            competencyTree  = competencyTreeDao.findById(evalExamRecord.getUserId()).get();
        }

        //数据取完，开始进行KSD分析和入库
        List<KSDScore> subTree = competencyTree.getSubCompetencyTree();
        //难度由1-5，分别对应1.0, 1.25, 1.5, 1.75, 2.0的得分系数
        Integer difficulty = evalExamInfo.getDifficulty();
        String disposition = evalExamInfo.getDisposition();
        System.out.println(competencyTree);
        Double tree_Score = competencyTree.getTreeScore();
        double[] difficulty_percent = new double[]{1.0,1.25,1.5,1.75,2.0};
        //得到学生所有题目的得分
        Map<String, Double> studentScores = evalExamRecord.getErrorQuestions();
//        Map<String,Double> questionAndScore = evalExamInfo.getQuestionAndScore();
        //修改成不初始化，而是逐条添加的模式
        for(Map.Entry<String,Double> entry : studentScores.entrySet()){
            String questionId = entry.getKey();
            Question question = questionDao.findById(questionId).get();

            //能力树中的加分 = 学生得分 * 试卷难度
            Double addScore = difficulty_percent[difficulty-1] * studentScores.get(questionId);
            //增加能力树总分,注意，每个competency都会加分
            tree_Score += (addScore*question.getCompetencies().size());

            for(int i=0;i<question.getCompetencies().size();i++){
                String competency = question.getCompetencies().get(i);
                KSScore ksScoreMessage = question.getKsScores().get(i);

                //判定当前的subTree中是否添加过该分支，若添加过则直接修改，否则要新建分支
                boolean existCom = false;
                KSDScore changeKSDScore = new KSDScore();
                //根据competency找大分类
                for(KSDScore ksdScore : subTree){
                    //competency大分支存在
                    if(ksdScore.getCompetency().equals(competency)){
                        existCom = true;
                        changeKSDScore = ksdScore;
                        break;
                    }
                }
                //competency大分支不存在，需要添加
                if(existCom == false){
                    changeKSDScore.setCompetency(competency);
                    changeKSDScore.setTotalScore(0.0);
                    List<KSScore> addKs = new ArrayList<>();
                    List<DScore> addD = new ArrayList<>();
                    changeKSDScore.setKSScore(addKs);
                    changeKSDScore.setDScore(addD);
                }


                //增加该KSD子树的分数
                Double total_score = changeKSDScore.getTotalScore();
                total_score += addScore;
                changeKSDScore.setTotalScore(total_score);

                //开始处理KSScore，记录子分支是否存在
                boolean existSubCom = false;
                //在对应的competency下进行下一步小分类
                List<KSScore> subKS = changeKSDScore.getKSScore();
                KSScore changeKSScore = new KSScore();
                for(KSScore ksScore : subKS){
                    if(ksScore.getKnowledge().equals(ksScoreMessage.getKnowledge())){
                        existSubCom = true;
                        changeKSScore = ksScore;
                        break;
                    }
                }
                //sub小分支不存在，需要添加并对分支名称和分数进行初始化
                if(existSubCom == false){
                    changeKSScore.setKnowledge(ksScoreMessage.getKnowledge());
                    changeKSScore.setSkillsAndScore(Arrays.asList(new Double[]{0.0,0.0,0.0,0.0,0.0,0.0}));
                }
                List<Double> skills = changeKSScore.getSkillsAndScore();
                for(int j=0;j<skills.size();j++){
                    Double score = ksScoreMessage.getSkillsAndScore().get(j) * addScore + skills.get(j);
                    skills.set(j,score);
                }
                changeKSScore.setSkillsAndScore(skills);
                //需要增加新建的KS子分支
                if(existSubCom == false){
                    subKS.add(changeKSScore);
                }


                //开始处理DScore，记录该品质是否存在
                boolean existD = false;
                List<DScore> subD = changeKSDScore.getDScore();
                DScore changeDScore = new DScore();
                for(DScore dScore : subD){
                    if(dScore.getName().equals(disposition)){
                        existD = true;
                        changeDScore = dScore;
                        break;
                    }
                }
                if(existD == false){
                    changeDScore.setName(disposition);
                    changeDScore.setScore(0.0);
                }
                Double addDScore = addScore + changeDScore.getScore();
                changeDScore.setScore(addDScore);
                //需要增加新建的D子分支
                if(existD == false){
                    subD.add(changeDScore);
                }

                //处理完KS分支和D分支
                changeKSDScore.setKSScore(subKS);
                changeKSDScore.setDScore(subD);

                if(existCom == false){
                    subTree.add(changeKSDScore);
                }
            }
        }

        //处理完考试中的每个问题后，更新能力树
        competencyTree.setTreeScore(tree_Score);
        competencyTree.setSubCompetencyTree(subTree);
        competencyTreeDao.save(competencyTree);

        return competencyTree;
    }

    @Override
    public Map<String, Double> getStudentErrorQuestions(int userId){
        List<EvalExamRecord> evalExamRecordList = evalExamRecordDao.findByUserId(userId);
        Map<String,Double> res = new HashMap<>();
        for(EvalExamRecord evalExamRecord : evalExamRecordList){
            Map<String,Double> errorQuestions = evalExamRecord.getErrorQuestions();
            for(String questionId : errorQuestions.keySet()){
                Optional<Question> result = questionDao.findById(questionId);
                if(!result.isPresent()){
                    System.out.println("题号不存在");
                    continue;
                }
                Question question = questionDao.findById(questionId).get();
                //如果题目分数为0，则跳过该题不做分析
                if(question.getQuestionScore() == 0){
                    continue;
                }
                Double scorePercent = errorQuestions.get(questionId) / question.getQuestionScore();
                res.put(questionId,res.getOrDefault(questionId,0.0)+scorePercent);
            }
        }
        return res;
    }
}