package com.ots.project.exam.service.impl;
import cn.hutool.core.collection.CollUtil;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.ots.common.enums.SenderCode;
import com.ots.common.enums.UserTypeEnum;
import com.ots.common.utils.DateUtils;
import com.ots.common.utils.MessageUtils;
import com.ots.common.utils.StringUtils;
import com.ots.common.utils.Threads;
import com.ots.common.utils.bean.BeanUtils;
import com.ots.common.utils.poi.WordUtil;
import com.ots.common.utils.security.ShiroUtils;
import com.ots.common.utils.text.Convert;
import com.ots.framework.web.domain.Ztree;
import com.ots.framework.web.service.DictService;
import com.ots.project.exam.domain.*;
import com.ots.project.exam.dto.*;
import com.ots.project.exam.mapper.*;
import com.ots.project.exam.service.*;
import com.ots.project.exam.viewmodel.ExamPaperSubmitVM;
import com.ots.project.system.dict.domain.DictData;
import com.ots.project.system.dict.service.IDictDataService;
import com.ots.project.system.user.domain.User;
import com.ots.project.tool.email.EmailMessage;
import com.ots.project.tool.email.RushMailResult;
import com.ots.project.tool.exam.ExamUtil;
import com.ots.project.tool.exam.JsonUtil;
import com.ots.project.tool.exam.ModelMapperSingle;
import com.ots.project.tool.gen.service.IExamUtilService;
import com.ots.project.tool.report.reportCalculation.request.*;
import com.ots.project.tool.report.reportCalculation.response.ReportAPIResult;
import lombok.extern.slf4j.Slf4j;
import org.modelmapper.ModelMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.i18n.LocaleContextHolder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.*;
import java.util.stream.Collectors;
import static com.ots.project.tool.report.reportCalculation.request.CalculationTypeEnum.*;
import static com.ots.project.tool.report.reportCalculation.request.ReportTypeEnum.firstPath;
import static com.ots.project.tool.report.reportCalculation.request.ReportTypeEnum.secondPath;

@Service("examPaper")
@Slf4j
public class TExamPaperServiceImpl implements ITExamPaperService {
    @Autowired
    private TExamPaperMapper tExamPaperMapper;
    @Autowired
    private TTextContentMapper tTextContentMapper;
    @Autowired
    private TExamLevelMapper tExamLevelMapper;
    @Autowired
    private TQuestionMapper questionMapper;
    @Autowired
    private ITQuestionService tQuestionService;
    @Autowired
    private IDictDataService dictDataService;
    @Autowired
    private DictService dictService;
    @Autowired
    private ITTextContentService tTextContentService;
    @Autowired
    private TExamPaperQuestionMapper tExamPaperQuestionMapper;
    @Autowired
    private ITExamPaperService tExamPaperService;
    @Autowired
    private ISysUserPaperService userPaperService;
    @Autowired
    private IExamUtilService examUtilService;
    protected final static ModelMapper modelMapper = ModelMapperSingle.Instance();
    @Autowired
    private ITReportTemplateService itReportTemplateService;
    @Autowired
    private ITExamReportService examReportService;
    @Autowired
    private EntTestMemberMapper entTestMemberMapper;
    @Autowired
    EmailMessage emailMessage;
    @Autowired
    ReportCalculationServices calculationServices;
    private static final Logger logger = LoggerFactory.getLogger(Threads.class);
    
    @Override
    public TExamPaper selectTExamPaperById(Long id) {
        return tExamPaperMapper.selectTExamPaperById(id);
    }
    
    @Override
    public List<TExamPaper> selectTExamPaperList(TExamPaper tExamPaper) {
        List<TExamPaper> tExamPaperList = tExamPaperMapper.selectTExamPaperList(tExamPaper);
        List<TExamPaper> tExamPaperResultList = new ArrayList<>();
        
        for (TExamPaper tExamPaperTemp : tExamPaperList) {
            Map<String, String> nameMap = JsonUtil.toJsonObject(tExamPaperTemp.getName(), HashMap.class);
            if (Objects.isNull(nameMap)) {
                TExamPaper tExamPaperResult = new TExamPaper();
                BeanUtils.copyProperties(tExamPaperTemp, tExamPaperResult);
                tExamPaperResult.setLangType(tExamPaper.getLangType());
                tExamPaperResultList.add(tExamPaperResult);
            } else {
                nameMap.forEach((key, value) -> {
                    TExamPaper tExamPaperResult = new TExamPaper();
                    BeanUtils.copyProperties(tExamPaperTemp, tExamPaperResult);
                    tExamPaperResult.setLangType(key);
                    tExamPaperResult.setName(value);
                    if (nameMap.size() == 1) {
                        tExamPaperResultList.add(tExamPaperResult);
                    } else if (Objects.nonNull(tExamPaper.getUuid()) || (Objects.isNull(tExamPaper.getUuid()) && Objects.equals(dictService.getLangType(LocaleContextHolder.getLocale().toString()), key))) {
                        tExamPaperResultList.add(tExamPaperResult);
                    }
                });
            }
        }
        
        tExamPaperList.clear();
        tExamPaperList.addAll(tExamPaperResultList);
        return tExamPaperList;
    }
    
    @Override
    @Transactional
    public int insertTExamPaper(TExamPaper tExamPaper) {
        
        if (Objects.nonNull(tExamPaper.getVersionId())) {
            String maxVersion = tExamPaperMapper.selectEPaperMaxVBypermanentId(tExamPaper);
            if (StringUtils.isEmpty(maxVersion) && StringUtils.isNotEmpty(tExamPaper.getVersionId())) {
                int vNum = Integer.parseInt(tExamPaper.getVersion().substring(1)) + 1;
                tExamPaper.setVersion("V" + vNum);
            } else if (StringUtils.isNotEmpty(maxVersion)) {
                int vNum = Integer.parseInt(maxVersion.substring(1)) + 1;
                tExamPaper.setVersion("V" + vNum);
            } else {
                setVersion(tExamPaper);
            }
        } else {
            setVersion(tExamPaper);
        }
        
        tExamPaper.setLangType(examUtilService.getLocalLangType(tExamPaper.getLangType()));
        tExamPaper.setCreateTime(DateUtils.getNowDate());
        
        TTextContent textContent = new TTextContent();
        
        setInserPerperNameAndGuide(tExamPaper);
        
        setInsertPaperContent(tExamPaper, textContent);
        
        tTextContentMapper.insertTTextContent(textContent);
        tExamPaper.setFrameTextContentId(textContent.getId());
        
        
        setQuestionContentJson(tExamPaper);
        tExamPaperMapper.insertTExamPaper(tExamPaper);
        
        return setExamPaperQuestion(tExamPaper);
    }
    private void setVersion(TExamPaper tExamPaper) {
        tExamPaper.setVersionId(UUID.randomUUID().toString().replaceAll("-", ""));
        tExamPaper.setVersion("V1");
    }
    private void setInsertPaperContent(TExamPaper tExamPaper, TTextContent textContent) {
        
        if (StringUtils.isNotEmpty(tExamPaper.getMultilingual())) {
            String content = tExamPaper.getQuestions();
            content = setPartsContent(tExamPaper, content);
            textContent.setContent(content);
        } else {
            List<ExamPaperTitleItem> examPaperTitleItemList = JsonUtil.parseArray(tExamPaper.getQuestions(), ExamPaperTitleItem.class);
            for (ExamPaperTitleItem examPaperTitleItem : examPaperTitleItemList) {
                examPaperTitleItem.setName(examUtilService.getLangOrLocalLangString(tExamPaper.getLangType(), examPaperTitleItem.getName()));
                examPaperTitleItem.setDescription(examUtilService.getLangOrLocalLangString(tExamPaper.getLangType(), examPaperTitleItem.getDescription()));
                examPaperTitleItem.setGuide(examUtilService.getLangOrLocalLangString(tExamPaper.getLangType(), examPaperTitleItem.getGuide()));
                setPartLangsData(tExamPaper, examPaperTitleItem.getParts());
            }
            textContent.setContent(JsonUtil.toJSONString(examPaperTitleItemList));
        }
    }
    private String setPartsContent(TExamPaper tExamPaper, String content) {
        List<ExamPaperTitleItem> examPaperTitleItemList = JsonUtil.parseArray(content, ExamPaperTitleItem.class);
        List<QuestionPart> parts = examPaperTitleItemList.get(0).getParts();
        setPartLangsData(tExamPaper, parts);
        content = JsonUtil.toJSONString(examPaperTitleItemList);
        return content;
    }
    
