package com.aijia.kmt.service.impl;

import com.aijia.core.utils.StringUtil;
import com.aijia.core.web.ResponseConstant;
import com.aijia.core.web.ResponseEntity;
import com.aijia.kmt.common.taskthread.AijiaThreadPool;
import com.aijia.kmt.dto.KnowHowDetailsDTO;
import com.aijia.kmt.dto.exercise.ExerciseQuestionAnswerValue;
import com.aijia.kmt.dto.knowledge.KnowledgeBaseDto;
import com.aijia.kmt.enums.ProofreadStatusEnum;
import com.aijia.kmt.es.service.ExerciseQuestionSearchService;
import com.aijia.kmt.es.service.base.BaseSearchService;
import com.aijia.kmt.mapper.*;
import com.aijia.kmt.po.KmtExerciseBook;
import com.aijia.kmt.po.KmtExerciseQuestion;
import com.aijia.kmt.po.KmtExerciseQuestionKnow;
import com.aijia.kmt.po.base.IdWorker;
import com.aijia.kmt.po.knowledge.ZuoybKnowHowDetailsSort;
import com.aijia.kmt.po.user.TbLibManager;
import com.aijia.kmt.po.user.User;
import com.aijia.kmt.service.*;
import com.aijia.kmt.task.SyncRefreshExerciseBookStatusTask;
import com.aijia.kmt.utils.ExerciseUtil;
import com.aijia.kmt.utils.JSONFileUtil;
import com.aijia.kmt.utils.PropertiesUtil;
import com.aijia.kmt.vo.AuditingV1Request;
import com.aijia.kmt.vo.QuestionPublishRequest;
import com.aijia.kmt.vo.QuestionUpdateRequest;
import com.aijia.questioninfo.service.KmtExerciseQuestionInfoService;
import com.aijia.train.bean.TrTrainPartUser;
import com.aijia.train.bean.TrTrainUserExercise;
import com.aijia.train.bean.TrTrainUserQuestionKnow;
import com.aijia.train.mapper.TrainUserExerciseMapper;
import com.aijia.train.mapper.TrainUserQuestionKnowMapper;
import com.aijia.train.mapper.TrainUserServiceMapper;
import com.aijia.utils.DateUtil;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.google.common.collect.Collections2;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.MapUtils;
import org.apache.commons.lang3.StringUtils;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;
import java.util.stream.Collectors;

@Service
public class KmtExerciseSubmitServiceImpl implements KmtExerciseSubmitService {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Autowired
    private KmtExerciseMapper kmtExerciseMapper;
    @Autowired
    private KmtExerciseService kmtExerciseService;
    @Autowired
    private TokenManager tokenManager;
    @Autowired
    private KmtExerciseQuestionService kmtExerciseQuestionService;
    @Autowired
    private BaseSearchService baseSearchService;
    @Autowired
    private ExerciseQuestionSearchService exerciseQuestionSearchService;
    @Autowired
    private LibManagerMapper libManagerMapper;
    @Autowired
    private UserMapper userMapper;
    @Autowired
    private HowDetailSortMapper howDetailSortMapper;
    @Autowired
    private KmtExerciseQuestionDealService kmtExerciseQuestionDealService;
    @Autowired
    private KmtExerciseQuestionInfoService questionInfoService;

    @Autowired
    private TrainUserQuestionKnowMapper userQuestionKnowMapper;

    @Autowired
    private TrainUserServiceMapper userServiceMapper;

    @Autowired
    private TrainUserExerciseMapper userExerciseMapper;

