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 org.springframework.beans.BeanUtils;

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

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

/**
 * @Author: GaoYiXuan
 * @Description:卡特尔16PF测试
 * @DateTime: 2022/7/18 23:01
 * @Params:
 * @Return
 */

public class C16PFTScale extends BaseScale {
    public C16PFTScale(JSONArray jsonArray, JSONObject resultJson) {
        super(jsonArray, resultJson);
    }

    /*public  JSONObject scaleCalculate() throws Exception {
        //总分
        double score = 0;
        DecimalFormat df = new DecimalFormat("######0.00");
        //结果列表
        Map<String, String> resultMap0 = new LinkedHashMap<>();
        List<Map<String, String>> resultMapList = new ArrayList<>();
        //新版本数据格式
        Map<String, Object> newResult = new LinkedHashMap<>();

        //获取答案列表
        List<AnswerEntity> answerEntities = (List<AnswerEntity>) resultJson.get("answerEntities");
        //获取评分规则列表
        List<ScaleMarksEntity> scaleMarksEntities = (List<ScaleMarksEntity>) resultJson.get("scaleMarksEntities");
        //获取维度信息列表
        List<DimensionEntity> dimensionEntities = (List<DimensionEntity>) resultJson.get("dimensionEntities");
        //获取特殊维度信息：这些维度需要根据已有维度进行计算
        dimensionEntities.add(new DimensionEntity("心理健康者的人格因素", "", "20211020112514", "1"));
        dimensionEntities.add(new DimensionEntity("从事专业而有成就者的人格因素", "", "20211020112514", "1"));
        dimensionEntities.add(new DimensionEntity("创造力强者的人格因素", "", "20211020112514", "1"));
        dimensionEntities.add(new DimensionEntity("在新的环境中有成长能力的人格因素", "", "20211020112514", "1"));
        dimensionEntities.add(new DimensionEntity("适应与焦虑性", "", "20211020112514", "1"));
        dimensionEntities.add(new DimensionEntity("内向与外向性", "", "20211020112514", "1"));
        dimensionEntities.add(new DimensionEntity("感情用事与安祥机警性", "", "20211020112514", "1"));
        dimensionEntities.add(new DimensionEntity("怯懦与果断性", "", "20211020112514", "1"));
        //计算每个维度得分dimensionEntities
        double[] dimensionScore = new double[dimensionEntities.size()];
        Map<String,Double> dimensionScoreMap = new HashMap<>();
        //jsonArray:用户自己选择的题目选项
        for (int i = 0; i < jsonArray.size(); i++) {
            JSONObject jsonObject1 = jsonArray.getJSONObject(i);
            //计算总分
            for (AnswerEntity answerEntity : answerEntities) {
                if (answerEntity.getQuestionNo().equals(jsonObject1.getString("questionNo"))) {
                    if (answerEntity.getName().equals(jsonObject1.getString("checkItems"))) {
                        score += Double.parseDouble(answerEntity.getScore());
                        break;
                    }
                }
            }

            //计算维度分数
            for (int y = 0; y < dimensionEntities.size(); y++) {
                //获取维度信息
                DimensionEntity dimensionEntity = dimensionEntities.get(y);
                //获取该维度下有哪些选项
                String questionNos = dimensionEntity.getQuestionNo();
                //得到选择题号
                String[] questionNo = questionNos.split("；");
                //处理特殊的维度分数
                if ("心理健康者的人格因素".equals(dimensionEntity.getName())){
                    dimensionScore[y] = dimensionScore[2] + dimensionScore[4] + (11 - dimensionScore[11]) + (11 - dimensionScore[15]);
                } else if ("从事专业而有成就者的人格因素".equals(dimensionEntity.getName())){
                    dimensionScore[y] = 2 * dimensionScore[14] + 2 * dimensionScore[5] + 2 * dimensionScore[2] + dimensionScore[3] + dimensionScore[10] + dimensionScore[13] + dimensionScore[12];
                } else if ("创造力强者的人格因素".equals(dimensionEntity.getName())){
                    dimensionScore[y] = 2 * (11 - dimensionScore[0]) + 2 * dimensionScore[1] + dimensionScore[3] + 2 * (11 - dimensionScore[4]) + dimensionScore[6] + 2 * dimensionScore[7] + dimensionScore[9] + (11 - dimensionScore[10]) + dimensionScore[12] + 2 * dimensionScore[13];
                } else if ("在新的环境中有成长能力的人格因素".equals(dimensionEntity.getName())){
                    dimensionScore[y] = dimensionScore[1] + dimensionScore[5] + dimensionScore[14] + (11 - dimensionScore[4]);
                } else if ("适应与焦虑性".equals(dimensionEntity.getName())){
                    dimensionScore[y] =((38 + 2 * dimensionScore[8] + 3 * dimensionScore[11] + 4 * dimensionScore[15]) - (2 * dimensionScore[2] + 2 * dimensionScore[6] + 2 * dimensionScore[14])) / 10;
                } else if ("内向与外向性".equals(dimensionEntity.getName())){
                    dimensionScore[y] =((2 * dimensionScore[0] + 3 * dimensionScore[3] + 4 * dimensionScore[4] + 5 * dimensionScore[6]) - (2 * dimensionScore[13] + 11)) / 10;
                } else if ("感情用事与安祥机警性".equals(dimensionEntity.getName())){
                    dimensionScore[y] =((77 + 2 * dimensionScore[2] + 2 * dimensionScore[3] + 2 * dimensionScore[4] + 2 * dimensionScore[10]) - (4 * dimensionScore[0] + 6*dimensionScore[7] + 2 * dimensionScore[9])) / 10;
                } else if ("怯懦与果断性".equals(dimensionEntity.getName())){
                    dimensionScore[y] = ((4 * dimensionScore[3] + 3 * dimensionScore[9] + 4 * dimensionScore[12] + 4 * dimensionScore[13]) - (3 * dimensionScore[0] + 2 * dimensionScore[5])) / 10;
                }
                //计算每道题的得分
                for (String question : questionNo) {
                    if (question.equals(jsonObject1.getString("questionNo"))) {
                        //获取所有答案中本道题目的答案list数组
                        List<AnswerEntity> nowQuestionAnswerList = answerEntities.stream().filter(answerEntity -> answerEntity.getQuestionNo().equals(question)).collect(Collectors.toList());
                        //本题目的正确答案与自己的选项进行对比，正确的话相应分数进行相加
                        for (AnswerEntity answerEntity : nowQuestionAnswerList) {
                            if (answerEntity.getName().equals(jsonObject1.getString("checkItems"))) {
                                dimensionScore[y] += Double.parseDouble(answerEntity.getScore());
                                dimensionScoreMap.put(dimensionEntity.getId(),dimensionScoreMap.get(dimensionEntity.getId())==null?Double.parseDouble(answerEntity.getScore()):(dimensionScoreMap.get(dimensionEntity.getId()) +Double.parseDouble(answerEntity.getScore())));
                                break;
                            }
                        }
                    }
                }
            }
        }
        if(dimensionScoreMap.size()>0){
            resultJson.put("dimensionScoreMap",dimensionScoreMap);
        }
        //将量表总维度根据维度名称进行分组
        Map<String, List<ScaleMarksEntity>> scaleMarksMap = scaleMarksEntities.stream().collect(Collectors.groupingBy(ScaleMarksEntity::getName));
        //返回值以及存数据库格式
        List<NewResultDto> newResultDtos = new ArrayList<>();
        resultMap0.put("总分", df.format(score));
        resultJson.put("总分", df.format(score));
        BigDecimal scoreDecimal = new BigDecimal(df.format(score));
        //如果没有总分这一栏，需要手动赋值返回
        List<ScaleMarksEntity> totalScore = scaleMarksMap.get("总分");
        if (totalScore == null) {
            newResultDtos.add(new NewResultDto("总分", df.format(score), "无", "无",
                    "无", "无", "无", "无", "是"));
        } else {
            for (ScaleMarksEntity tempTotalScore : totalScore) {
                BigDecimal scoreStart = new BigDecimal(tempTotalScore.getScoreStart());
                BigDecimal scoreEnd = new BigDecimal(tempTotalScore.getScoreEnd());
                if (scoreDecimal.compareTo(scoreEnd) <= 0 && scoreDecimal.compareTo(scoreStart) >= 0) {
                    newResultDtos.add(new NewResultDto("总分", df.format(score), tempTotalScore.getSymptom(), tempTotalScore.getImprovementSuggestions(),
                            tempTotalScore.getFlag(), tempTotalScore.getReference(), tempTotalScore.getNameExplain(), tempTotalScore.getSuggestion(), tempTotalScore.getIsTotalScoreExplain()));
                }
            }
        }


        JSONObject iconInfo = new JSONObject();
        //雷达图需要的维度以及最大值
        List<Map<String, Object>> indicator = new LinkedList<>();
        //雷达图所需要的常模参考值
        LinkedList<String> reference = new LinkedList<>();
        //雷达图需要的分数
        LinkedList<String> scoreList = new LinkedList<>();
        for (int y = 0; y < dimensionEntities.size(); y++) {
            Map<String, Object> indicatorMap = new HashMap<>();
            DimensionEntity dimensionEntity = dimensionEntities.get(y);
            NewResultDto newResultDto1 = new NewResultDto();
            //存放该维度总分
            resultMap0.put(dimensionEntity.getName() + "得分", df.format(dimensionScore[y]));
            resultJson.put(dimensionEntity.getName() + "得分", df.format(dimensionScore[y]));
            newResultDto1.setScore(df.format(dimensionScore[y]));
            newResultDtos.add(newResultDto1);
            BigDecimal dimensionScoreDecimal = new BigDecimal(df.format(dimensionScore[y]));
            //获取当前维度的评分规则
            List<ScaleMarksEntity> scaleMarksEntities1 = scaleMarksMap.get(dimensionEntity.getName());
            if (scaleMarksEntities1 != null) {
                //循环遍历判断得分在哪个区间
                for (ScaleMarksEntity scaleMarksEntity : scaleMarksEntities1) {
                    BigDecimal decimalScoreEnd = new BigDecimal(scaleMarksEntity.getScoreEnd());
                    BigDecimal decimalScoreStart = new BigDecimal(scaleMarksEntity.getScoreStart());
                    if (dimensionScoreDecimal.compareTo(decimalScoreEnd) <= 0 && dimensionScoreDecimal.compareTo(decimalScoreStart) >= 0) {
                        putDimResult(resultMap0, resultJson, dimensionEntity, newResultDto1, scaleMarksEntity);
                        //需要进行图表展示的维度放入map
                        if ("1".equals(dimensionEntity.getIsIconFlag())) {
                            indicatorMap.put("text", dimensionEntity.getName());
                            //将当前维度按照分数的结尾值来进行排序scaleMarksEntities1
                            List<ScaleMarksEntity> collect = scaleMarksEntities1.stream().sorted(Comparator.comparing(ScaleMarksEntity::getScoreEnd, Comparator.comparingInt(Integer::parseInt))
                                    .reversed()).collect(Collectors.toList());
                            //排序完成后第一个的scoreEnd最大，也就是该维度最大的
                            indicatorMap.put("max", collect.get(0).getScoreEnd());
                            indicator.add(indicatorMap);
                            if ("无".equals(scaleMarksEntity.getReference()) || "无".equals(scaleMarksEntity.getStandardDeviation())) {
                                //常模参考值设为0
                                reference.add("0");
                            } else {
                                reference.add(scaleMarksEntity.getReference());
                            }
                            scoreList.add(String.valueOf(dimensionScore[y]));
                        }
                    }
                }
            } else {
                //如果分数规则表中无维度，而维度表中有相应维度，则只显示维度分数
                newResultDto1.setFlag("无");
                newResultDto1.setImprovementSuggestions("无");
                newResultDto1.setName(dimensionEntity.getName());
                newResultDto1.setReference("无");
                newResultDto1.setNameExplain("无");
                newResultDto1.setSuggestion("无");
                newResultDto1.setIsTotalScoreExplain("否");
                newResultDto1.setSymptom("无");
            }
        }
        //需要图表展示的
        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;
    }*/