    private void setPartLangsData(TExamPaper tExamPaper, List<QuestionPart> parts) {
        if (ExamUtil.isListNotEmpty(parts)) {
            for (QuestionPart questionPart : parts) {
                List<SignalObject> signals = questionPart.getSignals();
                signals.stream().forEach(signalObject -> {
                    signalObject.setSignalDescription(ExamUtil.getStringMapJson(tExamPaper.getLangType(), signalObject.getSignalDescription(), new HashMap<>()));
                });
            }
        }
    }
    private int setExamPaperQuestion(TExamPaper tExamPaper) {
        List<ExamPaperTitleItem> examPaperTitleItemList = JsonUtil.toJsonListObject(tExamPaper.getQuestions(), ExamPaperTitleItem.class);
        int size = examPaperTitleItemList.size();
        tExamPaperQuestionMapper.deleteTExamPaperQuestionById(tExamPaper.getId());
        for (ExamPaperTitleItem examPaperTitleItem : examPaperTitleItemList) {
            List<QuestionItem> questionItems = examPaperTitleItem.getQuestionItems();
            questionItems.stream().forEach(questionItem -> {
                TExamPaperQuestion tExamPaperQuestion = new TExamPaperQuestion();
                tExamPaperQuestion.setPaperId(tExamPaper.getId());
                tExamPaperQuestion.setQuestionId(questionItem.getId());
                tExamPaperQuestion.setPermanentId(size > 1 ? examPaperTitleItem.getPermanentId() : questionItem.getPermanentId());
                tExamPaperQuestionMapper.insertTExamPaperQuestion(tExamPaperQuestion);
            });
        }
        return 1;
    }
    private void setInserPerperNameAndGuide(TExamPaper tExamPaper) {
        
        
        Map<String, String> nameMap = new HashMap<>();
        Map<String, String> guideMap = new HashMap<>();
        if (StringUtils.isNotEmpty(tExamPaper.getMultilingual())) {
            
            setInserPerperBatch(tExamPaper, nameMap, guideMap);
            
            setProductNameAndGuide(tExamPaper, nameMap, guideMap);
        } else { 
            
            if (tExamPaper.isCreate() && Objects.nonNull(tExamPaper.getId())) {
                TExamPaper tExamPaperLast = tExamPaperMapper.selectTExamPaperById(tExamPaper.getId());
                String nameMapJson = ExamUtil.getStringMapJson(tExamPaper.getLangType(), tExamPaper.getName(), tExamPaperLast.getName());
                String guideMapJson = ExamUtil.getStringMapJson(tExamPaper.getLangType(), tExamPaper.getGuide(), tExamPaperLast.getGuide());
                nameMap = JsonUtil.toJsonObject(nameMapJson, HashMap.class);
                guideMap = JsonUtil.toJsonObject(guideMapJson, HashMap.class);
            } else if (Objects.equals(tExamPaper.getLangType(), "ALL")) {
                nameMap.put(dictService.getLangType(LocaleContextHolder.getLocale().toString()), tExamPaper.getName());
                guideMap.put(dictService.getLangType(LocaleContextHolder.getLocale().toString()), tExamPaper.getGuide());
            } else {
                nameMap.put(tExamPaper.getLangType(), tExamPaper.getName());
                guideMap.put(tExamPaper.getLangType(), tExamPaper.getGuide());
            }
            
            setProductNameAndGuide(tExamPaper, nameMap, guideMap);
        }
    }
    
    private void setInserPerperBatch(TExamPaper tExamPaper, Map<String, String> nameMap, Map<String, String> guideMap) {
        List<String> multilingualList = JsonUtil.toJsonListObject(tExamPaper.getMultilingual(), String.class);
        for (int i = 0; i < multilingualList.size(); i++) {
            
            if (StringUtils.equals(tExamPaper.getLangType(), "ALL") && !multilingualList.contains(dictService.getLangType(LocaleContextHolder.getLocale().toString()))) {
                nameMap.put(multilingualList.get(i), tExamPaper.getName());
                guideMap.put(multilingualList.get(i), tExamPaper.getGuide());
            } else if (!Objects.equals(dictService.getLangType(LocaleContextHolder.getLocale().toString()), multilingualList.get(i))) {
                nameMap.put(multilingualList.get(i), "");
                guideMap.put(multilingualList.get(i), "");
            } else {
                nameMap.put(multilingualList.get(i), tExamPaper.getName());
                guideMap.put(multilingualList.get(i), tExamPaper.getGuide());
            }
        }
    }
    
    private void setProductNameAndGuide(TExamPaper tExamPaper, Map<String, String> nameMap, Map<String, String> guideMap) {
        tExamPaper.setName(JsonUtil.toJsonStr(nameMap));
        tExamPaper.setGuide(JsonUtil.toJsonStr(guideMap));
    }
    
    private void setQuestionContentJson(TExamPaper tExamPaper) {
        String langType = tExamPaper.getLangType();
        tExamPaper.setLangType("");
        List<ExamPaperTitleItem> ExamPaperTitleItemList = getExamPaperTitleContent(tExamPaper);
        List<QuestionContent> questionContentList = new ArrayList<>();
        for (ExamPaperTitleItem examPaperTitleItem : ExamPaperTitleItemList) {
            List<QuestionItem> questionItemList = examPaperTitleItem.getQuestionItems();
            questionItemList.stream().forEach(questionItem -> {
                QuestionContent quesitonContent = new QuestionContent();
                quesitonContent.setPermanentId(questionItem.getPermanentId());
                quesitonContent.setQuestionTitle(questionItem.getTitle());
                questionContentList.add(quesitonContent);
            });
        }
        tExamPaper.setQuestionContent(JsonUtil.toJsonStr(questionContentList));
        tExamPaper.setLangType(langType);
    }
    private void SetExamPaperAttribute(TExamPaper tExamPaper) {
        
        List<ExamPaperTitleItemObject> examPaperTitleItemObjectList = JSONArray.parseArray(tExamPaper.getQuestions(), ExamPaperTitleItemObject.class);
        
        List<Integer> questionIds = examPaperTitleItemObjectList.stream().flatMap(t -> t.getQuestionItems().stream().map(q -> q.getId())).collect(Collectors.toList());
        Integer[] ids = questionIds.toArray(new Integer[questionIds.size()]);
        List<TQuestion> tQuestionList = questionMapper.selectTQuestionScore(ids);
        
        
        tExamPaper.setScore(0l);
        
        
        tExamPaper.setQuestionCount(Long.valueOf(questionIds.size()));
    }
    