    @Autowired
    private KmtExerciseQuestionMapper kmtExerciseQuestionMapper;


    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    public ResponseEntity submit2Auditing(AuditingV1Request request, String userId) {
        ResponseEntity responseEntity = new ResponseEntity();
        Map<String,Object> data = new HashMap<>(8);
        if (CollectionUtils.isNotEmpty(request.getQuestions())) {
//            logger.error("2");
            List<String> questionIds = request.getQuestions().stream().map(QuestionUpdateRequest::getQuestionId).collect(Collectors.toList());
            List<KmtExerciseQuestion> questions = kmtExerciseMapper.findKmtExerciseQuestionsByIdIn(questionIds);
            questions.forEach(q->{
                List<QuestionUpdateRequest> reqList = request.getQuestions();
                reqList.forEach(r->{
                    if(q.getId().equals(r.getQuestionId())){
                        TrTrainUserExercise questionInfo = userExerciseMapper.selectOne(
                                new QueryWrapper<TrTrainUserExercise>().eq("question_id",r.getQuestionId())
                                        .eq("user_id", userId)
                        );
                        if (questionInfo == null){
                            //已经提交过的也更新
                            questionInfo = new TrTrainUserExercise();
                            KmtExerciseQuestion kmtExerciseQuestion = kmtExerciseQuestionMapper.selectById(q.getId());
                            questionInfo.setQuestionId(r.getQuestionId());
                            questionInfo.setQuestionOrg(kmtExerciseQuestion.getImage());
                            questionInfo.setUserId(userId);
                            questionInfo.setExerciseId(q.getBookId());
                            questionInfo.setQuestion(q.getQuestion());
                            questionInfo.setQuestionText(r.getQuestionText());
                            questionInfo.setQuestionJson(q.getQuestionJson());
                            questionInfo.setAnswer(r.getAnswer());
                            questionInfo.setAnswerJson(r.getAnswerJson());
                            questionInfo.setAnalysis(q.getAnalysis());
                            questionInfo.setAnalysisJson(r.getAnalysisJson());
                            questionInfo.setCreateTime(DateUtil.format_yyyyMMddHHmmss(new Date()));
                            questionInfo.setStatus(request.getType()==0?2:1);
                            if(CollectionUtils.isNotEmpty(r.getDifficultyLevels())){
                                questionInfo.setDifficultyLevel(r.getDifficultyLevels().get(0).getType());
                            }
                            if(CollectionUtils.isNotEmpty(r.getQuestionTypes())){
                                questionInfo.setQuestionType(r.getQuestionTypes().get(0).getType());
                            }
                            if(CollectionUtils.isNotEmpty(r.getRealExamTypes())){
                                questionInfo.setRealExamType(r.getRealExamTypes().stream().map(k->k.getType()+"").collect(Collectors.joining(",")));
                            }
                            if(CollectionUtils.isNotEmpty(r.getTrainingSkills())){
                                questionInfo.setTrainingSkill(r.getTrainingSkills().stream().map(KnowledgeBaseDto::getName).collect(Collectors.joining(",")));
                            }
                            userExerciseMapper.insert(questionInfo);
                        }else{
                            KmtExerciseQuestion kmtExerciseQuestion = kmtExerciseQuestionMapper.selectById(q.getId());
                            questionInfo.setQuestionId(r.getQuestionId());
                            questionInfo.setQuestionOrg(kmtExerciseQuestion.getImage());
                            questionInfo.setUserId(userId);
                            questionInfo.setExerciseId(q.getBookId());
                            questionInfo.setQuestion(q.getQuestion());
                            questionInfo.setQuestionText(r.getQuestionText());
                            questionInfo.setQuestionJson(q.getQuestionJson());
                            questionInfo.setAnswer(r.getAnswer());
                            questionInfo.setAnswerJson(r.getAnswerJson());
                            questionInfo.setAnalysis(q.getAnalysis());
                            questionInfo.setAnalysisJson(r.getAnalysisJson());
                            questionInfo.setCreateTime(DateUtil.format_yyyyMMddHHmmss(new Date()));
                            questionInfo.setStatus(request.getType()==0?2:1);
                            if(CollectionUtils.isNotEmpty(r.getDifficultyLevels())){
                                questionInfo.setDifficultyLevel(r.getDifficultyLevels().get(0).getType());
                            }
                            if(CollectionUtils.isNotEmpty(r.getQuestionTypes())){
                                questionInfo.setQuestionType(r.getQuestionTypes().get(0).getType());
                            }
                            if(CollectionUtils.isNotEmpty(r.getRealExamTypes())){
                                questionInfo.setRealExamType(r.getRealExamTypes().stream().map(k->k.getType()+"").collect(Collectors.joining(",")));
                            }
                            if(CollectionUtils.isNotEmpty(r.getTrainingSkills())){
                                questionInfo.setTrainingSkill(r.getTrainingSkills().stream().map(KnowledgeBaseDto::getName).collect(Collectors.joining(",")));
                            }
                            userExerciseMapper.updateById(questionInfo);
                        }
                    }
                });
            });

//            kmtExerciseService.appendQuestionDataFromJSONFile(questions); //读文件，把题目信息加载到实体中
            KmtExerciseBook book = kmtExerciseMapper.findExerciseBookById(questions.get(0).getExerciseBookId());
//            this.appendUser2QuestionBean(questions, book);  //把加工审核人，校对人加载到实体中
            //走事务保存练习册，题目，知识点
            this.updateBookAndQuestionsAndKnow(questions, book, request,userId);
            /**
             * 更新用户状态为已提交
             */
            //查看是否所有的题目都处理提交
            //查询提交题目数
            int count = userExerciseMapper.selectCount(new QueryWrapper<TrTrainUserExercise>()
                    .eq("user_id",userId).eq("exercise_id",questions.get(0).getBookId()).eq("status",1));
            //查询总题目数
            int qCount = kmtExerciseQuestionMapper.selectCount(new QueryWrapper<KmtExerciseQuestion>()
                    .eq("book_id",questions.get(0).getBookId()));
            data.put("commitAll",1);
            if(count == qCount){
                TrTrainPartUser user = userServiceMapper.selectById(userId);
                user.setStudyStatus(4);
                userServiceMapper.updateById(user);
                data.put("commitAll",2);
            }

            responseEntity.success(data,"提交成功");
        }
        return responseEntity;
    }


    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void updateBookAndQuestionsAndKnow (List<KmtExerciseQuestion> questions, KmtExerciseBook book, AuditingV1Request request,String userId){
        List<String> questionIds = request.getQuestions().stream().map(QuestionUpdateRequest::getQuestionId).collect(Collectors.toList());
        //保存大字段文件
        //kmtExerciseService.saveQuestionData2JSONFile(questions,userId);
        //删除之前的
        kmtExerciseMapper.deleteKmtExerciseQuestionKnowByQuestionIds(questionIds, userId);
        List<TrTrainUserQuestionKnow> questionKnows = new ArrayList<>();
        for (QuestionUpdateRequest updateRequest : request.getQuestions()) {
            if (CollectionUtils.isNotEmpty(updateRequest.getKnowledges())) {
                for (KmtExerciseQuestion question : questions) {
                    if (question.getId().equals(updateRequest.getQuestionId())){
                        questionKnows.addAll(this.getKmtQuestionKnow(updateRequest.getKnowledges(), question));
                        break;
                    }
                }
            }
        }
        if (CollectionUtils.isNotEmpty(questionKnows)) {
            for (TrTrainUserQuestionKnow know : questionKnows){
                know.setUserId(userId);
                userQuestionKnowMapper.insert(know);
            }
        }

    }

