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.CompetencyTree;
import com.seecoder.dataanalysis.data.entity.competency.DScore;
import com.seecoder.dataanalysis.data.entity.competency.KSDScore;
import com.seecoder.dataanalysis.data.entity.competency.KSScore;
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){
        //TODO 和ModelTree进行合并，空值补0，返回可以用于可视化的结果

        return null;
    }

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

        EvalExamRecord evalExamRecord = evalExamRecordDao.findById(exam_id).get();
        EvalExamInfo evalExamInfo = evalExamInfoDao.findById(exam_id).get();
        CompetencyTree competencyTree;

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

        //数据取完，开始进行KSD分析和入库
        List<KSDScore> subTree = competencyTree.getSubCompetencyTree();
        Integer difficulty = evalExamInfo.getDifficulty();
        String disposition = evalExamInfo.getDisposition();
        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] * studentScores.get(questionId);
            //增加能力树总分
            tree_Score += addScore;

            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(i);
                    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;
    }
}