    @Override
    @Transactional
    public int updateTExamPaper(TExamPaper tExamPaper) {
        
        if (StringUtils.isEmpty(tExamPaper.getVersion())) {
            setVersion(tExamPaper);
            updateTExamPaperVersion(tExamPaper);
        }
        if (tExamPaper.isCreate()) {
            insertTExamPaper(tExamPaper);
        }
        updateLangProduct(tExamPaper);
        return setExamPaperQuestion(tExamPaper);
    }
    
    public int updateTExamPaperVersion(TExamPaper tExamPaper) {
        return tExamPaperMapper.updateTExamPaperVersion(tExamPaper);
    }
    private int updateLangProduct(TExamPaper tExamPaper) {
        
        TExamPaper tExamPaperForUpdate = selectTExamPaperById(tExamPaper.getId());
        
        setExamPaperInfor(tExamPaper, tExamPaperForUpdate);
        
        TTextContent textContent = tTextContentMapper.selectTTextContentById(tExamPaperForUpdate.getFrameTextContentId());
        textContent.setContent(tExamPaper.getQuestions());
        textContent.setUpdateTime(DateUtils.getNowDate());
        tTextContentMapper.updateTTextContent(textContent);
        tExamPaperForUpdate.setUpdateTime(DateUtils.getNowDate());
        return tExamPaperMapper.updateTExamPaper(tExamPaperForUpdate);
    }
    private void setExamPaperInfor(TExamPaper tExamPaper, TExamPaper tExamPaperForUpdate) {
        tExamPaperForUpdate.setName(ExamUtil.getStringMapJson(tExamPaper.getLangType(), tExamPaper.getName(), tExamPaperForUpdate.getName()));
        
        tExamPaperForUpdate.setGuide(ExamUtil.getStringMapJson(tExamPaper.getLangType(), tExamPaper.getGuide(), tExamPaperForUpdate.getGuide()));
        tExamPaperForUpdate.setSuggestTime(tExamPaper.getSuggestTime());
        tExamPaperForUpdate.setReportTemplateId(tExamPaper.getReportTemplateId());
        
        setLangsPart(tExamPaper, tExamPaperForUpdate);
    }
    private void setLangsPart(TExamPaper tExamPaper, TExamPaper tExamPaperForUpdate) {
        try {
            List<ExamPaperTitleItem> examPaperTitleItemListNew = JsonUtil.parseArray(tExamPaper.getQuestions(), ExamPaperTitleItem.class);
            List<ExamPaperTitleItem> examPaperTitleItemListOld = JsonUtil.parseArray(tExamPaperForUpdate.getContent(), ExamPaperTitleItem.class);
            List<QuestionPart> partsNew = examPaperTitleItemListNew.get(0).getParts();
            List<QuestionPart> partsOld = examPaperTitleItemListOld.get(0).getParts();
            for (int i = 0; i < partsNew.size(); i++) {
                List<SignalObject> signalsNew = partsNew.get(i).getSignals();
                List<SignalObject> signalsOld = partsOld.get(i).getSignals();
                for (int j = 0; j < signalsNew.size(); j++) {
                    Map<String, String> signalDescriptionMap = JsonUtil.parseObject(signalsOld.get(j).getSignalDescription(), HashMap.class);
                    signalsNew.get(j).setSignalDescription(ExamUtil.getStringMapJson(tExamPaper.getLangType(), signalsNew.get(j).getSignalDescription(), signalDescriptionMap));
                }
            }
            tExamPaper.setQuestions(JsonUtil.toJSONString(examPaperTitleItemListNew));
        } catch (Exception e) {
        }
    }
    @Override
    public int deleteProductContent(TExamPaper tExamPaper) {
        
        TExamPaper tExamPaperForUpdate = selectTExamPaperById(tExamPaper.getId());
        tExamPaperForUpdate.setName(ExamUtil.deleteLangString(tExamPaper.getLangType(), tExamPaperForUpdate.getName()));
        
        tExamPaperForUpdate.setGuide(ExamUtil.deleteLangString(tExamPaper.getLangType(), tExamPaperForUpdate.getGuide()));
        
        TTextContent textContent = tTextContentMapper.selectTTextContentById(tExamPaperForUpdate.getFrameTextContentId());
        List<ExamPaperTitleItem> examPaperTitleItemUpdateList = JsonUtil.toJsonListObject(textContent.getContent(), ExamPaperTitleItem.class);
        int questionNum = 0;
        for (ExamPaperTitleItem examPaperTitleItem : examPaperTitleItemUpdateList) {
            
            examPaperTitleItem.setName(ExamUtil.deleteLangString(tExamPaper.getLangType(), examPaperTitleItem.getName()));
            examPaperTitleItem.setGuide(ExamUtil.deleteLangString(tExamPaper.getLangType(), examPaperTitleItem.getGuide()));
            examPaperTitleItem.setDescription(ExamUtil.deleteLangString(tExamPaper.getLangType(), examPaperTitleItem.getDescription()));
        }
        textContent.setContent(JsonUtil.toJsonStr(examPaperTitleItemUpdateList));
        textContent.setUpdateTime(DateUtils.getNowDate());
        
        deleteLangParts(tExamPaper, textContent);
        tTextContentMapper.updateTTextContent(textContent);
        tExamPaperForUpdate.setUpdateTime(DateUtils.getNowDate());
        return tExamPaperMapper.updateTExamPaper(tExamPaperForUpdate);
    }
    private void deleteLangParts(TExamPaper tExamPaper, TTextContent textContent) {
        try {
            List<ExamPaperTitleItem> examPaperTitleItemForPartList = JsonUtil.parseArray(textContent.getContent(), ExamPaperTitleItem.class);
            List<QuestionPart> parts = examPaperTitleItemForPartList.get(0).getParts();
            if (ExamUtil.isListNotEmpty(parts)) {
                for (QuestionPart questionPart : parts) {
                    questionPart.getSignals().stream().forEach(signalObject -> {
                        signalObject.setSignalDescription(ExamUtil.deleteLangString(tExamPaper.getLangType(), signalObject.getSignalDescription()));
                    });
                }
                textContent.setContent(JsonUtil.toJSONString(examPaperTitleItemForPartList));
            }
        } catch (Exception e) {
        }
    }
    
    @Override
    public int deleteTExamPaperByIds(String ids) {
        
        tExamPaperQuestionMapper.deleteTExamPaperQuestionByIds(Convert.toStrArray(ids));
        
        return tExamPaperMapper.updateByDelete(Convert.toStrArray(ids));
    }
    
    public int deleteTExamPaperById(Long id) {
        return tExamPaperMapper.deleteTExamPaperById(id);
    }
    @Override
    public List<TExamPaper> selectProdByDeleteList(List<Long> deletes) {
        Map map = new HashMap<>();
        map.put("deleteds", deletes);
        return tExamPaperMapper.selectProdByDeleteList(map);
    }
    