    /**
     * 获取更新的题目的当前状态下的题数
     * @param questions
     * @param type
     * @return
     */
    private int getQuestionStatusCount (List<KmtExerciseQuestion> questions, int type){
        int result = 0;
        if (type == 0){
            for (KmtExerciseQuestion q :questions){
                if (q.getDealStatus() == 0 || q.getDealStatus() == 1) {
                    result += 1;
                }
            }
        } else if (type == 1){
            for (KmtExerciseQuestion q :questions){
                if (q.getDealStatus() == 3 || q.getDealStatus() == 7) {
                    result += 1;
                }
            }
        } else if (type == 4){
            for (KmtExerciseQuestion q :questions){
                if (q.getDealStatus() == 5 || q.getDealStatus() == 8) {
                    result += 1;
                }
            }
        } else if (type == 5){
            for (KmtExerciseQuestion q :questions){
                if (q.getDealStatus() == 9 || q.getDealStatus() == 10) {
                    result += 1;
                }
            }
        }
        return result;
    }


    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    public void updateEsQuestionAndKnow (List<KmtExerciseQuestion> questions, List<String> questionIds){
        for (KmtExerciseQuestion kmtExerciseQuestion : questions){
            kmtExerciseQuestionService.saveToEs(kmtExerciseQuestion);
        }

        QueryBuilder queryBuilder = QueryBuilders.termsQuery("question_id.keyword", questionIds);
        exerciseQuestionSearchService.deleteByQuery("kmt_exercise_question_know", queryBuilder);
        List<Map<String, Object>> knowEsData = kmtExerciseMapper.findData2EsByQuestionList(questionIds);
        if (CollectionUtils.isNotEmpty(knowEsData)) {
            kmtExerciseService.appendQuestionMapFromJSONFile(knowEsData);
            baseSearchService.insertBatch("kmt_exercise_question_know", knowEsData, true);
        }
    }