    public  JSONObject scaleCalculate() throws Exception {
        //总分
        double score = 0;
        DecimalFormat df = new DecimalFormat("######0.00");

        Map<String, String> resultMap0 = new LinkedHashMap<>();
        List<Map<String, String>> resultMapList = new ArrayList<>();
        //新版本数据格式
        Map<String, Object> newResult = new LinkedHashMap<>();

        //获取答案列表
        List<AnswerEntity> answerEntities = (List<AnswerEntity>) resultJson.get("answerEntities");
        //获取评分规则列表
        List<ScaleMarksEntity> scaleMarksEntities = (List<ScaleMarksEntity>) resultJson.get("scaleMarksEntities");
        //获取维度信息列表
        List<DimensionEntity> dimensionEntities = (List<DimensionEntity>) resultJson.get("dimensionEntities");
        //计算每个维度得分dimensionEntities
        double[] dimensionScore = new double[dimensionEntities.size()];
        Map<String,Double> dimensionScoreMap = new HashMap<>();
        //jsonArray:用户自己选择的题目选项
        for (int i = 0; i < jsonArray.size(); i++) {
            JSONObject jsonObject1 = jsonArray.getJSONObject(i);
            //计算总分
            for (AnswerEntity answerEntity : answerEntities) {
                if (answerEntity.getQuestionNo().equals(jsonObject1.getString("questionNo"))) {
                    if (answerEntity.getName().replaceAll("\\s", "").equals(jsonObject1.getString("checkItems").replaceAll("\\s", ""))) {
                        score += Double.parseDouble(answerEntity.getScore());
                        break;
                    }
                }
            }
            //计算维度分数
            for (int y = 0; y < dimensionEntities.size(); y++) {
                //获取维度信息
                DimensionEntity dimensionEntity = dimensionEntities.get(y);
                //获取该维度下有哪些选项
                String questionNos = dimensionEntity.getQuestionNo();
                //删除空白字符后得到进行划分得到选择题号
                String[] questionNo = questionNos.replaceAll("\\s", "").split("；");
                //计算每道题的得分
                for (String question : questionNo) {
                    if (question.equals(jsonObject1.getString("questionNo"))) {
                        //获取所有答案中本道题目的答案list数组
                        List<AnswerEntity> nowQuestionAnswerList = answerEntities.stream().filter(answerEntity -> answerEntity.getQuestionNo().equals(question)).collect(Collectors.toList());
                        //本题目的正确答案与自己的选项进行对比，正确的话相应分数进行相加
                        for (AnswerEntity answerEntity : nowQuestionAnswerList) {
                            if (answerEntity.getName().replaceAll("\\s", "").equals(jsonObject1.getString("checkItems").replaceAll("\\s", ""))) {
                                dimensionScoreMap.put(dimensionEntity.getId(),dimensionScoreMap.get(dimensionEntity.getId())==null?Double.parseDouble(answerEntity.getScore()):(dimensionScoreMap.get(dimensionEntity.getId()) +Double.parseDouble(answerEntity.getScore())));
                                dimensionScore[y] += Double.parseDouble(answerEntity.getScore());
                                break;
                            }
                        }
                    }
                }
            }
            resultJson.put("dimensionScoreMap",dimensionScoreMap);
        }
        //计算标准分
        for (int y = 0; y < dimensionEntities.size(); y++) {
            for (int i = 0; i < scaleMarksEntities.size(); i++) {
                if (dimensionEntities.get(y).getName().equals(scaleMarksEntities.get(i).getName())) {
                    String[] splits = scaleMarksEntities.get(i).getReference().split("±");
                    double a = Double.valueOf(splits[0]);
                    double b = Double.valueOf(splits[1]);
                    dimensionScore[y] = Math.floor(((dimensionScore[y] - a)/b)*1.5 + 5.5);
                    break;
                }
            }
        }

        //返回值以及存数据库格式
        List<NewResultDto> newResultDtos = new ArrayList<>();

        //判断最高分
        double[] dimensionScores = new double[dimensionScore.length];
        for (int y = 0; y < dimensionScore.length; y++) {
            dimensionScores[y] = dimensionScore[y];
        }
        Arrays.sort(dimensionScores);
        JSONObject jsonObject = new JSONObject(true);
        for (int y = 0; y < dimensionScore.length; y++) {
            if (dimensionScore[y] == dimensionScores[dimensionScores.length-1]){
                jsonObject.put(dimensionEntities.get(y).getName(),dimensionScores[dimensionScores.length-1]);
            }
        }
        Set<String> keys = jsonObject.keySet();
        List<DimensionEntity> dimensionEntitieList = new ArrayList<>();
        int b = 0;
        for (String key : keys) {
            for (DimensionEntity dimensionEntity : dimensionEntities) {
                if (dimensionEntity.getName().equals(key)){
                    dimensionEntitieList.add(dimensionEntity);
                    dimensionScore[b] = jsonObject.getInteger(key);
                    b++;
                }
            }
        }


        //将量表总维度根据维度名称进行分组
        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, dimensionEntitieList, 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);
        }

        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;
    }
}