    public List<Ztree> selectProdTree(String testType) {
        List<Ztree> ztrees = new ArrayList<>();
        List<TExamPaper> dictList = getUserPapers();
        for (TExamPaper dict : dictList) {
            TExamPaper tExamPaper = tExamPaperMapper.selectTExamPaperById(dict.getId());
            if (Objects.isNull(tExamPaper)) {
                continue;
            }
            Long levelId = tExamPaper.getLevelId();
            TExamLevel tExamLevel = tExamLevelMapper.selectTExamLevelById(levelId);
            if (Objects.isNull(tExamLevel)) {
                continue;
            }
            String questionTemplateId = tExamLevel.getQuestionTemplateId();
            if (!Objects.equals(testType, questionTemplateId)) {
                if (Objects.equals("questionnaire",testType) && Objects.equals("job",questionTemplateId)) {
                } else {
                    continue;
                }
            }
            Ztree ztree = new Ztree();
            ztree.setId(dict.getId());
            ztree.setName(dict.getName());
            ztree.setTitle(String.valueOf(dict.getId()));
            ztrees.add(ztree);
        }
        return ztrees;
    }
    public List<TExamPaper> getUserPapers() {
        User sysUser = ShiroUtils.getSysUser();
        List<TExamPaper> dictList;
        if (Objects.equals(UserTypeEnum.SYS_USER.getUserType(), sysUser.getUserType())) {
            TExamPaper tExamPaper = new TExamPaper();
            dictList = tExamPaperService.selectTExamPaperList(tExamPaper);
        }
        else {
            SysUserPaper sysUserPaper = new SysUserPaper();
            sysUserPaper.setUserId(sysUser.getUserId());
            List<SysUserPaper> sysUserPapers = userPaperService.selectSysUserPaperList(sysUserPaper);
            dictList = sysUserPapers.stream().map(p -> {
                TExamPaper paper = new TExamPaper();
                paper.setName(p.getProdName());
                paper.setId(p.getProdId());
                return paper;
            }).collect(Collectors.toList());
        }
        
        dictList.stream().forEach(p -> {
            p.setName(ExamUtil.getStringByLang(p.getLangType(), p.getName()));
        });
        return dictList;
    }
    @Override
    public int updateDeleted(TExamPaper tExamPaper) {
        return tExamPaperMapper.updateTExamPaper(tExamPaper);
    }
    @Transactional
    @Override
    public List<TQuestion> updateInsertQuestion(List<TQuestion> questionList, String multilingual) {
        questionList.stream().forEach(question -> {
            
            question.setMultilingual(multilingual);
            tQuestionService.updateTQuestion(question);
        });
        return questionList;
    }
    