    @Override
    public ResponseEntity publishQuestion(QuestionPublishRequest request, String userId) {
        ResponseEntity responseEntity = new ResponseEntity();
        //查询用户是否有提交数据
        if (CollectionUtils.isNotEmpty(request.getQuestionIds())) {
            List<KmtExerciseQuestion> questions = kmtExerciseMapper.findKmtExerciseQuestionsByIdIn(request.getQuestionIds());
            questions.forEach(q -> {
                TrTrainUserExercise questionInfo = userExerciseMapper.selectOne(
                        new QueryWrapper<TrTrainUserExercise>().eq("question_id", q.getId())
                                .eq("user_id", userId)
                );
                if (questionInfo == null) {
                    //没有提交记录就用原来题目的信息
                    questionInfo = new TrTrainUserExercise();
                    KmtExerciseQuestion kmtExerciseQuestion = kmtExerciseQuestionMapper.selectById(q.getId());
                    questionInfo.setQuestionId(q.getId());
                    questionInfo.setQuestionOrg(kmtExerciseQuestion.getImage());
                    questionInfo.setUserId(userId);
                    questionInfo.setExerciseId(q.getBookId());
                    questionInfo.setQuestion(q.getQuestion());
                    questionInfo.setQuestionText(q.getQuestionText());
                    questionInfo.setQuestionJson(q.getQuestionJson());
                    questionInfo.setAnswer(q.getOptionAnswer());
                    questionInfo.setAnswerJson(q.getAnswerJson());
                    questionInfo.setAnalysis(q.getAnalysis());
                    questionInfo.setAnalysisJson(q.getAnalysisJson());
                    questionInfo.setCreateTime(DateUtil.format_yyyyMMddHHmmss(new Date()));
                    questionInfo.setStatus(1);
                    questionInfo.setDifficultyLevel(q.getDifficultyLevel());
                    questionInfo.setQuestionType(q.getQuestionType());
                    questionInfo.setRealExamType(q.getRealExamType());
                    questionInfo.setTrainingSkill(q.getTrainingSkill());
                    userExerciseMapper.insert(questionInfo);
                } else {
                    //已经编辑过的信息更新状态
                    questionInfo.setStatus(1);
                    userExerciseMapper.updateById(questionInfo);
                }
            });
            responseEntity.success("发布成功");
        }else{
            responseEntity.failure("未查到题目信息");
        }
        return responseEntity;
    }


    /**
     * 是否是管理员提交
     * @param userId
     * @param type
     * @return
     */
    private boolean isManagerSubmit (String userId, int type){
        TbLibManager manager = libManagerMapper.findByUserIdAndType(userId, 18);
        if (manager != null) {
            //管理员把状态设置为3，不改任何状态
            return true;
        }
        return false;
    }

    /**
     * 是否是答案校对提交
     * @param type
     * @return
     */
    private boolean isAnswerCorrectSubmit (int type) {
        // 答案校对修改提交
        if (Objects.equals(type, 6)) {
            return true;
        }
        return false;
    }

    /**
     * 是否存在已发布的题目
     * @param questions
     * @param type
     * @return
     */
    private boolean isExistQuestonsPulish (List<KmtExerciseQuestion> questions, int type){
        boolean exist = false;
        if (type == 4 && questions.stream().anyMatch(q -> q.getDealStatus() == 11)) {
            //解析加工提交， 但是题目存在解析已发布
            exist = true;
        } else if (type == 0 && questions.stream().anyMatch(q -> q.getDealStatus() == 4 || q.getDealStatus() == 5 || q.getDealStatus() > 7)) {
            //题目加工提交，但是题目存在加工已发布
            exist = true;
        }
        return exist;
    }

    /**
     * 是否存在不可操作题目
     * @param questions
     * @param type
     * @return
     */
    private boolean isExistQuestionCantDeal (List<KmtExerciseQuestion> questions, int type){
        boolean exist = false;
        if (type == 0 && questions.stream().anyMatch(q ->
                q.getDealStatus() != 0 && q.getDealStatus() != 1 && q.getDealStatus() != 3 && q.getDealStatus() != 7)){
            exist = true;
        } else if (type == 1 && questions.stream().anyMatch(q -> q.getDealStatus() != 3 && q.getDealStatus() != 7)){
            exist = true;
        } else if (type == 4 && questions.stream().anyMatch(q ->
                q.getDealStatus() != 5 && q.getDealStatus() != 8 && q.getDealStatus() != 9 && q.getDealStatus() != 10)){
            exist = true;
        } else if (type == 5 && questions.stream().anyMatch(q -> q.getDealStatus() != 9 && q.getDealStatus() != 10)){
            exist = true;
        }
        return exist;
    }

    /**
     * 练习册加工审核是否提交了知识点
     * @param request
     * @return
     */
    private boolean isQuestionHandlerSubmitKnowledge (AuditingV1Request request){
        boolean  result = true;
        if (request.getType() == 0 || request.getType() == 1 || request.getType() == 3){
            for (QuestionUpdateRequest questionUpdateRequest : request.getQuestions()){
                if (CollectionUtils.isEmpty(questionUpdateRequest.getKnowledges())){
                    result = false;
                    break;
                }
            }
        }
        return result;
    }

