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.ScaleMarksEntity;
import com.rf.psychological.scale.scaleresult.ScaleConstant;
import com.rf.psychological.utils.Constant;

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

import static com.rf.psychological.scale.resultBusiness.scaleResult.NEWCOMMONScale.commonComputeDimensionScore;

/**
 * @description 成人依恋量表
 */
public class AASScale extends BaseScale {
    public AASScale(JSONArray jsonArray, JSONObject resultJson) {
        super(jsonArray, resultJson);
    }

    public JSONObject scaleCalculate() throws Exception {

        // 自定义路径使用
        /*ScaleUtil.getScaleDll("AASSCALE.dll");
        System.out.println("JSONArray:"+jsonArray);
        System.out.println("resultJson:"+resultJson);
        XScale xScale = new XScale(jsonArray,resultJson);
        String result = xScale.AASScale(jsonArray.toString(), resultJson.toString());
        //System.out.println("dllresult:"+result);
        //解决排序问题
        LinkedHashMap<String, Object> jsonMap = JSON.parseObject(result,LinkedHashMap.class, Feature.OrderedField);
        JSONObject jsonObject = new JSONObject(true);
        jsonObject.putAll(jsonMap);
        System.out.println("jsonObject:"+jsonObject);
        return jsonObject;*/

        //亲近分量表总分
        int score1 = 0;
        //依赖分量表总分
        int score2 = 0;
        //焦虑分量表总分
        int score3 = 0;
        //亲近依赖均分
        double scoreA;
        //焦虑均分
        double scoreB;

        for (int i = 0; i < jsonArray.size(); i++) {
            JSONObject jsonObject1 = jsonArray.getJSONObject(i);
            if ((i + 1) == 1 || (i + 1) == 6 || (i + 1) == 8 || (i + 1) == 12 || (i + 1) == 13 || (i + 1) == 17) {
                if (jsonObject1.getString("scoreDirection").equals("1")) {
                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
                        score1 += 1;
                    } else if (jsonObject1.getString("checkItems").equals("较不符合")) {
                        score1 += 2;
                    } else if (jsonObject1.getString("checkItems").equals("不能确定")) {
                        score1 += 3;
                    } else if (jsonObject1.getString("checkItems").equals("较符合")) {
                        score1 += 4;
                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
                        score1 += 5;
                    }
                } else {
                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
                        score1 += 5;
                    } else if (jsonObject1.getString("checkItems").equals("较不符合")) {
                        score1 += 4;
                    } else if (jsonObject1.getString("checkItems").equals("不能确定")) {
                        score1 += 3;
                    } else if (jsonObject1.getString("checkItems").equals("较符合")) {
                        score1 += 2;
                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
                        score1 += 1;
                    }
                }
            } else if ((i + 1) == 2 || (i + 1) == 5 || (i + 1) == 7 || (i + 1) == 14 || (i + 1) == 16 || (i + 1) == 18) {
                if (jsonObject1.getString("scoreDirection").equals("1")) {
                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
                        score2 += 1;
                    } else if (jsonObject1.getString("checkItems").equals("较不符合")) {
                        score2 += 2;
                    } else if (jsonObject1.getString("checkItems").equals("不能确定")) {
                        score2 += 3;
                    } else if (jsonObject1.getString("checkItems").equals("较符合")) {
                        score2 += 4;
                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
                        score2 += 5;
                    }
                } else {
                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
                        score2 += 5;
                    } else if (jsonObject1.getString("checkItems").equals("较不符合")) {
                        score2 += 4;
                    } else if (jsonObject1.getString("checkItems").equals("不能确定")) {
                        score2 += 3;
                    } else if (jsonObject1.getString("checkItems").equals("较符合")) {
                        score2 += 2;
                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
                        score2 += 1;
                    }
                }
            } else {
                if (jsonObject1.getString("scoreDirection").equals("1")) {
                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
                        score3 += 1;
                    } else if (jsonObject1.getString("checkItems").equals("较不符合")) {
                        score3 += 2;
                    } else if (jsonObject1.getString("checkItems").equals("不能确定")) {
                        score3 += 3;
                    } else if (jsonObject1.getString("checkItems").equals("较符合")) {
                        score3 += 4;
                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
                        score3 += 5;
                    }
                } else {
                    if (jsonObject1.getString("checkItems").equals("完全不符合")) {
                        score3 += 5;
                    } else if (jsonObject1.getString("checkItems").equals("较不符合")) {
                        score3 += 4;
                    } else if (jsonObject1.getString("checkItems").equals("不能确定")) {
                        score3 += 3;
                    } else if (jsonObject1.getString("checkItems").equals("较符合")) {
                        score3 += 2;
                    } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
                        score3 += 1;
                    }
                }
            }
        }

        DecimalFormat df = new DecimalFormat("######0.00");

        scoreA = Double.parseDouble(df.format((score1 + score2) / 12.0));
        scoreB = Double.parseDouble(df.format(score3 / 6.0));

        //得分列表
        Map<String, String> resultMap = new LinkedHashMap<>();
        resultMap.put("亲近依赖均分", String.valueOf(scoreA));
        resultMap.put("焦虑均分", String.valueOf(scoreB));

        resultJson.put("亲近依赖均分", String.valueOf(scoreA));
        resultJson.put("焦虑均分", String.valueOf(scoreB));


        if (scoreA > 3 && scoreB < 3) {
            resultMap.put("结论", "安全型");
            resultJson.put("结论", "安全型");
        } else if (scoreA > 3 && scoreB > 3) {
            resultMap.put("结论", "先占型");
            resultJson.put("结论", "先占型");
        } else if (scoreA < 3 && scoreB < 3) {
            resultMap.put("结论", "拒绝型");
            resultJson.put("结论", "拒绝型");
        } else if (scoreA < 3 && scoreB > 3) {
            resultMap.put("结论", "恐惧型");
            resultJson.put("结论", "恐惧型");
        }

        Map<String,Double> dimensionScoreMap = new HashMap<>();
        dimensionScoreMap.put("8af178857b94d581017b94e318230a0d", (double) score1);
        dimensionScoreMap.put("8af178857b94d581017b94e318930a0e", (double) score2);
        dimensionScoreMap.put("8af178857b94d581017b94e319020a0f", (double) score3);
        resultJson.put("dimensionScoreMap",dimensionScoreMap);
        List<Map<String, String>> resultMapList = new ArrayList<>();
        resultMapList.add(resultMap);

        JSONObject returnJson = new JSONObject(true);
        returnJson.put("resultMapList", resultMapList);
        returnJson.put("scaleName", Constant.SHEET_NAME_AAS);
        returnJson.put("resultJson", resultJson);

        return returnJson;
    }

    public JSONObject scaleCalculateV2() throws Exception {

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

        //亲近分量表总分
        int score1 = 0;
        //依赖分量表总分
        int score2 = 0;
        //焦虑分量表总分
        int score3 = 0;
        //亲近依赖均分
        double scoreA = 0;
        //焦虑均分
        double scoreB = 0;

        //获取评分规则列表
        List<ScaleMarksEntity> scaleMarksEntities = (List<ScaleMarksEntity>) resultJson.get("scaleMarksEntities");
        //获取维度信息列表
        List<DimensionEntity> dimensionEntities = (List<DimensionEntity>) resultJson.get("dimensionEntities");
        //新版本数据格式
        Map<String, Object> newResult = new LinkedHashMap<>();

        //返回值以及存数据库格式
        List<NewResultDto> newResultDtos = new ArrayList<>();
        Map<String,Double> dimensionScoreMap = new HashMap<>();
        if (jsonArray.size() > 0) {
            for (int i = 0; i < jsonArray.size(); i++) {
                JSONObject jsonObject1 = jsonArray.getJSONObject(i);
                if ((i + 1) == 1 || (i + 1) == 6 || (i + 1) == 8 || (i + 1) == 12 || (i + 1) == 13 || (i + 1) == 17) {
                    if (jsonObject1.getString("scoreDirection").equals("1")) {
                        if (jsonObject1.getString("checkItems").equals("完全不符合")) {
                            score1 += 1;
                        } else if (jsonObject1.getString("checkItems").equals("较不符合")) {
                            score1 += 2;
                        } else if (jsonObject1.getString("checkItems").equals("不能确定")) {
                            score1 += 3;
                        } else if (jsonObject1.getString("checkItems").equals("较符合")) {
                            score1 += 4;
                        } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
                            score1 += 5;
                        }
                    } else {
                        if (jsonObject1.getString("checkItems").equals("完全不符合")) {
                            score1 += 5;
                        } else if (jsonObject1.getString("checkItems").equals("较不符合")) {
                            score1 += 4;
                        } else if (jsonObject1.getString("checkItems").equals("不能确定")) {
                            score1 += 3;
                        } else if (jsonObject1.getString("checkItems").equals("较符合")) {
                            score1 += 2;
                        } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
                            score1 += 1;
                        }
                    }
                } else if ((i + 1) == 2 || (i + 1) == 5 || (i + 1) == 7 || (i + 1) == 14 || (i + 1) == 16 || (i + 1) == 18) {
                    if (jsonObject1.getString("scoreDirection").equals("1")) {
                        if (jsonObject1.getString("checkItems").equals("完全不符合")) {
                            score2 += 1;
                        } else if (jsonObject1.getString("checkItems").equals("较不符合")) {
                            score2 += 2;
                        } else if (jsonObject1.getString("checkItems").equals("不能确定")) {
                            score2 += 3;
                        } else if (jsonObject1.getString("checkItems").equals("较符合")) {
                            score2 += 4;
                        } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
                            score2 += 5;
                        }
                    } else {
                        if (jsonObject1.getString("checkItems").equals("完全不符合")) {
                            score2 += 5;
                        } else if (jsonObject1.getString("checkItems").equals("较不符合")) {
                            score2 += 4;
                        } else if (jsonObject1.getString("checkItems").equals("不能确定")) {
                            score2 += 3;
                        } else if (jsonObject1.getString("checkItems").equals("较符合")) {
                            score2 += 2;
                        } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
                            score2 += 1;
                        }
                    }
                } else {
                    if (jsonObject1.getString("scoreDirection").equals("1")) {
                        if (jsonObject1.getString("checkItems").equals("完全不符合")) {
                            score3 += 1;
                        } else if (jsonObject1.getString("checkItems").equals("较不符合")) {
                            score3 += 2;
                        } else if (jsonObject1.getString("checkItems").equals("不能确定")) {
                            score3 += 3;
                        } else if (jsonObject1.getString("checkItems").equals("较符合")) {
                            score3 += 4;
                        } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
                            score3 += 5;
                        }
                    } else {
                        if (jsonObject1.getString("checkItems").equals("完全不符合")) {
                            score3 += 5;
                        } else if (jsonObject1.getString("checkItems").equals("较不符合")) {
                            score3 += 4;
                        } else if (jsonObject1.getString("checkItems").equals("不能确定")) {
                            score3 += 3;
                        } else if (jsonObject1.getString("checkItems").equals("较符合")) {
                            score3 += 2;
                        } else if (jsonObject1.getString("checkItems").equals("完全符合")) {
                            score3 += 1;
                        }
                    }
                }
            }

            DecimalFormat df = new DecimalFormat("######0.00");
            //计算每个维度得分dimensionEntities
            double[] dimensionScore = new double[dimensionEntities.size()];
            dimensionScore[0] = Double.parseDouble(df.format(score1 / 6));
            dimensionScore[1] = Double.parseDouble(df.format(score2 / 6));
            dimensionScore[2] = Double.parseDouble(df.format(score3 / 6));

            scoreA = Double.parseDouble(df.format((score1 + score2) / 12.0));
            scoreB = Double.parseDouble(df.format(score3 / 6.0));
            resultMap0.put("总分", String.valueOf(scoreA + scoreB));
            resultJson.put("总分", String.valueOf(scoreA + scoreB));
            if (scoreA > 3 && scoreB <= 3) {
                newResultDtos.add(new NewResultDto("总分", String.valueOf(scoreA + scoreB), "安全型", "亲密关系和相互依赖安心，乐观、好交际。在感情上很容易接近他人。不管是依赖他人还是被人依赖都感觉心安。不会担忧独处和不为人接纳。认为自己是值得爱的，他人也是值得爱和信任的。十分容易与其他人接近，总是放心地依赖他人和让别人依赖自己。不会过于担心被抛弃，也不怕别人在感情上与自己过于亲近。", "无",
                        "无", "亲近主要测量个体对接近和亲密感到舒适的程度。依赖主要测量个体感到当需要帮助时能有效依赖他人的程度以及拥有信赖他人的能力。焦虑主要测量一个人担心被抛弃或不被喜爱的程度，或者得不到爱与被人抛弃的无助。", "寻求专业心理治疗，如认知行为疗法或心理动力疗法，可以帮你认识并改变自己的行为模式。专业心理医生可以为你提供指导，增强自我意识，调整自己的行为。建立良好的依恋关系。", "是"));
                resultMap0.put("总分解释", "安全型");
                resultMap0.put("总分说明", "亲密关系和相互依赖安心，乐观、好交际。在感情上很容易接近他人。不管是依赖他人还是被人依赖都感觉心安。不会担忧独处和不为人接纳。认为自己是值得爱的，他人也是值得爱和信任的。十分容易与其他人接近，总是放心地依赖他人和让别人依赖自己。不会过于担心被抛弃，也不怕别人在感情上与自己过于亲近。");
                resultMap0.put("总分解读", "亲近主要测量个体对接近和亲密感到舒适的程度。依赖主要测量个体感到当需要帮助时能有效依赖他人的程度以及拥有信赖他人的能力。焦虑主要测量一个人担心被抛弃或不被喜爱的程度，或者得不到爱与被人抛弃的无助。");
                resultMap0.put("总分建议", "寻求专业心理治疗，如认知行为疗法或心理动力疗法，可以帮你认识并改变自己的行为模式。专业心理医生可以为你提供指导，增强自我意识，调整自己的行为。建立良好的依恋关系。");
                resultJson.put("总分解释", "安全型");
                resultJson.put("总分说明", "亲密关系和相互依赖安心，乐观、好交际。在感情上很容易接近他人。不管是依赖他人还是被人依赖都感觉心安。不会担忧独处和不为人接纳。认为自己是值得爱的，他人也是值得爱和信任的。十分容易与其他人接近，总是放心地依赖他人和让别人依赖自己。不会过于担心被抛弃，也不怕别人在感情上与自己过于亲近。");
                resultJson.put("总分解读", "亲近主要测量个体对接近和亲密感到舒适的程度。依赖主要测量个体感到当需要帮助时能有效依赖他人的程度以及拥有信赖他人的能力。焦虑主要测量一个人担心被抛弃或不被喜爱的程度，或者得不到爱与被人抛弃的无助。");
                resultJson.put("总分建议", "寻求专业心理治疗，如认知行为疗法或心理动力疗法，可以帮你认识并改变自己的行为模式。专业心理医生可以为你提供指导，增强自我意识，调整自己的行为。建立良好的依恋关系。");
            } else if (scoreA > 3 && scoreB > 3) {
                newResultDtos.add(new NewResultDto("总分", String.valueOf(scoreA + scoreB), "先占型", "对有损亲密关系的任何威胁都不安和警惕，贪婪、妒忌。希望在亲密关系中投入全部的感情，但经常发现他人并不乐意杷关系发展到如自己期望的那般亲密。没有亲密关系让你不安，有时还担心伴侣不会像你看重他一样看重你。", "无",
                        "无", "亲近主要测量个体对接近和亲密感到舒适的程度。依赖主要测量个体感到当需要帮助时能有效依赖他人的程度以及拥有信赖他人的能力。焦虑主要测量一个人担心被抛弃或不被喜爱的程度，或者得不到爱与被人抛弃的无助。", "寻求专业心理治疗，如认知行为疗法或心理动力疗法，可以帮你认识并改变自己的行为模式。专业心理医生可以为你提供指导，增强自我意识，调整自己的行为。建立良好的依恋关系。", "是"));
                resultMap0.put("总分解释", "先占型");
                resultMap0.put("总分说明", "对有损亲密关系的任何威胁都不安和警惕，贪婪、妒忌。希望在亲密关系中投入全部的感情，但经常发现他人并不乐意杷关系发展到如自己期望的那般亲密。没有亲密关系让你不安，有时还担心伴侣不会像你看重他一样看重你。");
                resultMap0.put("总分解读", "亲近主要测量个体对接近和亲密感到舒适的程度。依赖主要测量个体感到当需要帮助时能有效依赖他人的程度以及拥有信赖他人的能力。焦虑主要测量一个人担心被抛弃或不被喜爱的程度，或者得不到爱与被人抛弃的无助。");
                resultMap0.put("总分建议", "寻求专业心理治疗，如认知行为疗法或心理动力疗法，可以帮你认识并改变自己的行为模式。专业心理医生可以为你提供指导，增强自我意识，调整自己的行为。建立良好的依恋关系。");
                resultJson.put("总分解释", "先占型");
                resultJson.put("总分说明", "对有损亲密关系的任何威胁都不安和警惕，贪婪、妒忌。希望在亲密关系中投入全部的感情，但经常发现他人并不乐意杷关系发展到如自己期望的那般亲密。没有亲密关系让你不安，有时还担心伴侣不会像你看重他一样看重你。");
                resultJson.put("总分解读", "亲近主要测量个体对接近和亲密感到舒适的程度。依赖主要测量个体感到当需要帮助时能有效依赖他人的程度以及拥有信赖他人的能力。焦虑主要测量一个人担心被抛弃或不被喜爱的程度，或者得不到爱与被人抛弃的无助。");
                resultJson.put("总分建议", "寻求专业心理治疗，如认知行为疗法或心理动力疗法，可以帮你认识并改变自己的行为模式。专业心理医生可以为你提供指导，增强自我意识，调整自己的行为。建立良好的依恋关系。");
            } else if (scoreA <= 3 && scoreB <= 3) {
                newResultDtos.add(new NewResultDto("总分", String.valueOf(scoreA + scoreB), "拒绝型", "自立。漠视亲密关系，冷淡、独立。即使没有亲密关系也安心。对你而言，独立和自给自足更加重要，你不喜欢依赖别人或让人依赖。崇尚独立，对自我是积极的，否认渴望亲近，对他人是消极的。", "无",
                        "无", "亲近主要测量个体对接近和亲密感到舒适的程度。依赖主要测量个体感到当需要帮助时能有效依赖他人的程度以及拥有信赖他人的能力。焦虑主要测量一个人担心被抛弃或不被喜爱的程度，或者得不到爱与被人抛弃的无助。", "寻求专业心理治疗，如认知行为疗法或心理动力疗法，可以帮你认识并改变自己的行为模式。专业心理医生可以为你提供指导，增强自我意识，调整自己的行为。建立良好的依恋关系。", "是"));
                resultMap0.put("总分解释", "拒绝型");
                resultMap0.put("总分说明", "自立。漠视亲密关系，冷淡、独立。即使没有亲密关系也安心。对你而言，独立和自给自足更加重要，你不喜欢依赖别人或让人依赖。崇尚独立，对自我是积极的，否认渴望亲近，对他人是消极的。");
                resultMap0.put("总分解读", "亲近主要测量个体对接近和亲密感到舒适的程度。依赖主要测量个体感到当需要帮助时能有效依赖他人的程度以及拥有信赖他人的能力。焦虑主要测量一个人担心被抛弃或不被喜爱的程度，或者得不到爱与被人抛弃的无助。");
                resultMap0.put("总分建议", "寻求专业心理治疗，如认知行为疗法或心理动力疗法，可以帮你认识并改变自己的行为模式。专业心理医生可以为你提供指导，增强自我意识，调整自己的行为。建立良好的依恋关系。");
                resultJson.put("总分解释", "拒绝型");
                resultJson.put("总分说明", "自立。漠视亲密关系，冷淡、独立。即使没有亲密关系也安心。对你而言，独立和自给自足更加重要，你不喜欢依赖别人或让人依赖。崇尚独立，对自我是积极的，否认渴望亲近，对他人是消极的。");
                resultJson.put("总分解读", "亲近主要测量个体对接近和亲密感到舒适的程度。依赖主要测量个体感到当需要帮助时能有效依赖他人的程度以及拥有信赖他人的能力。焦虑主要测量一个人担心被抛弃或不被喜爱的程度，或者得不到爱与被人抛弃的无助。");
                resultJson.put("总分建议", "寻求专业心理治疗，如认知行为疗法或心理动力疗法，可以帮你认识并改变自己的行为模式。专业心理医生可以为你提供指导，增强自我意识，调整自己的行为。建立良好的依恋关系。");
            } else if (scoreA <= 3 && scoreB > 3) {
                newResultDtos.add(new NewResultDto("总分", String.valueOf(scoreA + scoreB), "恐惧型", "害怕被遗弃，不信任他人，猜忌多疑、害羞。和他人发生亲密接触使你不安。感情上你渴望亲密关系，但很难完全相信他人或依赖他人。担心自己和他人变得太亲密会受到伤害。对自己和他人的态度都是消极的，一旦建立了亲密关系，往往会过度担心伴侣会离开自己，整天提心吊胆。", "无",
                        "无", "亲近主要测量个体对接近和亲密感到舒适的程度。依赖主要测量个体感到当需要帮助时能有效依赖他人的程度以及拥有信赖他人的能力。焦虑主要测量一个人担心被抛弃或不被喜爱的程度，或者得不到爱与被人抛弃的无助。", "寻求专业心理治疗，如认知行为疗法或心理动力疗法，可以帮你认识并改变自己的行为模式。专业心理医生可以为你提供指导，增强自我意识，调整自己的行为。建立良好的依恋关系。", "是"));
                resultMap0.put("总分解释", "恐惧型");
                resultMap0.put("总分说明", "害怕被遗弃，不信任他人，猜忌多疑、害羞。和他人发生亲密接触使你不安。感情上你渴望亲密关系，但很难完全相信他人或依赖他人。担心自己和他人变得太亲密会受到伤害。对自己和他人的态度都是消极的，一旦建立了亲密关系，往往会过度担心伴侣会离开自己，整天提心吊胆。");
                resultMap0.put("总分解读", "亲近主要测量个体对接近和亲密感到舒适的程度。依赖主要测量个体感到当需要帮助时能有效依赖他人的程度以及拥有信赖他人的能力。焦虑主要测量一个人担心被抛弃或不被喜爱的程度，或者得不到爱与被人抛弃的无助。");
                resultMap0.put("总分建议", "寻求专业心理治疗，如认知行为疗法或心理动力疗法，可以帮你认识并改变自己的行为模式。专业心理医生可以为你提供指导，增强自我意识，调整自己的行为。建立良好的依恋关系。");
                resultJson.put("总分解释", "恐惧型");
                resultJson.put("总分说明", "害怕被遗弃，不信任他人，猜忌多疑、害羞。和他人发生亲密接触使你不安。感情上你渴望亲密关系，但很难完全相信他人或依赖他人。担心自己和他人变得太亲密会受到伤害。对自己和他人的态度都是消极的，一旦建立了亲密关系，往往会过度担心伴侣会离开自己，整天提心吊胆。");
                resultJson.put("总分解读", "亲近主要测量个体对接近和亲密感到舒适的程度。依赖主要测量个体感到当需要帮助时能有效依赖他人的程度以及拥有信赖他人的能力。焦虑主要测量一个人担心被抛弃或不被喜爱的程度，或者得不到爱与被人抛弃的无助。");
                resultJson.put("总分建议", "寻求专业心理治疗，如认知行为疗法或心理动力疗法，可以帮你认识并改变自己的行为模式。专业心理医生可以为你提供指导，增强自我意识，调整自己的行为。建立良好的依恋关系。");
            }
            resultMapList.add(resultMap0);

            //将量表总维度根据维度名称进行分组
            Map<String, List<ScaleMarksEntity>> scaleMarksMap = scaleMarksEntities.stream().collect(Collectors.groupingBy(ScaleMarksEntity::getName));
            JSONObject iconInfo = new JSONObject();
            //雷达图需要的维度以及最大值
            List<Map<String, Object>> indicator = new LinkedList<>();
            //雷达图所需要的常模参考值
            LinkedList<String> reference = new LinkedList<>();
            //雷达图需要的分数
            LinkedList<String> scoreList = new LinkedList<>();
            //计算维度所在评分区间
            commonComputeDimensionScore(df, resultMap0, resultJson, dimensionEntities, dimensionScore, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
            //需要图表展示的
            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);
            }

            dimensionScoreMap.put("8af178857b94d581017b94e318230a0d", dimensionScore[0]);
            dimensionScoreMap.put("8af178857b94d581017b94e318930a0e", dimensionScore[1]);
            dimensionScoreMap.put("8af178857b94d581017b94e319020a0f", dimensionScore[2]);
            resultJson.put("dimensionScoreMap",dimensionScoreMap);
        }

        newResult.put("result", newResultDtos);
        resultMapList.add(resultMap0);
        JSONObject returnJson = new JSONObject(true);
        returnJson.put("resultMapList", resultMapList);
        //returnJson.put("scaleName",resultJson.getString("scaleName"));
        returnJson.put("resultJson", resultJson);
        returnJson.put(ScaleConstant.ResultEnum.RESULT_NEW_FIELD.getKeyword(), newResult);

        return returnJson;
    }
}