    @Override
    public List<DictData> getType(Long id) {
        
        List<DictData> dictDataList = dictDataService.selectDictDataByType("lang_type");
        
        if (Objects.nonNull(id)) {
            TExamPaper tExamPaper = selectTExamPaperById(id);
            Map<String, String> titleMap = JsonUtil.toJsonObject(tExamPaper.getName(), HashMap.class);
            if (Objects.isNull(titleMap)) {
                return dictDataList;
            }
            List<DictData> dictDataListResult = new ArrayList<>();
            for (DictData dictData : dictDataList) {
                if (StringUtils.isEmpty(titleMap.get(dictData.getDictValue()))) {
                    dictDataListResult.add(dictData);
                }
            }
            return dictDataListResult;
        } else {
            return dictDataList;
        }
    }
    @Override
    public void recallThaiInterface(TExamReport tExamReportResult, String reportType) {
        TExamReport tExamReportUpdate = new TExamReport();
        tExamReportUpdate.setId(tExamReportResult.getId());
        tExamReportUpdate.setTokenId(tExamReportResult.getTokenId());
        
        tExamReportResult.setInterfaceContent("");
        
        recallMaqAndSaqThaiInterface(tExamReportResult, reportType, tExamReportUpdate);
        recallCaqThaiInterface(tExamReportResult, reportType, tExamReportUpdate);
    }
    private void recallCaqThaiInterface(TExamReport tExamReportResult, String reportType, TExamReport tExamReportUpdate) {
        if (Objects.equals("CAQ", reportType)) {
            ExamPaperSubmitVM examPaperSubmitVM = new ExamPaperSubmitVM();
            
            examPaperSubmitVM.setRecallThaiInterface(true);
            
            examPaperSubmitVM.setSubmitClick(true);
            if (!recallThaiInterfaceForMAQAndCAQ(tExamReportResult, tExamReportUpdate, examPaperSubmitVM, 2)) {
                return;
            }
        }
    }
    private void recallMaqAndSaqThaiInterface(TExamReport tExamReportResult, String reportType, TExamReport tExamReportUpdate) {
        List<QuestionReport> questionReports = JsonUtil.parseArray(tExamReportResult.getQuestionReport(), QuestionReport.class);
        if (Objects.equals("MAQ", reportType) || Objects.equals("SAQ", reportType)) {
            Set<Integer> partOrderSet = questionReports.stream().map(QuestionReport::getPartOrder).collect(Collectors.toSet());
            partOrderSet.stream().sorted(Comparator.naturalOrder());
            for (Integer partOrder : partOrderSet) {
                ExamPaperSubmitVM examPaperSubmitVM = new ExamPaperSubmitVM();
                examPaperSubmitVM.setPartOrder(partOrder);
                
                examPaperSubmitVM.setRecallThaiInterface(true);
                if (!recallThaiInterfaceForMAQAndCAQ(tExamReportResult, tExamReportUpdate, examPaperSubmitVM, examPaperSubmitVM.getPartOrder())) {
                    return;
                }
            }
        }
    }
    private boolean recallThaiInterfaceForMAQAndCAQ(TExamReport tExamReportResult, TExamReport tExamReportUpdate, ExamPaperSubmitVM examPaperSubmitVM, Integer partOrder2) {
        ReportAPIResult reportAPIResult = getTaiInterface(examPaperSubmitVM, tExamReportResult, tExamReportUpdate);
        if (Objects.equals(reportAPIResult.getCode(), "fail")) {
            tExamReportUpdate.setRemark(tExamReportResult.getRemark() + ";" + reportAPIResult.getMessage());
            examReportService.updateTExamReportByTokenId(tExamReportUpdate);
            return false;
        }
        
        updateTaiInterfaceContent(tExamReportUpdate, tExamReportResult, reportAPIResult, partOrder2);
        tExamReportResult.setInterfaceContent(tExamReportUpdate.getInterfaceContent());
        return true;
    }
    @Override
    public List<ExamPaperTitleItem> getExamPaperTitleContent(TExamPaper tExamPaper) {
        
        if (Objects.isNull(tExamPaper.getFrameTextContentId())) {
            return null;
        }
        TTextContent tTextContent = tTextContentService.selectTTextContentById(tExamPaper.getFrameTextContentId());
        
        List<ExamPaperTitleItemObject> examPaperTitleItemObjectList = JSONArray.parseArray(tTextContent.getContent(), ExamPaperTitleItemObject.class);
        
        examUtilService.setTitleName(tExamPaper, examPaperTitleItemObjectList);
        
        List<ExamPaperTitleItem> examPaperTitleItemList = new ArrayList<>();
        
        setPaperQuestion(tExamPaper, examPaperTitleItemObjectList, examPaperTitleItemList);
        
        examPaperTitleItemList.get(0).setParts(examPaperTitleItemObjectList.get(0).getParts());
        
        getPartsmultiLanguage(tExamPaper, examPaperTitleItemList);
        return examPaperTitleItemList;
    }
    private void getPartsmultiLanguage(TExamPaper tExamPaper, List<ExamPaperTitleItem> examPaperTitleItemList) {
        List<QuestionPart> parts = examPaperTitleItemList.get(0).getParts();
        if (CollUtil.isEmpty(parts)) {
            return;
        }
        for (QuestionPart questionPart : parts) {
            List<SignalObject> signals = questionPart.getSignals();
            signals.stream().forEach(signalObject -> {
                signalObject.setSignalDescription(ExamUtil.getLangString(tExamPaper.getLangType(), signalObject.getSignalDescription()));
            });
        }
    }
    private void setPaperQuestion(TExamPaper tExamPaper, List<ExamPaperTitleItemObject> examPaperTitleItemObjectList, List<ExamPaperTitleItem> examPaperTitleItemList) {
        
        for (ExamPaperTitleItemObject examPaperTitleItemObject : examPaperTitleItemObjectList) {
            
            ExamPaperTitleItem examPaperTitleItem = new ExamPaperTitleItem();
            examPaperTitleItem.setName(ExamUtil.getLangString(tExamPaper.getLangType(), examPaperTitleItemObject.getName()));
            
            List<ExamPaperQuestionItemObject> examPaperQuestionList = examPaperTitleItemObject.getQuestionItems();
            
            Map<Integer, ExamPaperQuestionItemObject> questionOrder = new HashMap<>();
            List<String> ids = new ArrayList<String>();
            for (ExamPaperQuestionItemObject examPaperQuestionItemObject : examPaperQuestionList) {
                ids.add(examPaperQuestionItemObject.getId().toString());
                questionOrder.put(examPaperQuestionItemObject.getId(), examPaperQuestionItemObject);
            }
            if (ExamUtil.isListEmpty(ids)) {
                continue;
            }
            
            List<TTextContentAndQuestion> tTextContents = tTextContentService.selectTextContentAndQuestion(ids.toArray(new String[ids.size()]));
            List<QuestionItem> questionItemList = tTextContents.stream().map(i -> {
                QuestionItem questionItem = new QuestionItem();
                
                QuestionObject questionObject = JSONObject.parseObject(i.getContent(), QuestionObject.class);
                
                questionItem.setTitle(ExamUtil.getLangString(tExamPaper.getLangType(), questionObject.getTitleContent()));
                questionItem.setId(i.getId().intValue());
                questionItem.setQuestionId(i.getQuestionId().intValue());
                questionItem.setItemOrder(questionOrder.get(i.getQuestionId().intValue()).getItemOrder());
                questionItem.setPermanentId(i.getPermanentId());
                questionItem.setPartOrder(questionOrder.get(i.getQuestionId().intValue()).getPartOrder());
                
                
                if (Objects.nonNull(questionObject.getQuestionItemObjects())) {
                    List<QuestionEditItem> items = questionObject.getQuestionItemObjects().stream().map(val -> {
                        QuestionEditItem questionEditItem = modelMapper.map(val, QuestionEditItem.class);
                        questionEditItem.setContent(ExamUtil.getLangString(tExamPaper.getLangType(), questionEditItem.getContent()));
                        return questionEditItem;
                    }).collect(Collectors.toList());
                    questionItem.setItems(items);
                } else {
                    List<QuestionEditItem> items = new ArrayList<>();
                    QuestionEditItem questionEditItem = new QuestionEditItem();
                    questionEditItem.setPrefix("1");
                    questionEditItem.setContent("1");
                    questionEditItem.setScore(0);
                    items.add(questionEditItem);
                    questionItem.setItems(items);
                }
                
                return questionItem;
            }).collect(Collectors.toList());
            
            
            examPaperTitleItem.setQuestionItems(questionItemList);
            examPaperTitleItem.setDescription(ExamUtil.getLangString(tExamPaper.getLangType(), examPaperTitleItemObject.getDescription()));
            examPaperTitleItem.setGuide(ExamUtil.getLangString(tExamPaper.getLangType(), examPaperTitleItemObject.getGuide()));
            examPaperTitleItem.setPermanentId(examPaperTitleItemObject.getPermanentId());
            examPaperTitleItem.setQuestionId(examPaperTitleItemObject.getQuestionId());
            examPaperTitleItemList.add(examPaperTitleItem);
        }
    }
    public RestResponse<SignalObject> getSignalObjectRestResponse(ExamPaperSubmitVM examPaperSubmitVM, TExamReport tExamReport, List<TExamReport> tExamReportList, String langType) {
        
        TExamReport tExamReportResult = tExamReportList.get(0);
        
        ReportAPIResult reportAPIResult = getTaiInterface(examPaperSubmitVM, tExamReportResult, tExamReport);
        
        updateTaiInterfaceContent(tExamReport, tExamReportResult, reportAPIResult, examPaperSubmitVM.getPartOrder());
        
        sendHRAndMemberEmail(tExamReport, true, true);
        
        return getSignalObject(examPaperSubmitVM.getPartOrder(), tExamReportResult, reportAPIResult, langType);
    }
    private RestResponse<SignalObject> getSignalObject(int partOrder, TExamReport tExamReportResult, ReportAPIResult reportAPIResult, String langType) {
        TExamPaper tExamPaper = selectTExamPaperById(tExamReportResult.getProductId());
        List<ExamPaperTitleItem> examPaperTitleItemList = JsonUtil.parseArray(tExamPaper.getContent(), ExamPaperTitleItem.class);
        List<QuestionPart> parts = examPaperTitleItemList.get(0).getParts();
        QuestionPart questionPart = parts.get(partOrder - 1);
        List<SignalObject> signals = questionPart.getSignals();
        for (SignalObject signalObject : signals) {
            if (Objects.equals(reportAPIResult.getSignal(), signalObject.getSignal())) {
                signalObject.setSignalDescription(ExamUtil.getLangString(langType, signalObject.getSignalDescription()));
                String name = examReportService.getDemographicName(tExamReportResult);
                signalObject.setSignalDescription(signalObject.getSignalDescription().replaceAll("%%fullName%%", StringUtils.isNotEmpty(name) ? name : tExamReportResult.getMemberName()));
                signalObject.setCode(reportAPIResult.getCode());
                signalObject.setMessage(reportAPIResult.getMessage());
                return RestResponse.ok(signalObject);
            }
        }
        SignalObject signalObject = new SignalObject();
        signalObject.setCode(reportAPIResult.getCode());
        signalObject.setMessage(reportAPIResult.getMessage());
        return RestResponse.ok(signalObject);
    }
    