    /**
     * 把练习册的加工审核人，校对人加入到题目实体中
     * @param questions
     * @param book
     */
    private void appendUser2QuestionBean (List<KmtExerciseQuestion> questions, KmtExerciseBook book){
        if (CollectionUtils.isNotEmpty(questions)){
            for (KmtExerciseQuestion kmtExerciseQuestion : questions) {
                kmtExerciseQuestion.setHandleUserId(book.getHandleUserId());
                kmtExerciseQuestion.setAuditingUserId(book.getAuditingUserId());
                kmtExerciseQuestion.setAnalysisUserId(book.getAnalysisUserId());
                kmtExerciseQuestion.setAnalysisAuditerId(book.getAnalysisAuditerId());
                kmtExerciseQuestion.setAnswerCorrecterId(book.getAnswerCorrecterId());
            }
        }
    }


    /**
     * 提交审核更新为未加工，未审核
     * @param questionCount
     * @param exerciseBook
     * @param dealType
     */
    private void updateKmtExerciseBookFinishStatus (int questionCount, KmtExerciseBook exerciseBook, int dealType){
        int count = 0;
        if (dealType == 0){
            //题目加工
            if (exerciseBook.getHadHandle() == 0){
                count = kmtExerciseMapper.countUnFinishQuestionsByExerciseBookId(exerciseBook.getId(), 1);
                if (count <= questionCount){
                    exerciseBook.setHadHandle(1);
                }
            }
            if (exerciseBook.getHadHandle() == 1 && StringUtil.isNotBlank(exerciseBook.getAuditingUserId())) {
                //加工完了通知加工审核老师
                this.push2ExerciseTeacher(exerciseBook.getAuditingUserId(),  exerciseBook, 2);
            }
            exerciseBook.setHadAuditing(0);
        } else if (dealType == 1) {
            //题目发布
            if (exerciseBook.getHadAuditing() == 0){
                count = kmtExerciseMapper.countUnFinishQuestionsByExerciseBookId(exerciseBook.getId(), 2);
                if (count <= questionCount){
                    exerciseBook.setHadAuditing(1);
                }
            }
            if (exerciseBook.getHadHandle() == 1 && exerciseBook.getHadAuditing() == 1){
                //加工完了通知加工审核老师
                exerciseBook.setProgress("已发布");
                if (StringUtil.isNotBlank(exerciseBook.getAnalysisUserId())){
                    this.push2ExerciseTeacher(exerciseBook.getAnalysisUserId(),exerciseBook, 3);
                }
            }
            exerciseBook.setAnalysisHandled(0);
        } else if (dealType == 4){
            //题目解析加工
            if (exerciseBook.getAnalysisHandled() == 0){
                count = kmtExerciseMapper.countUnFinishQuestionsByExerciseBookId(exerciseBook.getId(), 3);
                if (count <= questionCount){
                    exerciseBook.setAnalysisHandled(1);
                }
            }

            if (exerciseBook.getHadHandle() == 1 && exerciseBook.getHadAuditing() == 1
                    && exerciseBook.getAnalysisHandled() == 1 && StringUtil.isNotBlank(exerciseBook.getAnalysisAuditerId())){
                //加工完了通知加工审核老师
                this.push2ExerciseTeacher(exerciseBook.getAnalysisAuditerId(), exerciseBook, 4);
            }
            exerciseBook.setAnalysisAudited(0);
        } else if (dealType == 5 && exerciseBook.getAnalysisAudited() == 0){
            //题目解析发布
            count = kmtExerciseMapper.countUnFinishQuestionsByExerciseBookId(exerciseBook.getId(), 4);
            if (count <= questionCount){
                exerciseBook.setAnalysisAudited(1);
            }
        }
    }

