package com.rf.psychological.scale.resultBusiness.scaleResult;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.rf.psychological.dao.dto.scale.NewResultDto;
import com.rf.psychological.dao.model.AnswerEntity;
import com.rf.psychological.dao.model.DimensionEntity;
import com.rf.psychological.scale.dao.model.ScaleEntity;
import com.rf.psychological.scale.dao.model.ScaleMarksEntity;
import com.rf.psychological.scale.scaleresult.ScaleConstant;

import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @author zsy
 * @description:职业性格测试
 * @date 2021/7/20 15:55
 */
public class MBTIScale extends BaseScale {

    public MBTIScale(JSONArray jsonArray, JSONObject resultJson) {
        super(jsonArray, resultJson);
    }

    public JSONObject scaleCalculate() throws Exception {

        //总分
        double score = 0;
        Map<String, String> resultMap0 = new LinkedHashMap<>();
        List<Map<String, String>> resultMapList = new ArrayList<>();

        //获取答案列表
        List<AnswerEntity> answerEntities = (List<AnswerEntity>) resultJson.get("answerEntities");
        //获取题目和答案列表
        List<ScaleEntity> scaleEntities = (List<ScaleEntity>) resultJson.get("scaleEntities");
        //获取评分规则列表
        List<ScaleMarksEntity> scaleMarksEntities = (List<ScaleMarksEntity>) resultJson.get("scaleMarksEntities");
        //获取维度信息列表
        List<DimensionEntity> dimensionEntities = (List<DimensionEntity>) resultJson.get("dimensionEntities");
        Map<String,Double> dimensionScoreMap = new HashMap<>();
        if (dimensionEntities.size() > 0) {
            //计算每个维度得分
            double[] dimensionScore = new double[dimensionEntities.size()];
            for (int i = 0; i < jsonArray.size(); i++) {
                JSONObject jsonObject1 = jsonArray.getJSONObject(i);
                for (int y = 0; y < dimensionEntities.size(); y++) {
                    //for (DimensionEntity dimensionEntity:dimensionEntities){
                    DimensionEntity dimensionEntity = dimensionEntities.get(y);
                    String questionNos = dimensionEntity.getQuestionNo();
                    String[] questionNo = questionNos.split("；");
                    for (String question : questionNo) {
                        if (question.equals(jsonObject1.getString("questionNo"))) {
                            for (AnswerEntity answerEntity : answerEntities) {
                                if (answerEntity.getQuestionNo().equals(question) && answerEntity.getName().equals(jsonObject1.getString("checkItems"))) {
                                    String checkItems = scaleEntities.get(Integer.parseInt(answerEntity.getQuestionNo()) - 1).getCheckItems();
                                    String[] CheckIteml = checkItems.split("；");
                                    if ((y & 1) == 1) {
                                        if (CheckIteml[0].equals(jsonObject1.getString("checkItems"))) {
                                            dimensionScore[y] += Double.parseDouble(answerEntity.getScore());
                                        } else {
                                            dimensionScore[y - 1] += Double.parseDouble(answerEntity.getScore());
                                        }
                                    } else {
                                        if (CheckIteml[0].equals(jsonObject1.getString("checkItems"))) {
                                            dimensionScore[y] += Double.parseDouble(answerEntity.getScore());
                                        } else {
                                            dimensionScore[y + 1] += Double.parseDouble(answerEntity.getScore());
                                        }
                                    }
                                }
                            }
                            break;
                        }
                    }
                }
            }

            /*score = dimensionScore[0]+dimensionScore[1]+dimensionScore[2]+dimensionScore[3]+dimensionScore[5]-dimensionScore[4]-dimensionScore[6]+100;
            resultMap0.put("TMD(情绪纷乱的总分)", String.valueOf(score));
            resultJson.put("TMD(情绪纷乱的总分)", String.valueOf(score));*/
            for (int y = 0; y < dimensionEntities.size(); y += 2) {
                DimensionEntity dimensionEntity = dimensionEntities.get(y);
                DecimalFormat df = new DecimalFormat("######0.00");
                resultMap0.put(dimensionEntity.getName() + "得分", String.valueOf(Double.parseDouble(df.format(dimensionScore[y]))));
                resultJson.put(dimensionEntity.getName() + "得分", String.valueOf(Double.parseDouble(df.format(dimensionScore[y]))));
                resultMap0.put(dimensionEntities.get(y + 1).getName() + "得分", String.valueOf(Double.parseDouble(df.format(dimensionScore[y + 1]))));
                resultJson.put(dimensionEntities.get(y + 1).getName() + "得分", String.valueOf(Double.parseDouble(df.format(dimensionScore[y + 1]))));
            }
            resultMapList.add(resultMap0);
        }

        JSONObject returnJson = new JSONObject(true);
        returnJson.put("resultMapList", resultMapList);
        //returnJson.put("scaleName",resultJson.getString("scaleName"));
        returnJson.put("resultJson", resultJson);

        return returnJson;
    }