    public void sendHRAndMemberEmail(TExamReport tExamReport, boolean justHr, boolean justMember) {
        
        List<String> fileNameResult = new ArrayList<>();
        
        List<String> deleteStrList = new ArrayList<>();
        TExamReport tExamReportResult = examReportService.getReportFromTemplate(tExamReport, fileNameResult, deleteStrList);
        if (tExamReportResult == null) {
            return;
        }
        
        String title = tExamReportResult.getMemberName() + MessageUtils.message("jsp.exam.quesiton.reportTilte");
        String content = tExamReportResult.getMailContent();
        StringBuilder remark = new StringBuilder();
        remark.append("失败邮箱：");
        if (justMember) {
            
            sendMemberEmail(tExamReport, fileNameResult, tExamReportResult, title, content, remark);
        }
        if (justHr) {
            
            sendHrEmail(tExamReport, fileNameResult, tExamReportResult, title, content, remark);
        }
        
        tExamReport.setReportAddress(JsonUtil.toJSONString(fileNameResult));
        
        tExamReport.setReportAddressNew(JsonUtil.toJSONString(fileNameResult));
        examReportService.updateTExamReportByTokenId(tExamReport);
        
        
        WordUtil wordUtil = new WordUtil();
        wordUtil.deleteFileByStr(deleteStrList);
    }
    public void sendHrEmail(TExamReport tExamReport, List<String> fileNameResult, TExamReport tExamReportResult, String title, String content, StringBuilder remark) {
        
        List<String> hrEmailList = null;
        try {
            hrEmailList = Arrays.asList(tExamReportResult.getTestEmail().split(","));
        } catch (Exception ex) {
        }
        if (ExamUtil.isListEmpty(hrEmailList)) {
            try {
                hrEmailList = Arrays.asList(tExamReportResult.getHrEmail().split(","));
            } catch (Exception ex) {
            }
        }
        if (Objects.isNull(hrEmailList)) {
            throw new RuntimeException("Hr Email Is Not Configured");
        }
        
        String userName = ExamUtil.getLangString(tExamReportResult.getLangType(), tExamReportResult.getUserName());
        
        String fullName = ExamUtil.getLangString(tExamReportResult.getLangType(), tExamReportResult.getMemberName());
        String productName = ExamUtil.getLangString(tExamReportResult.getLangType(), tExamReportResult.getProductName());
        if (StringUtils.isEmpty(content)) {
            content = loadReportHrDefaultTemplate(fullName, userName, productName);
        }
        content = content.replace("{Company}", StringUtils.isNotEmpty(userName) ? userName : "");
        content = content.replace("{fullName}", StringUtils.isNotEmpty(fullName) ? fullName : "");
        content = content.replace("{prodName}", StringUtils.isNotEmpty(productName) ? productName : "");
        for (String email : hrEmailList) {
            String hrEmailStatus = "1";
            RushMailResult rushMailResult = emailMessage.sendEmailwithAttachment(email, title, content, fileNameResult.stream().toArray(String[]::new));
            if (rushMailResult.isResult()) {
                tExamReport.setSendHrStatus(SenderCode.success.getCode());
            } else { 
                remark.append(tExamReportResult.getMemberEmail() + ",");
                tExamReport.setSendHrStatus(SenderCode.fail.getCode());
                hrEmailStatus = "2";
            }
            tExamReport.setHrReportEmail(email);
            tExamReport.setHrTitle(title);
            tExamReport.setHrSendTime(new Date());
            tExamReport.setHrUpdateTime(new Date());
            try {
                
                EntTestMember entTestMember = entTestMemberMapper.selectEntTestMemberById(Long.valueOf(tExamReportResult.getMemberId()));
                entTestMember.setHrEmailStatus(hrEmailStatus);
                entTestMember.setHrEmailTime(new Date());
                entTestMemberMapper.updateEntTestMember(entTestMember);
            } catch (Exception ex) {
                log.error("update HrEmailStatus error:{}", ex.getMessage(), ex);
            }
        }
        tExamReport.setRemark(remark.toString());
    }
    private String loadReportHrDefaultTemplate(String fullName, String userName, String productName) {
        StringBuilder builder = new StringBuilder();
        builder.append("亲爱的{Company}人力资源部，").append("<br>");
        builder.append("Dear HR Staff at {Company},").append("<br><br>");
        builder.append("附件是{fullName}最近完成的{prodName}测评报告。").append("<br>");
        builder.append("Attached please find the assessment report on ({prodName}) of ({fullName}).").append("<br><br>");
        builder.append("如有疑问，请与客服联系，邮箱是：support@tai-online.com。").append("<br>");
        builder.append("Should you have questions, please contact our customer service at support@tai-online.com. ").append("<br><br><br>");
        builder.append("谢谢！").append("<br>");
        builder.append("All the best,").append("<br><br><br>");
        builder.append("TAI公司客户服务部").append("<br>");
        builder.append("Customer Service Dept., TAI, LLC").append("<br><br><br>");
        return builder.toString();
    }
    private String loadReportMemberDefaultTemplate(String fullName, String userName, String productName) {
        StringBuilder builder = new StringBuilder();
        builder.append("Subject Line: Your assessment report is attached (您的测评报告附上了)");
        builder.append("<br><br>");
        builder.append("Dear " + fullName + ",");
        builder.append("<br><br>");
        builder.append(userName + " has recently asked you to complete an assessment (" + productName + ").  Attached please find your assessment report. ");
        builder.append("<br><br>");
        builder.append("Should you have questions, please contact our customer service at support@tai-online.com. ");
        builder.append("<br><br>");
        builder.append("All the best,");
        builder.append("<br><br>");
        builder.append(userName);
        builder.append("<br><br><br>");
        builder.append("亲爱的" + fullName + "，");
        builder.append("<br><br>");
        builder.append("最近" + userName + " 邀请您完成了一份测试 (" + productName + ")。现将您的测试报告发给您。");
        builder.append("<br><br>");
        builder.append("如有疑问，请与客服联系，邮箱是：support@tai-online.com。");
        builder.append("<br><br>");
        builder.append("谢谢！");
        builder.append("<br><br>");
        builder.append(userName);
        return builder.toString();
    }
    private void sendMemberEmail(TExamReport tExamReport, List<String> fileNameResult, TExamReport tExamReportResult, String title, String content, StringBuilder remark) {
        if (StringUtils.isEmpty(content)) {
            
            String userName = tExamReportResult.getUserName();
            
            String fullName = tExamReportResult.getMemberName();
            String productName = ExamUtil.getLangString(tExamReportResult.getLangType(), tExamReportResult.getProductName());
            content = loadReportMemberDefaultTemplate(fullName, userName, productName);
        }
        if (Objects.nonNull(tExamReportResult.getAutoSendReport()) && tExamReportResult.getAutoSendReport() == 1) {
            boolean result = emailMessage.sendEmailwithAttachment(tExamReportResult.getMemberEmail(), title, content, fileNameResult.stream().toArray(String[]::new)).isResult();
            if (result) {
                tExamReport.setSendTesterStatus(SenderCode.success.getCode());
            } else { 
                remark.append(tExamReportResult.getMemberEmail() + ",");
                tExamReport.setSendTesterStatus(SenderCode.fail.getCode());
            }
        } else {
            tExamReport.setSendTesterStatus(SenderCode.noSend.getCode());
        }
        tExamReport.setRemark(remark.toString());
    }
    private void updateTaiInterfaceContent(TExamReport tExamReportUpdate, TExamReport tExamReportResult, ReportAPIResult reportAPIResult, int partOrder) {
        List<ReportAPIResult> reportAPIResultList = JsonUtil.parseArray(tExamReportResult.getInterfaceContent(), ReportAPIResult.class);
        if (CollUtil.isNotEmpty(reportAPIResultList)) {
            ReportAPIResult reportAPIResultLast = reportAPIResultList.get(reportAPIResultList.size() - 1);
            if (Objects.equals(reportAPIResultLast.getCode(), "fail")) {
                reportAPIResultList.remove(reportAPIResultList.size() - 1);
            }
        }
        if (ExamUtil.isListEmpty(reportAPIResultList)) {
            reportAPIResultList = new ArrayList<>();
        } else {
            int size = reportAPIResultList.size();
            int deletNum = size - (partOrder - 1);
            
            for (int i = size - 1; i >= 0 && deletNum > 0; i--, deletNum--) {
                reportAPIResultList.remove(i);
            }
            logger.info("reportAPIResultList:的个数" + reportAPIResultList.size());
        }
        reportAPIResultList.add(reportAPIResult);
        tExamReportUpdate.setInterfaceContent(JsonUtil.toJSONString(reportAPIResultList));
        examReportService.updateTExamReportByTokenId(tExamReportUpdate);
    }
    private ReportAPIResult getTaiInterface(ExamPaperSubmitVM examPaperSubmitVM, TExamReport tExamReportResult, TExamReport tExamReportUpdate) {
        Map<Integer, ReportTypeEnum> reportTypeEnumMap = new HashMap<>();
        reportTypeEnumMap.put(1, firstPath);
        reportTypeEnumMap.put(2, secondPath);
        List<TReportTemplate> tReportTemplateList = itReportTemplateService.selectTReportTemplates(tExamReportResult.getReportTemplateId());
        CalculationTypeEnum calculationTypeEnum = MAQ;
        for (TReportTemplate tReportTemplate : tReportTemplateList) {
            if ("SAQ".equals(tReportTemplate.getTemplateType()) || Objects.equals("SAQ", tReportTemplate.getReportType())) {
                calculationTypeEnum = SAQ;
            }
            if ("RuiLin".equals(tReportTemplate.getReportType())) {
                calculationTypeEnum = RUILIN;
            }
            if ("CAQ".equals(tReportTemplate.getReportType())) {
                calculationTypeEnum = CAQ;
            }
        }
        HolderInfo info = new HolderInfo();
        info.setAccessCode(tExamReportResult.getTokenId());
        info.setFullName(tExamReportResult.getMemberName());
        info.setCalculationType(calculationTypeEnum);
        if (calculationTypeEnum == CAQ) {
            return getReportAPICAQResult(examPaperSubmitVM, tExamReportResult, tExamReportUpdate, info);
        } else if (calculationTypeEnum == SAQ) {
            return getReportAPISAQResult(examPaperSubmitVM, tExamReportResult, tExamReportUpdate, reportTypeEnumMap, info);
        } else {
            return getReportAPIMAQResult(examPaperSubmitVM, tExamReportResult, tExamReportUpdate, reportTypeEnumMap, info);
        }
    }
    private ReportAPIResult getReportAPICAQResult(ExamPaperSubmitVM examPaperSubmitVM, TExamReport tExamReportResult, TExamReport tExamReport, HolderInfo info) {
        Map data = new HashMap();
        
        
        getWaitTaiData(examPaperSubmitVM, tExamReportResult, data);
        CaqRequest request = new CaqRequest();
        request.setInfo(info);
        request.setData(data);
        ReportAPIResult reportAPIResult = calculationServices.stageCalculation(request);
        reportAPIResult.setAnswerData(data);
        if (Objects.equals(reportAPIResult.getCode(), "fail") && !examPaperSubmitVM.isRecallThaiInterface()) {
            updateChoice(examPaperSubmitVM, tExamReport, tExamReportResult);
        }
        return reportAPIResult;
    }
    public SignalObject callTaiData(String tokenId, String langType, ExamPaperSubmitVM examPaperSubmitVM) {
        
        TExamReport tExamReport = new TExamReport();
        tExamReport.setTokenId(tokenId);
        List<TExamReport> tExamReportList = examReportService.selectTExamReportList(tExamReport);
        TExamReport tExamReportOldResult = tExamReportList.get(0);
        if (ExamUtil.isListEmpty(tExamReportList)) {
            return getEmptySignalObjectResult();
        }
        List<QuestionReport> questionReportList = JsonUtil.toJsonListObject(tExamReportOldResult.getQuestionReport(), QuestionReport.class);
        if (ExamUtil.isListEmpty(questionReportList)) {
            return getEmptySignalObjectResult();
        }
        try {
            
            RestResponse<SignalObject> signalObject = getSignalObjectRestResponse(examPaperSubmitVM, tExamReport, tExamReportList, langType);
            if (Objects.nonNull(signalObject)) {
                return signalObject.getResponse();
            }
        } catch (Exception e) {
            updateChoice(examPaperSubmitVM, tExamReport, tExamReportOldResult);
            throw e;
        }
        return getEmptySignalObjectResult();
    }
    private SignalObject getEmptySignalObjectResult() {
        SignalObject signalObject = new SignalObject();
        signalObject.setSignalDescription("");
        return signalObject;
    }
    private void updateChoice(ExamPaperSubmitVM examPaperSubmitVM, TExamReport tExamReport, TExamReport tExamReportOldResult) {
        tExamReport.setFinish(0);
        if (StringUtils.isEmpty(tExamReport.getTokenId()) || StringUtils.isEmpty(examPaperSubmitVM.getItemOrder())) {
            examReportService.updateTExamReportByTokenId(tExamReport);
            return;
        }
        String choice = tExamReportOldResult.getChoice();
        LinkedHashMap<String, String> linkedHashMap = JsonUtil.parseObject(choice, LinkedHashMap.class);
        Iterator<String> iterator = linkedHashMap.keySet().iterator();
        String lastKeyElement = null;
        while (iterator.hasNext()) {
            lastKeyElement = iterator.next();
        }
        if (StringUtils.isEmpty(lastKeyElement)) {
            return;
        }
        linkedHashMap.remove(lastKeyElement);
        tExamReport.setChoice(JsonUtil.toJSONString(linkedHashMap));
        tExamReport.setRemark(tExamReport.getRemark() + ",itemOrder:" + examPaperSubmitVM.getItemOrder());
        examReportService.updateTExamReportByTokenId(tExamReport);
    }
    