    /**
     * 练习册加工完推送下一个阶段的老师
     * @param userId
     * @param exerciseBook
     * @param type
     */
    private void push2ExerciseTeacher (String userId, KmtExerciseBook exerciseBook,int type){
        String key = "push_bookId"+exerciseBook.getId()+userId;
        if(tokenManager.exists(key)){
            return ;
        }

        Map<String, String> data = new HashMap<>();
        String template_id_short = "OPENTM206165551";
        User user = userMapper.selectById(userId);
        if  (user != null && StringUtils.isNotEmpty(user.getAccount()) ){
            try{
                TbLibManager libTeacher = libManagerMapper.findByUserIdAndType(userId, 17);
                if (libTeacher != null){
                    String teacherName = null;
                    teacherName = libTeacher.getName();
                    if (StringUtils.isEmpty(teacherName)){
                        teacherName = user.getName();
                    }
                    String authName =  null;
                    switch (type){
                        case 1: authName="题目加工"; break;
                        case 2: authName="审核发布"; break;
                        case 3: authName="解析加工"; break;
                        case 4: authName="解析发布"; break;
                        default: authName="加工"; break;
                    }


                    String bookType =  null;
                    switch (exerciseBook.getBookType()){
                        case 0: bookType="整本"; break;
                        case 1: bookType="上半本"; break;
                        case 2: bookType="下半本"; break;
                        case 3: bookType="不同的页码的新版练习册"; break;
                        default: bookType=""; break;
                    }

//                    // 你好，你有一本 数学人教版上册四年级 整本、半本,《我爱写作业(2020)》，
//
//                    StringBuffer sb =new StringBuffer("你好，你有一本");
//                    sb.append(exerciseBook.getCourseName()).append(exerciseBook.getVersionName()).append(exerciseBook.getSemester()==1?"上册":"下册");
//                    sb.append(exerciseBook.getGrade()).append(bookType).append("《").append(exerciseBook.getBookName()).append("》,");
//                    sb.append(authName+"请在规定时间内完成");
//                    data.put("first", sb.toString());
//                    data.put("keyword1", teacherName);
//                    data.put("keyword2", DateUtil.format_yyyyMMddHHmmss(new Date()));
//                    data.put("remark", "请及时登录处理，如有疑问请及时联系相关负责老师。");
//                    SendTemplateShort sendTemplateShort = new SendTemplateShort(user.getAccount(), template_id_short, null, data);
//                    pushTemplateService.saveAndSendPushWxTemplate(sendTemplateShort);
                    tokenManager.setString(key,authName,12*60*60);
                } else {
                    logger.error("没有老师角色" + userId);
                }
            } catch (Exception e){
                logger.error("推送练习册老师失败：", e);
            }
        }
    }

    /**
     * 更新题目信息
     * @param questions
     * @param questionUpdateRequests
     * @param type
     */
    private void getKmtExerciseQuestionData (List<KmtExerciseQuestion> questions, List<QuestionUpdateRequest> questionUpdateRequests,
                                                int type, boolean isAnswerCorrectSubmit) {
        //解析加工或解析审核
        if (isAnswerCorrectSubmit) {
            this.updateProofreadStatusSubmit(questions, questionUpdateRequests);
            String exerciseBookId = questions.get(0).getExerciseBookId();
              // 如果已经没有需要修改答案的题目，则修改练习册的校对状态为已修改
            List<String> questionIds = questionUpdateRequests.stream().map(QuestionUpdateRequest::getQuestionId).collect(Collectors.toList());

            int count = kmtExerciseMapper.countAnswerWrongQuestion(exerciseBookId, new HashSet<>(questionIds));
                if (count < 1) {
                    kmtExerciseMapper.updateKmtExerciseBookProofreadStatus(exerciseBookId, ProofreadStatusEnum.ManagerModified.getCode());
                }

        } else if (type == 0) {
            this.updateHandlerQuestions(questions, questionUpdateRequests);
        } else if (type == 1) {
            this.updateAuditingUserQuestion(questions, questionUpdateRequests);
        } else if (type == 3){
            this.updateManagerQuestions(questions, questionUpdateRequests);
        } else if (type == 4) {
            this.updateAnalysisHandleQuestions(questions, questionUpdateRequests);
        } else if (type == 5) {
            this.updateAnalysisAuditingQuestions(questions, questionUpdateRequests);
        }
    }

    /**
     * 解析加工的提交功能，如果是加工人（题目deal_status=5,8）, 记录解析加工时间， 修改题目状态
     * @param questions
     * @param questionUpdateRequests
     */
    private void updateAnalysisHandleQuestions (List<KmtExerciseQuestion> questions, List<QuestionUpdateRequest> questionUpdateRequests) {
        for (KmtExerciseQuestion question : questions) {
            for (QuestionUpdateRequest updateRequest : questionUpdateRequests) {
                if (question.getId().equals(updateRequest.getQuestionId())) {
                    question.setAnalysisJson(updateRequest.getAnalysisJson());
                    question.setAnalysis(updateRequest.getQuestionAnalysis());
                    if (question.getDealStatus() == 5 || question.getDealStatus() == 8) {
                        question.setAnalysisHandlerSubmitTime(new Date());
                        question.setDealStatus(9);
                    }
                }
            }
        }
    }

    /**
     * 解析加工的发布功能, 记录解析加工时间， 修改题目状态
     * @param questions
     * @param questionUpdateRequests
     */
    private void updateAnalysisAuditingQuestions (List<KmtExerciseQuestion> questions, List<QuestionUpdateRequest> questionUpdateRequests) {
        for (KmtExerciseQuestion question : questions) {
            for (QuestionUpdateRequest updateRequest : questionUpdateRequests) {
                if (question.getId().equals(updateRequest.getQuestionId())) {
                    question.setAnalysisJson(updateRequest.getAnalysisJson());
                    question.setAnalysis(updateRequest.getQuestionAnalysis());
                    question.setDealStatus(11);
                    question.setAnalysisSubmitTime(new Date());
                }
            }
        }
    }