    public JSONObject scaleCalculateV2() throws Exception {

        //总分
        double score = 0;
        //外倾(E)得分
        int scoreE = 0;
        //内倾(I)得分
        int scoreI = 0;
        //直觉(N)得分
        int scoreN = 0;
        //感觉(S)得分
        int scoreS = 0;
        //情感(F)得分
        int scoreF = 0;
        //思维(T)得分
        int scoreT = 0;
        //判断(J)得分
        int scoreJ = 0;
        //知觉(P)得分
        int scoreP = 0;
        Map<String, String> resultMap0 = new LinkedHashMap<>();
        List<Map<String, String>> resultMapList = new ArrayList<>();

        //获取答案列表
        List<AnswerEntity> answerEntities = (List<AnswerEntity>) resultJson.get("answerEntities");
        //获取题目和答案列表
        List<ScaleEntity> scaleEntities = (List<ScaleEntity>) resultJson.get("scaleEntities");
        //获取评分规则列表
        List<ScaleMarksEntity> scaleMarksEntities = (List<ScaleMarksEntity>) resultJson.get("scaleMarksEntities");
        //获取维度信息列表
        List<DimensionEntity> dimensionEntities = (List<DimensionEntity>) resultJson.get("dimensionEntities");
        //新版本数据格式
        Map<String, Object> newResult = null;
        if (dimensionEntities.size() > 0) {
            //计算每个维度得分
            double[] dimensionScore = new double[dimensionEntities.size()];
            for (int i = 0; i < jsonArray.size(); i++) {
                JSONObject jsonObject1 = jsonArray.getJSONObject(i);
                for (int y = 0; y < dimensionEntities.size(); y++) {
                    //for (DimensionEntity dimensionEntity:dimensionEntities){
                    DimensionEntity dimensionEntity = dimensionEntities.get(y);
                    String questionNos = dimensionEntity.getQuestionNo();
                    String[] questionNo = questionNos.split("；");
                    for (String question : questionNo) {
                        if (question.equals(jsonObject1.getString("questionNo"))) {
                            for (AnswerEntity answerEntity : answerEntities) {
                                if (answerEntity.getQuestionNo().equals(question) && answerEntity.getName().equals(jsonObject1.getString("checkItems"))) {
                                    if (dimensionEntity.getName().equals("外倾-内倾")){
                                        if (answerEntity.getOptions().equals("A")){
                                            scoreE += Double.parseDouble(answerEntity.getScore());
                                        }else {
                                            scoreI += Double.parseDouble(answerEntity.getScore());
                                        }
                                    }else if (dimensionEntity.getName().equals("感觉-直觉")){
                                        if (answerEntity.getOptions().equals("A")){
                                            scoreS += Double.parseDouble(answerEntity.getScore());
                                        }else {
                                            scoreN += Double.parseDouble(answerEntity.getScore());
                                        }
                                    }else if (dimensionEntity.getName().equals("思维-情感")){
                                        if (answerEntity.getOptions().equals("A")){
                                            scoreT += Double.parseDouble(answerEntity.getScore());
                                        }else {
                                            scoreF += Double.parseDouble(answerEntity.getScore());
                                        }
                                    }else {
                                        if (answerEntity.getOptions().equals("A")){
                                            scoreJ += Double.parseDouble(answerEntity.getScore());
                                        }else {
                                            scoreP += Double.parseDouble(answerEntity.getScore());
                                        }
                                    }
                                    String checkItems = scaleEntities.get(Integer.parseInt(answerEntity.getQuestionNo()) - 1).getCheckItems();
                                    String[] CheckIteml = checkItems.split("；");
                                    if ((y & 1) == 1) {
                                        if (CheckIteml[0].equals(jsonObject1.getString("checkItems"))) {
                                            dimensionScore[y] += Double.parseDouble(answerEntity.getScore());
                                        } else {
                                            dimensionScore[y - 1] += Double.parseDouble(answerEntity.getScore());
                                        }
                                    } else {
                                        if (CheckIteml[0].equals(jsonObject1.getString("checkItems"))) {
                                            dimensionScore[y] += Double.parseDouble(answerEntity.getScore());
                                        } else {
                                            dimensionScore[y + 1] += Double.parseDouble(answerEntity.getScore());
                                        }
                                    }
                                }
                            }
                            break;
                        }
                    }
                }
            }
            dimensionScore[0] = scoreE - scoreI;
            dimensionScore[1] = scoreS - scoreN;
            dimensionScore[2] = scoreT - scoreF;
            dimensionScore[3] = scoreJ - scoreP;


            //将量表总维度根据维度名称进行分组
            Map<String, List<ScaleMarksEntity>> scaleMarksMap = scaleMarksEntities.stream().collect(Collectors.groupingBy(ScaleMarksEntity::getName));
            newResult = new LinkedHashMap<>();
            //返回值以及存数据库格式
            List<NewResultDto> newResultDtos = new ArrayList<>();
            JSONObject iconInfo = new JSONObject();
            //雷达图需要的维度以及最大值
            List<Map<String, Object>> indicator = new LinkedList<>();
            //雷达图所需要的常模参考值
            LinkedList<String> reference = new LinkedList<>();
            //雷达图需要的分数
            LinkedList<String> scoreList = new LinkedList<>();
            Map<String,Double> dimensionScoreMap = new HashMap<>();
            NEWCOMMONScale.commonComputeDimensionScore(null, resultMap0, resultJson, "外倾-内倾", dimensionScore[0], true, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
            NEWCOMMONScale.commonComputeDimensionScore(null, resultMap0, resultJson, "感觉-直觉", dimensionScore[1], true, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
            NEWCOMMONScale.commonComputeDimensionScore(null, resultMap0, resultJson, "思维-情感", dimensionScore[2], true, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
            NEWCOMMONScale.commonComputeDimensionScore(null, resultMap0, resultJson, "判断-知觉", dimensionScore[3], true, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
//            NEWCOMMONScale.commonComputeDimensionScore(null, resultMap0, resultJson, "感觉(S)", dimensionScore[4], true, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
//            NEWCOMMONScale.commonComputeDimensionScore(null, resultMap0, resultJson, "直觉(N)", dimensionScore[5], true, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
//            NEWCOMMONScale.commonComputeDimensionScore(null, resultMap0, resultJson, "外倾(E)", dimensionScore[6], true, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
//            NEWCOMMONScale.commonComputeDimensionScore(null, resultMap0, resultJson, "内倾(I)", dimensionScore[7], true, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
            dimensionScoreMap.put("8af1788589de8b880189de8bb1eb0008",dimensionScore[0]);
            dimensionScoreMap.put("8af1788589de8b880189de8bb2230009",dimensionScore[1]);
            dimensionScoreMap.put("8af1788589de8b880189de8bb25a000a",dimensionScore[2]);
            dimensionScoreMap.put("8af1788589de8b880189de8bb28f000b",dimensionScore[3]);
//            dimensionScoreMap.put("2c91f37d7bec0878017c9bc8586f57dc",dimensionScore[4]);
//            dimensionScoreMap.put("2c91f37d7bec0878017c9bc858a757dd",dimensionScore[5]);
//            dimensionScoreMap.put("2c91f37d7bec0878017c9bc858df57de",dimensionScore[6]);
//            dimensionScoreMap.put("2c91f37d7bec0878017c9bc8591857df",dimensionScore[7]);
            resultJson.put("dimensionScoreMap",dimensionScoreMap);



            // “外倾/内倾”=(内倾-外倾)/21*10 (正分为内倾I， 负分为外倾E)
            /*double score0 = ((dimensionScore[6] - dimensionScore[7]) / 21) * 10;
            String score0FLag = null;
            // “感觉/直觉”=(感觉-直觉)/26*10(正分为感觉S，负分为直觉N)
            double score1 = ((dimensionScore[4] - dimensionScore[5]) / 26) * 10;
            String score1FLag = null;
            //“思考/情感”=(思考-情感)/24*10(正分为思考T，负分为情感F)
            double score2 = ((dimensionScore[2] - dimensionScore[3]) / 24) * 10;
            String score2FLag = null;
            //“知觉/判断”=(知觉-判断)/22*10(正分为感性P，负分为判断J)
            double score3 = ((dimensionScore[1] - dimensionScore[0]) / 22) * 10;
            String score3FLag = null;
            DecimalFormat df = new DecimalFormat("######0.00");
            if (new BigDecimal(df.format(score0)).compareTo(new BigDecimal("-20")) >= 0 && new BigDecimal(df.format(score0)).compareTo(new BigDecimal("0")) < 0) {
                newResultDtos.add(new NewResultDto("外倾—内倾", df.format(score0), "外倾型", "外倾态度（E）：在外倾的态度中，心理能量和注意是向外流动的，是指向外在环境中的客体的。个体着重外在世界，因注意外在事情而获得动力。",
                        "无", "无", "(内倾-外倾)/21*10", "无", "否"));
                score0FLag = "E";
            } else if (new BigDecimal(df.format(score0)).compareTo(new BigDecimal("0")) >= 0 && new BigDecimal(df.format(score0)).compareTo(new BigDecimal("20")) <= 0) {
                newResultDtos.add(new NewResultDto("外倾—内倾", df.format(score0), "内倾型", "内倾态度（I）：在内倾的态度中，心理能量是从外部环境向内流动的，指向个体的内在经验与反应。个体着重内在世界，因内省、感觉而获得动力。",
                        "无", "无", "(内倾-外倾)/21*10", "无", "否"));
                score0FLag = "I";
            }
            if (new BigDecimal(df.format(score1)).compareTo(new BigDecimal("-25")) >= 0 && new BigDecimal(df.format(score1)).compareTo(new BigDecimal("0")) < 0) {
                newResultDtos.add(new NewResultDto("感觉—直觉", df.format(score1), "直觉型", "直觉功能（N）：偏好直觉的个体倾向于感知的可能性、事物之间的关系，注重事物的未来发展。",
                        "无", "无", "(感觉-直觉)/26*10", "无", "否"));
                score1FLag = "N";
            } else if (new BigDecimal(df.format(score1)).compareTo(new BigDecimal("0")) >= 0 && new BigDecimal(df.format(score1)).compareTo(new BigDecimal("25")) <= 0) {
                newResultDtos.add(new NewResultDto("感觉—直觉", df.format(score1), "感觉型", "感觉功能（S）：偏好感觉的个体倾向于通过视觉、听觉、触觉、味觉和嗅觉这5种方式来获得信息，个体表现为注重现在的事实与具体观点。",
                        "无", "无", "(感觉-直觉)/26*10", "无", "否"));
                score1FLag = "S";
            }
            if (new BigDecimal(df.format(score2)).compareTo(new BigDecimal("-23")) >= 0 && new BigDecimal(df.format(score2)).compareTo(new BigDecimal("0")) < 0) {
                newResultDtos.add(new NewResultDto("感觉—直觉", df.format(score2), "情感型", "情感功能（F）：在作出判断时，倾向于从个人感觉出发，注重事物对自身的价值与喜好。",
                        "无", "无", "(思考-情感)/24*10", "无", "否"));
                score2FLag = "F";
            } else if (new BigDecimal(df.format(score2)).compareTo(new BigDecimal("0")) >= 0 && new BigDecimal(df.format(score2)).compareTo(new BigDecimal("23")) <= 0) {
                newResultDtos.add(new NewResultDto("感觉—直觉", df.format(score2), "思考型", "思维功能（T）：根据对客观事实的分析，来作出决定，注重公平原则。",
                        "无", "无", "(思考-情感)/24*10", "无", "否"));
                score2FLag = "T";
            }
            if (new BigDecimal(df.format(score3)).compareTo(new BigDecimal("-21")) >= 0 && new BigDecimal(df.format(score3)).compareTo(new BigDecimal("0")) < 0) {
                newResultDtos.add(new NewResultDto("判断—知觉", df.format(score3), "判断型", "判断态度(J)：喜欢有条理的生活，实践计划时，以目标为本。通过思考或情感(T或F)来对外界作出反应。",
                        "无", "无", "(知觉-判断)/22*10", "无", "否"));
                score3FLag = "J";
            } else if (new BigDecimal(df.format(score3)).compareTo(new BigDecimal("0")) >= 0 && new BigDecimal(df.format(score3)).compareTo(new BigDecimal("21")) <= 0) {
                newResultDtos.add(new NewResultDto("判断—知觉", df.format(score3), "感性型", "感知态度（P）：不介意突发事情，喜欢弹性生活，注重过程而非目标。通过感觉或直觉（N或S）来对外界作出反应。",
                        "无", "无", "(知觉-判断)/22*10", "无", "否"));
                score3FLag = "P";
            }
            String totalFlag = score0FLag + score1FLag + score2FLag + score3FLag;
            if ("ISTJ".equals(totalFlag)) {
                resultMap0.put("结论", "沉静，认真，有责任感，讲求实际，注重事实，目标清晰且不易动摇，工作生活都打理得井井有条，心思缜密，重视传统和忠诚。");
                newResultDtos.add(new NewResultDto("总分", "无", "ISTJ组合型", "沉静，认真，有责任感，讲求实际，注重事实，目标清晰且不易动摇，工作生活都打理得井井有条，心思缜密，重视传统和忠诚。",
                        "无", "无", "无", "无", "是"));
            } else if ("ISFJ".equals(totalFlag)) {
                resultMap0.put("结论", "沉静，友善，谨慎，有责任感，重视细节，勤奋，做事有始有终，忠诚，细心，关心他人感受、尊重他人、替他人着想，努力创造一个有秩序、和谐的工作和家居环境。");
                newResultDtos.add(new NewResultDto("总分", "无", "ISFJ组合型", "沉静，友善，谨慎，有责任感，重视细节，勤奋，做事有始有终，忠诚，细心，关心他人感受、尊重他人、替他人着想，努力创造一个有秩序、和谐的工作和家居环境。",
                        "无", "无", "无", "无", "是"));
            } else if ("INFJ".equals(totalFlag)) {
                resultMap0.put("结论", "喜欢探索世界意义、体察万物关系，对人有很强的洞察力，坚持并践履自己的价值观念，懂得关心他人，友好而和善，有一个清晰的理念以谋取大众的最佳利益，能够有计划地、果断地去实践自己的理念。");
                newResultDtos.add(new NewResultDto("总分", "无", "INFJ组合型", "喜欢探索世界意义、体察万物关系，对人有很强的洞察力，坚持并践履自己的价值观念，懂得关心他人，友好而和善，有一个清晰的理念以谋取大众的最佳利益，能够有计划地、果断地去实践自己的理念。",
                        "无", "无", "无", "无", "是"));
            } else if ("INTJ".equals(totalFlag)) {
                resultMap0.put("结论", "具有创意头脑、有很大的冲劲去实践自己的理念，较为聪慧，能够很快地掌握事情发展的规律，想出长远的发展方向。对复杂的理论充满激情，会有条理地开展工作，并致力于目标的达成，是天生的组织者，有怀疑精神，能看到更多的机会，独立自主，有高水准的工作表现。");
                newResultDtos.add(new NewResultDto("总分", "无", "INTJ组合型", "具有创意头脑、有很大的冲劲去实践自己的理念，较为聪慧，能够很快地掌握事情发展的规律，想出长远的发展方向。对复杂的理论充满激情，会有条理地开展工作，并致力于目标的达成，是天生的组织者，有怀疑精神，能看到更多的机会，独立自主，有高水准的工作表现。",
                        "无", "无", "无", "无", "是"));
            } else if ("ISTP".equals(totalFlag)) {
                resultMap0.put("结论", "是冷静的观察者，具有超强的忍耐力和弹性，很重视事件的前因后果，遇到问题会马上行动并找到应对措施，可以从大量信息中找到症结，能够以理性的原则把事实组织起来，重视效率，善于实践，动手能力强。");
                newResultDtos.add(new NewResultDto("总分", "无", "ISTP组合型", "是冷静的观察者，具有超强的忍耐力和弹性，很重视事件的前因后果，遇到问题会马上行动并找到应对措施，可以从大量信息中找到症结，能够以理性的原则把事实组织起来，重视效率，善于实践，动手能力强。",
                        "无", "无", "无", "无", "是"));
            } else if ("ISFP".equals(totalFlag)) {
                resultMap0.put("结论", "沉静、友善、敏感和仁慈，心思细腻，不喜欢与人产生冲突，不会强迫别人接受自己的意见或价值观，喜欢有独自的空间，可以按照自己的时间规划进行工作安排，渴望沟通分享，热爱大自然，喜欢探索未知的事物。");
                newResultDtos.add(new NewResultDto("总分", "无", "ISFP组合型", "沉静、友善、敏感和仁慈，心思细腻，不喜欢与人产生冲突，不会强迫别人接受自己的意见或价值观，喜欢有独自的空间，可以按照自己的时间规划进行工作安排，渴望沟通分享，热爱大自然，喜欢探索未知的事物。",
                        "无", "无", "无", "无", "是"));
            } else if ("INFP".equals(totalFlag)) {
                resultMap0.put("结论", "理想主义者，忠于自己的价值观及自己所重视的人，只要双方的价值观没有抵触，往往能包容他人，有弹性，善于接受新事物，有好奇心，能快速预判事情的发展趋向，适应力强，能快速发现他人的优势，并助其发挥潜能。");
                newResultDtos.add(new NewResultDto("总分", "无", "INFP组合型", "理想主义者，忠于自己的价值观及自己所重视的人，只要双方的价值观没有抵触，往往能包容他人，有弹性，善于接受新事物，有好奇心，能快速预判事情的发展趋向，适应力强，能快速发现他人的优势，并助其发挥潜能。",
                        "无", "无", "无", "无", "是"));
            } else if ("INTP".equals(totalFlag)) {
                resultMap0.put("结论", "沉静、满足、有弹性、适应力强，有怀疑精神，有时喜欢批评，擅于分析，对任何感兴趣的事物，都要探索一个合理的解释，喜欢理论性和抽象性的概念，热衷于思考，有深度的钻研精神，思维严谨有条理。");
                newResultDtos.add(new NewResultDto("总分", "无", "INTP组合型", "沉静、满足、有弹性、适应力强，有怀疑精神，有时喜欢批评，擅于分析，对任何感兴趣的事物，都要探索一个合理的解释，喜欢理论性和抽象性的概念，热衷于思考，有深度的钻研精神，思维严谨有条理。",
                        "无", "无", "无", "无", "是"));
            } else if ("ESTP".equals(totalFlag)) {
                resultMap0.put("结论", "自然不做作，喜欢主动与别人交往，专注于“此时此地”，讲求实际，注重结果，希望以积极的行动去解决问题，喜欢学习新的事物，较为理性，擅长数学及专业理论，追求利益最大化，但过度严谨。");
                newResultDtos.add(new NewResultDto("总分", "无", "ESTP组合型", "自然不做作，喜欢主动与别人交往，专注于“此时此地”，讲求实际，注重结果，希望以积极的行动去解决问题，喜欢学习新的事物，较为理性，擅长数学及专业理论，追求利益最大化，但过度严谨。",
                        "无", "无", "无", "无", "是"));
            } else if ("ESFP".equals(totalFlag)) {
                resultMap0.put("结论", "外向、友善、包容，热爱生命，喜欢物质享受，接受力强，讲究实用性，易接受新朋友和适应新环境，富有灵活性，善于识人，喜欢和他人一起工作，周到得体，但处理原则问题时会摇摆不定。");
                newResultDtos.add(new NewResultDto("总分", "无", "ESFP组合型", "外向、友善、包容，热爱生命，喜欢物质享受，接受力强，讲究实用性，易接受新朋友和适应新环境，富有灵活性，善于识人，喜欢和他人一起工作，周到得体，但处理原则问题时会摇摆不定。",
                        "无", "无", "无", "无", "是"));
            } else if ("ENFP".equals(totalFlag)) {
                resultMap0.put("结论", "热情且富有想象力，认为生活充满很多可能性，有灵性，可以快速将事物的有关信息联系起来，有信心按照自己的判断去解决问题，有很强的即兴发挥能力，容易冲动，很需要别人的肯定，也乐于欣赏和支持别人。");
                newResultDtos.add(new NewResultDto("总分", "无", "ENFP组合型", "热情且富有想象力，认为生活充满很多可能性，有灵性，可以快速将事物的有关信息联系起来，有信心按照自己的判断去解决问题，有很强的即兴发挥能力，容易冲动，很需要别人的肯定，也乐于欣赏和支持别人。",
                        "无", "无", "无", "无", "是"));
            } else if ("ENTP".equals(totalFlag)) {
                resultMap0.put("结论", "思维敏捷，反应快，勇于发言，善于洞察别人，能激励他人，警觉性强，喜欢用战略的眼光分析问题，不喜欢例行公事，能随机应变地去应付新的和富于挑战性的问题。");
                newResultDtos.add(new NewResultDto("总分", "无", "ENTP组合型", "思维敏捷，反应快，勇于发言，善于洞察别人，能激励他人，警觉性强，喜欢用战略的眼光分析问题，不喜欢例行公事，能随机应变地去应付新的和富于挑战性的问题。",
                        "无", "无", "无", "无", "是"));
            } else if ("ESTJ".equals(totalFlag)) {
                resultMap0.put("结论", "讲求实际，注重现实，能果断而快速地作出实际可行的决定，并安排计划和组织人员去完成工作，注重细节，有一套清晰的逻辑标准，能遵从规章制度并坚决执行，善于处理程式化事物，一丝不苟，习惯以经验解决问题。");
                newResultDtos.add(new NewResultDto("总分", "无", "ESTJ组合型", "讲求实际，注重现实，能果断而快速地作出实际可行的决定，并安排计划和组织人员去完成工作，注重细节，有一套清晰的逻辑标准，能遵从规章制度并坚决执行，善于处理程式化事物，一丝不苟，习惯以经验解决问题。",
                        "无", "无", "无", "无", "是"));
            } else if ("ESFJ".equals(totalFlag)) {
                resultMap0.put("结论", "能言善辩，有爱心、尽责，善于合作，喜欢与别人共事，能够注意到别人生活中的需要，渴望和谐的环境并致力于营造这样的环境，希望自己的努力可以得到认可，有极强的同理心，希望通过自己的力量帮助他人。");
                newResultDtos.add(new NewResultDto("总分", "无", "ESFJ组合型", "能言善辩，有爱心、尽责，善于合作，喜欢与别人共事，能够注意到别人生活中的需要，渴望和谐的环境并致力于营造这样的环境，希望自己的努力可以得到认可，有极强的同理心，希望通过自己的力量帮助他人。",
                        "无", "无", "无", "无", "是"));
            } else if ("ENFJ".equals(totalFlag)) {
                resultMap0.put("结论", "温情，有同情心，反应敏捷，有责任感，能为他人着想，善于发现他人的潜能，表达能力强，社交活跃，能积极地协助他人和组织的成长，有启发人的领导才能，忠诚，对赞美和批评都能作出快速回应，喜欢直接表明自己的观点。");
                newResultDtos.add(new NewResultDto("总分", "无", "ENFJ组合型", "温情，有同情心，反应敏捷，有责任感，能为他人着想，善于发现他人的潜能，表达能力强，社交活跃，能积极地协助他人和组织的成长，有启发人的领导才能，忠诚，对赞美和批评都能作出快速回应，喜欢直接表明自己的观点。",
                        "无", "无", "无", "无", "是"));
            } else if ("ENTJ".equals(totalFlag)) {
                resultMap0.put("结论", "坦率、果断、乐于作为领导者，能够发现组织规章制度的不合理性并着力加以改善，喜欢制定长远计划，善于设定目标，努力求知，又能把知识传给别人，富有远见，见解深刻。");
                newResultDtos.add(new NewResultDto("总分", "无", "ENTJ组合型", "坦率、果断、乐于作为领导者，能够发现组织规章制度的不合理性并着力加以改善，喜欢制定长远计划，善于设定目标，努力求知，又能把知识传给别人，富有远见，见解深刻。",
                        "无", "无", "无", "无", "是"));
            }*/
            //需要图表展示的
            iconInfo.put("indicator", indicator);
            //判断是否有常模参考值，即reference的内容如果全为0，则不进行返回
            if (!reference.stream().allMatch("0"::equals)) {
                iconInfo.put("reference", reference);
            }
            iconInfo.put("scoreList", scoreList);
            if (indicator.size() == 0 && reference.size() == 0) {
                newResult.put("iconInfo", "");
            } else {
                newResult.put("iconInfo", iconInfo);
            }
            newResult.put("result", newResultDtos);
            resultMapList.add(resultMap0);
        }

        JSONObject returnJson = new JSONObject(true);
        returnJson.put("resultMapList", resultMapList);

        returnJson.put("resultJson", resultJson);
        returnJson.put(ScaleConstant.ResultEnum.RESULT_NEW_FIELD.getKeyword(), newResult);


        return returnJson;
    }


}