    private void createMAQAndCAQData(ExamPaperSubmitVM examPaperSubmitVM, CalculationTypeEnum calculationTypeEnum, Map data) {
        if (calculationTypeEnum == CAQ) {
            
            simulationCAQTaiData(examPaperSubmitVM.getPartOrder(), data);
        } else {
            
            simulationTaiData(examPaperSubmitVM.getPartOrder(), data);
        }
    }
    
    private void simulationTaiData(int partOrder, Map data) {
        String topics = "MAQ0001,MAQ0003,MAQ0006,MAQ0009,MAQ0013,MAQ0020,MAQ0041,MAQ0048,MAQ0088,MAQ0094,MAQ0098,MAQ0112,MAQ0117,MAQ0133,MAQ0145,MAQ0163,MAQ0172,MAQ0174,MAQ0175,MAQ0183,MAQ0194,MAQ0203,MAQ0209,MAQ0212,MAQ0224,MAQ0232,MAQ0233,MAQ0235,MAQ0236,MAQ0241,MAQ0244,MAQ0249,MAQ0250,MAQ0251,MAQ0004,MAQ0005,MAQ0007,MAQ0010,MAQ0011,MAQ0014,MAQ0015,MAQ0019,MAQ0021,MAQ0024,MAQ0025,MAQ0026,MAQ0027,MAQ0028,MAQ0029,MAQ0030,MAQ0034,MAQ0035,MAQ0036,MAQ0038,MAQ0039,MAQ0040,MAQ0042,MAQ0044,MAQ0045,MAQ0046,MAQ0047,MAQ0049,MAQ0051,MAQ0053,MAQ0055,MAQ0058,MAQ0059,MAQ0060,MAQ0061,MAQ0062,MAQ0064,MAQ0065,MAQ0067,MAQ0069,MAQ0070,MAQ0071,MAQ0072,MAQ0073,MAQ0074,MAQ0076,MAQ0077,MAQ0078,MAQ0079,MAQ0080,MAQ0081,MAQ0082,MAQ0084,MAQ0085,MAQ0086,MAQ0087,MAQ0089,MAQ0090,MAQ0091,MAQ0092,MAQ0095,MAQ0097,MAQ0099,MAQ0100,MAQ0101,MAQ0103,MAQ0104,MAQ0106,MAQ0107,MAQ0110,MAQ0111,MAQ0113,MAQ0115,MAQ0118,MAQ0119,MAQ0120,MAQ0124,MAQ0126,MAQ0127,MAQ0129,MAQ0130,MAQ0131,MAQ0132,MAQ0134,MAQ0135,MAQ0136,MAQ0138,MAQ0140,MAQ0141,MAQ0142,MAQ0143,MAQ0144,MAQ0146,MAQ0147,MAQ0149,MAQ0150,MAQ0151,MAQ0152,MAQ0156,MAQ0157,MAQ0158,MAQ0159,MAQ0160,MAQ0161,MAQ0162,MAQ0164,MAQ0165,MAQ0166,MAQ0167,MAQ0168,MAQ0169,MAQ0170,MAQ0171,MAQ0173,MAQ0176,MAQ0178,MAQ0179,MAQ0180,MAQ0181,MAQ0182,MAQ0184,MAQ0185,MAQ0187,MAQ0190,MAQ0191,MAQ0192,MAQ0193,MAQ0195,MAQ0197,MAQ0199,MAQ0200,MAQ0201,MAQ0202,MAQ0204,MAQ0205,MAQ0206,MAQ0207,MAQ0208,MAQ0210,MAQ0211,MAQ0213,MAQ0214,MAQ0216,MAQ0218,MAQ0219,MAQ0220,MAQ0221,MAQ0223,MAQ0225,MAQ0226,MAQ0227,MAQ0228,MAQ0229,MAQ0230,MAQ0231,MAQ0234,MAQ0237,MAQ0240,MAQ0242,MAQ0243,MAQ0245,MAQ0247,MAQ0248,MAQ0253,MAQ0254,MAQ0255";
        if (partOrder == 1) {
            topics = "MAQ0001,MAQ0002,MAQ0003,MAQ0006,MAQ0009,MAQ0013,MAQ0020,MAQ0041,MAQ0048,MAQ0088,MAQ0094,MAQ0098,MAQ0112,MAQ0117,MAQ0133,MAQ0145,MAQ0163,MAQ0172,MAQ0174,MAQ0175,MAQ0183,MAQ0194,MAQ0203,MAQ0209,MAQ0212,MAQ0224,MAQ0232,MAQ0233,MAQ0235,MAQ0236,MAQ0241,MAQ0244,MAQ0249,MAQ0250,MAQ0251,MAQ0252";
        }
        String[] split = topics.split(",");
        Arrays.asList(split).stream().forEach(item -> {
            data.put(item, "5");
        });
    }
    