    /**
     * 题目加工提交功能
     * @param questions
     * @param questionUpdateRequests
     */
    private void updateHandlerQuestions (List<KmtExerciseQuestion> questions, List<QuestionUpdateRequest> questionUpdateRequests) {
        //循坏题目
        for (KmtExerciseQuestion question : questions) {
            for (QuestionUpdateRequest updateRequest : questionUpdateRequests) {
                if (question.getId().equals(updateRequest.getQuestionId())) {
                    this.updateKmtQuestionCommonData(question, updateRequest);
                    if (question.getDealStatus() == 0 || question.getDealStatus() == 1) {
                        question.setHandlerSubmitTime(new Date());
                        question.setDealStatus(3);
                    }
                }
            }
        }
    }

    /**
     * 题目审核提交发布功能
     * @param questions
     * @param questionUpdateRequests
     */
    private void updateAuditingUserQuestion (List<KmtExerciseQuestion> questions, List<QuestionUpdateRequest> questionUpdateRequests){
        //循坏题目
        for (KmtExerciseQuestion question : questions) {
            for (QuestionUpdateRequest updateRequest : questionUpdateRequests) {
                if (question.getId().equals(updateRequest.getQuestionId())) {
                    this.updateKmtQuestionCommonData(question, updateRequest);
                    question.setPublishTime(new Date());
                    question.setDealStatus(5);
                    int startX = 0;
                    if (StringUtil.isNotBlank(question.getConciseId())){
                        startX = Integer.parseInt(question.getConciseId());
                    }
                    // TODO: 2020/12/10 判断是否需要去题号
                    if (question.getEnumerate()==1){
                        String path = null;
                        try {
                            path = kmtExerciseQuestionDealService.removeQuestionNumMark(startX, question.getAnalysisSubmitType(),
                                    question.getUpdateType(), question.getEsLoaded(), question.getImage());
                        } catch (Exception e){
                            logger.error("异常", e);
                        }
                        String content = JSONFileUtil.readJSONFile(PropertiesUtil.getValue("EXERCISE_JSON_FILE_PATH") + question.getQuestionPath());
                        if (StringUtil.isNotBlank(content) && StringUtil.isNotBlank(path)){
                            Map<String, Object> map = JSON.parseObject(content, Map.class);
                            ExerciseQuestionAnswerValue questionAnswerValue = ExerciseUtil.getExerciseQuestionAnswerValue(path);
                            if (questionAnswerValue == null){
                                map.put("question_json", "[]");
                            } else {
                                map.put("question_json", Collections.singletonList(questionAnswerValue));
                            }
                            map.put("question", "<img src='" + PropertiesUtil.getValue("STATIC_FILE_URL") + path + "'/>");
                            JSONFileUtil.saveJSONFile(PropertiesUtil.getValue("EXERCISE_JSON_FILE_PATH") + question.getQuestionPath(), JSON.toJSONString(map));
                            questionInfoService.updateQuestionAndJsonByQuestionId(question.getId(), map);
                            question.setQuestionJson(JSON.toJSONString(map.get("question_json")));
                            question.setQuestion((String)map.get("question"));
                        }
                    }

                }
            }
        }
    }

    /**
     * 管理员提交， 不修改题目状态
     * @param questions
     * @param questionUpdateRequests
     */
    private void updateManagerQuestions (List<KmtExerciseQuestion> questions, List<QuestionUpdateRequest> questionUpdateRequests) {
        //循坏题目
        for (KmtExerciseQuestion question : questions) {
            for (QuestionUpdateRequest updateRequest : questionUpdateRequests) {
                if (question.getId().equals(updateRequest.getQuestionId())) {
                    this.updateKmtQuestionCommonData(question, updateRequest);
                }
            }
        }
    }

    /**
     * 校对更新提交
     * @param questions
     * @param questionUpdateRequests
     */
    private void updateProofreadStatusSubmit (List<KmtExerciseQuestion> questions, List<QuestionUpdateRequest> questionUpdateRequests) {
        //循坏题目
        for (KmtExerciseQuestion question : questions) {
            for (QuestionUpdateRequest updateRequest : questionUpdateRequests) {
                if (question.getId().equals(updateRequest.getQuestionId())) {
                    this.updateKmtQuestionCommonData(question, updateRequest);
                    question.setProofreadStatus(ProofreadStatusEnum.ManagerModified.getCode());
                }
            }
        }
    }

    /**
     * 更新单个题目的信息
     * @param question
     * @param updateRequest
     */
    private void updateKmtQuestionCommonData (KmtExerciseQuestion question, QuestionUpdateRequest updateRequest) {
        question.setQuestionText(updateRequest.getQuestionText());
        question.setOptionAnswer(updateRequest.getAnswer());
        question.setAnswerJson(updateRequest.getAnswerJson());
        question.setAnalysis(updateRequest.getQuestionAnalysis());
        question.setAnalysisJson(updateRequest.getAnalysisJson());

        if (CollectionUtils.isNotEmpty(updateRequest.getQuestionTypes())) {
            question.setQuestionType(updateRequest.getQuestionTypes().get(0).getType());
        }
        if (CollectionUtils.isNotEmpty(updateRequest.getDifficultyLevels())) {
            question.setDifficultyLevel(updateRequest.getDifficultyLevels().get(0).getType());
        }

        if (CollectionUtils.isNotEmpty(updateRequest.getRealExamTypes())) {
            List<Integer> types = updateRequest.getRealExamTypes().stream().map(KnowledgeBaseDto::getType).collect(Collectors.toList());
            question.setRealExamType(StringUtils.join(types, ","));
        }

        if (CollectionUtils.isNotEmpty(updateRequest.getTrainingSkills())) {
            List<String> names = updateRequest.getTrainingSkills().stream().map(KnowledgeBaseDto::getName).collect(Collectors.toList());
            question.setTrainingSkill(StringUtils.join(names, ","));
        }
    }

    /**
     * 添加题目关联的知识点 kmt_exercise_question_know， zyb_know_how_details_sort
     * @param knowledges
     * @param question
     */
    private List<TrTrainUserQuestionKnow> getKmtQuestionKnow (List<KnowHowDetailsDTO> knowledges, KmtExerciseQuestion question){
        //知识点不为空添加知识点
        List<TrTrainUserQuestionKnow> questionKnows = new ArrayList<>();
        if (CollectionUtils.isNotEmpty(knowledges)){
            for (KnowHowDetailsDTO detail : knowledges){
                ZuoybKnowHowDetailsSort detailsSort = howDetailSortMapper.selectById(detail.getId());
                if (CollectionUtils.isNotEmpty(detail.getPoints())){
                    //有考点的情况
                    detail.getPoints().forEach(point -> {
                        //添加题目与考点的关联记录
                        TrTrainUserQuestionKnow kmtExerciseQuestionKnow = new TrTrainUserQuestionKnow();
                        kmtExerciseQuestionKnow.setId(IdWorker.generateId());
                        ZuoybKnowHowDetailsSort pointSort = howDetailSortMapper.selectById(point.getId());
                        kmtExerciseQuestionKnow.setQuestionId(question.getId());
                        kmtExerciseQuestionKnow.setQuestionParentId(question.getParentId());
                        kmtExerciseQuestionKnow.setHowDetailsId(detailsSort.getHowDetailsId());
                        kmtExerciseQuestionKnow.setHowDetailsKdId(pointSort.getHowDetailsKdId());
                        kmtExerciseQuestionKnow.setVersion(detailsSort.getType());
                        kmtExerciseQuestionKnow.setLoaded(0);
                        kmtExerciseQuestionKnow.setCreateTime(new Date());
                        kmtExerciseQuestionKnow.setUpdateTime(new Date());
                        kmtExerciseQuestionKnow.setHowDetailSortId(detailsSort.getId());
                        kmtExerciseQuestionKnow.setHowDetailKdSortId(pointSort.getId());
                        questionKnows.add(kmtExerciseQuestionKnow);

                    });
                } else {
                    //没有考点的情况只记录知识点
                    TrTrainUserQuestionKnow  kmtExerciseQuestionKnow = new TrTrainUserQuestionKnow();
                    kmtExerciseQuestionKnow.setId(IdWorker.generateId());
                    kmtExerciseQuestionKnow.setQuestionId(question.getId());
                    kmtExerciseQuestionKnow.setQuestionParentId(question.getParentId());
                    kmtExerciseQuestionKnow.setHowDetailsId(detailsSort.getHowDetailsId());
                    kmtExerciseQuestionKnow.setHowDetailSortId(detailsSort.getId());
                    kmtExerciseQuestionKnow.setVersion(detailsSort.getType());
                    kmtExerciseQuestionKnow.setLoaded(0);
                    kmtExerciseQuestionKnow.setCreateTime(new Date());
                    kmtExerciseQuestionKnow.setUpdateTime(new Date());
                    questionKnows.add(kmtExerciseQuestionKnow);
                }
            }
        }
        return questionKnows;
    }
}