    private void simulationCAQTaiData(int partOrder, Map data) {
        String topics = "CAQ1010,CAQ1020,CAQ1030,CAQ1040,CAQ1050,CAQ1060,CAQ1070,CAQ1080,CAQ1090,CAQ1100,CAQ1110,CAQ1120,CAQ1130,CAQ1140,CAQ1150,CAQ2010,CAQ2020,CAQ2030,CAQ2040,CAQ2050,CAQ2060,CAQ2070,CAQ2080,CAQ2090,CAQ2100,CAQ2110,CAQ2120,CAQ2130,CAQ2140,CAQ2150,CAQ2160,CAQ2170,CAQ2180,CAQ2190,CAQ2200";
        if (partOrder == 1) {
            topics = "CAQ1010,CAQ1020,CAQ1030,CAQ1040,CAQ1050,CAQ1060,CAQ1070,CAQ1080,CAQ1090,CAQ1100,CAQ1110,CAQ1120,CAQ1130,CAQ1140,CAQ1150,CAQ2010,CAQ2020,CAQ2030,CAQ2040,CAQ2050,CAQ2060,CAQ2070,CAQ2080,CAQ2090,CAQ2100,CAQ2110,CAQ2120,CAQ2130,CAQ2140,CAQ2150,CAQ2160,CAQ2170,CAQ2180,CAQ2190,CAQ2200";
        }
        String[] split = topics.split(",");
        Arrays.asList(split).stream().forEach(item -> {
            data.put(item, "5");
        });
    }
    private void setNormalSubmit(ExamPaperSubmitVM examPaperSubmitVM, Map data, List<QuestionReport> questionReportList) {
        for (QuestionReport questionReport : questionReportList) {
            
            if (questionReport.getPartOrder() > examPaperSubmitVM.getPartOrder() || Objects.isNull(questionReport.getPermanentId()) || Objects.equals(questionReport.getPermanentId(), "0")) {
                continue;
            }
            data.put(questionReport.getPermanentId(), questionReport.getAnswer());
        }
    }
    private void setManSubmit(Map data, List<QuestionReport> questionReportList) {
        for (QuestionReport questionReport : questionReportList) {
            
            if (StringUtils.isNotEmpty(questionReport.getPermanentId()) && !Objects.equals(questionReport.getPermanentId(), "0")) {
                data.put(questionReport.getPermanentId(), questionReport.getAnswer());
            }
        }
    }
    private ReportAPIResult getReportAPISAQResult(ExamPaperSubmitVM examPaperSubmitVM, TExamReport tExamReportResult, TExamReport tExamReport, Map<Integer, ReportTypeEnum> reportTypeEnumMap, HolderInfo info) {
        return getReportAPIMAQResult(examPaperSubmitVM, tExamReportResult, tExamReport, reportTypeEnumMap, info);
    }
    private ReportAPIResult getReportAPIMAQResult(ExamPaperSubmitVM examPaperSubmitVM, TExamReport tExamReportResult, TExamReport tExamReport, Map<Integer, ReportTypeEnum> reportTypeEnumMap, HolderInfo info) {
        Map data = new HashMap();
        

        getWaitTaiData(examPaperSubmitVM, tExamReportResult, data);
        MaqRequest request = new MaqRequest();
        request.setInfo(info);
        request.setType(reportTypeEnumMap.get(examPaperSubmitVM.getPartOrder()));
        request.setData(data);
        ReportAPIResult reportAPIResult = calculationServices.stageCalculation(request);
        reportAPIResult.setAnswerData(data);
        
        if (Objects.equals(reportAPIResult.getCode(), "fail") && !examPaperSubmitVM.isRecallThaiInterface()) {
            updateChoice(examPaperSubmitVM, tExamReport, tExamReportResult);
        }
        return reportAPIResult;
    }
    private void getWaitTaiData(ExamPaperSubmitVM examPaperSubmitVM, TExamReport tExamReportResult, Map data) {
        List<QuestionReport> questionReportList = JsonUtil.parseArray(tExamReportResult.getQuestionReport(), QuestionReport.class);
        if (examPaperSubmitVM.isSubmitClick()) {
            
            setManSubmit(data, questionReportList);
        } else {
            setNormalSubmit(examPaperSubmitVM, data, questionReportList);
        }
    }
}