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

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.rf.psychological.dao.model.SHAPE2Entity;
import com.rf.psychological.dao.model.WebMemoryEntity;
import com.rf.psychological.file.excel.ExcelClass;
import com.rf.psychological.scale.resultBusiness.scaleResult.BaseScale;
import com.rf.psychological.utils.Constant;
import com.rf.psychological.utils.ExcelUtil;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

/**
 * @author zsy
 * @description:工作记忆能力测试(字母记忆)
 * @date 2021/7/20 15:55
 */
public class MEMORYCognize extends BaseScale {

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

    public  JSONObject scaleCalculate() throws Exception {
        List<Map<String, String>> resultMapList = new ArrayList<>();
        JSONObject jsonObject = resultJson.getJSONObject("jsonObject");
        String fileName = resultJson.getString("fileName");
        String name;

        JSONObject resultDBJson = new JSONObject(true);

        List<WebMemoryEntity> dataList = new ArrayList<>();
        JSONObject jsonObject0 = jsonObject.getJSONObject("data");
        int[] rightNum0 = {0, 0, 0, 0, 0, 0};
        int[] rightTime0 = {0, 0, 0, 0, 0, 0};
        //int [] countTemp0={0,0,0,0,0,0};
        int[] rightNum1 = {0, 0, 0, 0, 0, 0};
        int[] rightTime1 = {0, 0, 0, 0, 0, 0};
        //int [] countTemp1={0,0,0,0,0,0};
        int[] rightNum2 = {0, 0, 0, 0, 0, 0};
        int[] rightTime2 = {0, 0, 0, 0, 0, 0};
        //int [] countTemp2={0,0,0,0,0,0};
        JSONArray back0 = jsonObject0.getJSONArray("back0");
        for (int i = 0; i < back0.size(); i++) {
            //0back 平均响应时长只计算需要响应的，如果需要响应但为响应，按最长时间间隔计算  正确率计算需要响应和不需要响应的
            JSONArray back0a = back0.getJSONArray(i);
            for (int y = 0; y < back0a.size(); y++) {
                JSONObject back0b = back0a.getJSONObject(y);
                WebMemoryEntity webMemoryEntity = new WebMemoryEntity();
                webMemoryEntity = back0b.toJavaObject(WebMemoryEntity.class);
                webMemoryEntity.setDiffLevel("0back");
                dataList.add(webMemoryEntity);
                //需要响应且正确响应，响应正确次数+1 ，响应时间累加
                if (back0b.getString("ifNeedClick").equals("true") && back0b.getString("ifUserClick").equals("true")) {
                    rightNum0[i] += 1;
                    rightTime0[i] += back0b.getInteger("userResponseTime");
                }
                // ，字母展示时间+刺激时间=500+1500=2000ms
                if (back0b.getString("ifNeedClick").equals("true") && back0b.getString("ifUserClick").equals("false")) {
                    //rightTime0[i] += 2000;
                }
                //不需要响应且未响应，响应正确次数+1，但响应时间不累加
                if (back0b.getString("ifNeedClick").equals("false") && back0b.getString("ifUserClick").equals("false")) {
                    rightNum0[i] += 1;
                }
            }
        }
        JSONArray back1 = jsonObject0.getJSONArray("back1");
        for (int i = 0; i < back1.size(); i++) {
            JSONArray back1a = back1.getJSONArray(i);
            for (int y = 0; y < back1a.size(); y++) {
                JSONObject back1b = back1a.getJSONObject(y);
                WebMemoryEntity webMemoryEntity = new WebMemoryEntity();
                webMemoryEntity = back1b.toJavaObject(WebMemoryEntity.class);
                webMemoryEntity.setDiffLevel("1back");
                dataList.add(webMemoryEntity);
                //dataList.add(back1b.toJavaObject(WebMemoryEntity.class));
                if (back1b.getString("ifNeedClick").equals("true") && back1b.getString("ifUserClick").equals("true")) {
                    rightNum1[i] += 1;
                    rightTime1[i] += back1b.getInteger("userResponseTime");
                }
                if (back1b.getString("ifNeedClick").equals("true") && back1b.getString("ifUserClick").equals("false")) {
                    //rightTime1[i] += 2000;
                }
                if (back1b.getString("ifNeedClick").equals("false") && back1b.getString("ifUserClick").equals("false")) {
                    rightNum1[i] += 1;
                }
            }

        }
        JSONArray back2 = jsonObject0.getJSONArray("back2");
        for (int i = 0; i < back2.size(); i++) {
            JSONArray back2a = back2.getJSONArray(i);
            for (int y = 0; y < back2a.size(); y++) {
                JSONObject back2b = back2a.getJSONObject(y);
                WebMemoryEntity webMemoryEntity = new WebMemoryEntity();
                webMemoryEntity = back2b.toJavaObject(WebMemoryEntity.class);
                webMemoryEntity.setDiffLevel("2back");
                dataList.add(webMemoryEntity);
                //dataList.add(back2b.toJavaObject(WebMemoryEntity.class));
                if (back2b.getString("ifNeedClick").equals("true") && back2b.getString("ifUserClick").equals("true")) {
                    rightNum2[i] += 1;
                    rightTime2[i] += back2b.getInteger("userResponseTime");
                }
                if (back2b.getString("ifNeedClick").equals("true") && back2b.getString("ifUserClick").equals("false")) {
                    //rightTime2[i] += 2000;
                }
                if (back2b.getString("ifNeedClick").equals("false") && back2b.getString("ifUserClick").equals("false")) {
                    rightNum2[i] += 1;
                }
            }
        }

        resultDBJson.put("versionNo",Constant.COGNITION_RESULT_VERSION);
        List list = new ArrayList();
        JSONObject dimension0 = new JSONObject(true);
        dimension0.put("name","0back");


        resultMapList = new ArrayList<>();
        Map<String, String> resultMap0 = new LinkedHashMap<>();
        double back0RightTime = 0;
        double back0Precision = 0;
        for (int i = 0; i < back0.size(); i++) {
            //平均响应时长=所有需要响应的响应时间之和/需要响应的次数
            back0RightTime += rightNum0[i] == 0 ? 0 : new BigDecimal((double) (rightTime0[i]) / (double) (Constant.CHAR_COUNT / 2)).setScale(2, RoundingMode.HALF_UP).doubleValue();
            //响应正确率=(需要响应且正确响应次数+不需要响应且未响应次数)/所有响应总数
            back0Precision += new BigDecimal((double) (rightNum0[i] * 100) / (double) (Constant.CHAR_COUNT)).setScale(2, RoundingMode.HALF_UP).doubleValue();

            //平均响应时长=所有需要响应的响应时间之和/需要响应的次数
            resultMap0.put("0-back第"+(i+1)+"组块平均响应时长(ms)",String.valueOf(rightNum0[i]==0?0:new BigDecimal((double)(rightTime0[i])/(double)(Constant.CHAR_COUNT/2)).setScale(2, RoundingMode.HALF_UP).doubleValue()));
            resultDBJson.put("0-back第"+(i+1)+"组块平均响应时长(ms)",String.valueOf(rightNum0[i]==0?0:new BigDecimal((double)(rightTime0[i])/(double)(Constant.CHAR_COUNT/2)).setScale(2, RoundingMode.HALF_UP).doubleValue()));
            //响应正确率=(需要响应且正确响应次数+不需要响应且未响应次数)/所有响应总数
            resultMap0.put("0-back第"+(i+1)+"组块响应正确率(%)",String.valueOf(new BigDecimal((double)(rightNum0[i]*100)/(double)(Constant.CHAR_COUNT)).setScale(2, RoundingMode.HALF_UP).doubleValue()));
            resultDBJson.put("0-back第"+(i+1)+"组块响应正确率(%)",String.valueOf(new BigDecimal((double)(rightNum0[i]*100)/(double)(Constant.CHAR_COUNT)).setScale(2, RoundingMode.HALF_UP).doubleValue()));

        }
        DecimalFormat df = new DecimalFormat("######0.00");
        //0-back平均响应时长(ms)
        back0RightTime = Double.parseDouble(df.format(back0RightTime / back0.size()));
        //0-back正确率
        back0Precision = Double.parseDouble(df.format(back0Precision / back0.size()));
        resultMap0.put("0-back平均响应时长(ms)", String.valueOf(back0RightTime));
        resultDBJson.put("0-back平均响应时长(ms)", String.valueOf(back0RightTime));
        resultMap0.put("0-back正确率", back0Precision + "%");
        resultDBJson.put("0-back正确率", back0Precision + "%");
        resultMapList.add(resultMap0);


        dimension0.put("score",back0Precision);
        String desc = null;
        if(back0Precision>80 ){
            desc = "优秀等级：您具有很好的工作记忆能力，您的工作记忆系统容量很大，相比旁人，您能够储存和处理很多的即时信息，比如能记住很长的号码串且记住的时间很长，不容易遗忘。但这并不代表您有过目不忘的记忆能力，不能有这个误区，只是比旁人更能记住更复杂的东西且更不容易遗忘。\n";
            resultMap0.put("0-back结论", "优秀等级：您具有很好的工作记忆能力，您的工作记忆系统容量很大，相比旁人，您能够储存和处理很多的即时信息，比如能记住很长的号码串且记住的时间很长，不容易遗忘。但这并不代表您有过目不忘的记忆能力，不能有这个误区，只是比旁人更能记住更复杂的东西且更不容易遗忘。\n");
            resultDBJson.put("0-back结论", "优秀等级：您具有很好的工作记忆能力，您的工作记忆系统容量很大，相比旁人，您能够储存和处理很多的即时信息，比如能记住很长的号码串且记住的时间很长，不容易遗忘。但这并不代表您有过目不忘的记忆能力，不能有这个误区，只是比旁人更能记住更复杂的东西且更不容易遗忘。\n");
        }else if(back0Precision>60 && back0Precision<=80){
            desc = "一般等级：您具有一般水平的工作记忆能力，您的工作记忆系统容量并不很大但也不很小，您能储存和处理的即时信息不会太多也不会太少，比如记号码串，您只能记住5~9个数字的号码串，且在一分钟左右会忘记。\n";
            resultMap0.put("0-back结论", "一般等级：您具有一般水平的工作记忆能力，您的工作记忆系统容量并不很大但也不很小，您能储存和处理的即时信息不会太多也不会太少，比如记号码串，您只能记住5~9个数字的号码串，且在一分钟左右会忘记。\n");
            resultDBJson.put("0-back结论", "一般等级：您具有一般水平的工作记忆能力，您的工作记忆系统容量并不很大但也不很小，您能储存和处理的即时信息不会太多也不会太少，比如记号码串，您只能记住5~9个数字的号码串，且在一分钟左右会忘记。\n");
        }else if(back0Precision<=60){
            desc = "较差等级：您具有较差的工作记忆能力，您的工作记忆系统容量较小，相比旁人，您能够储存和处理的即时信息更少，更难记住东西且往往过目就忘，记住相同难度的内容要花费更多的时间和要更多复述。因此鼓励您后续加强记忆训练，增强记忆能力，掌握对记忆材料深度加工的技巧，掌握记忆材料呈现规律，从而更好记住。\n";
            resultMap0.put("0-back结论", "较差等级：您具有较差的工作记忆能力，您的工作记忆系统容量较小，相比旁人，您能够储存和处理的即时信息更少，更难记住东西且往往过目就忘，记住相同难度的内容要花费更多的时间和要更多复述。因此鼓励您后续加强记忆训练，增强记忆能力，掌握对记忆材料深度加工的技巧，掌握记忆材料呈现规律，从而更好记住。\n");
            resultDBJson.put("0-back结论", "较差等级：您具有较差的工作记忆能力，您的工作记忆系统容量较小，相比旁人，您能够储存和处理的即时信息更少，更难记住东西且往往过目就忘，记住相同难度的内容要花费更多的时间和要更多复述。因此鼓励您后续加强记忆训练，增强记忆能力，掌握对记忆材料深度加工的技巧，掌握记忆材料呈现规律，从而更好记住。\n");
        }
        dimension0.put("Describe",desc);
        dimension0.put("maximum",100);
        dimension0.put("groupName","第一组");

        JSONObject dimension1 = new JSONObject(true);
        dimension1.put("name","1back");

        Map<String, String> resultMap1 = new LinkedHashMap<>();
        double back1RightTime = 0;
        double back1Precision = 0;
        for (int i = 0; i < back1.size(); i++) {
            back1RightTime += rightNum1[i] == 0 ? 0 : new BigDecimal((double) (rightTime1[i]) / (double) (Constant.CHAR_COUNT / 2)).setScale(2, RoundingMode.HALF_UP).doubleValue();
            back1Precision += new BigDecimal((double) (rightNum1[i] * 100) / (double) (Constant.CHAR_COUNT)).setScale(2, RoundingMode.HALF_UP).doubleValue();
            //平均响应时长=所有需要响应的响应时间之和/需要响应的次数
            resultMap1.put("1-back第"+(i+1)+"组块平均响应时长(ms)",String.valueOf(rightNum0[i]==0?0:new BigDecimal((double)(rightTime0[i])/(double)(Constant.CHAR_COUNT/2)).setScale(2, RoundingMode.HALF_UP).doubleValue()));
            resultDBJson.put("1-back第"+(i+1)+"组块平均响应时长(ms)",String.valueOf(rightNum0[i]==0?0:new BigDecimal((double)(rightTime0[i])/(double)(Constant.CHAR_COUNT/2)).setScale(2, RoundingMode.HALF_UP).doubleValue()));
            //响应正确率=(需要响应且正确响应次数+不需要响应且未响应次数)/所有响应总数
            resultMap1.put("1-back第"+(i+1)+"组块响应正确率(%)",String.valueOf(new BigDecimal((double)(rightNum0[i]*100)/(double)(Constant.CHAR_COUNT)).setScale(2, RoundingMode.HALF_UP).doubleValue()));
            resultDBJson.put("1-back第"+(i+1)+"组块响应正确率(%)",String.valueOf(new BigDecimal((double)(rightNum0[i]*100)/(double)(Constant.CHAR_COUNT)).setScale(2, RoundingMode.HALF_UP).doubleValue()));

        }
        //1-back平均响应时长(ms)
        back1RightTime = Double.parseDouble(df.format(back1RightTime / back1.size()));
        //1-back正确率
        back1Precision = Double.parseDouble(df.format(back1Precision / back1.size()));
        resultMap1.put("1-back平均响应时长(ms)", String.valueOf(back1RightTime));
        resultDBJson.put("1-back平均响应时长(ms)", String.valueOf(back1RightTime));
        resultMap1.put("1-back正确率", back1Precision + "%");
        resultDBJson.put("1-back正确率", back1Precision + "%");
        resultMapList.add(resultMap1);

        dimension1.put("score",back1Precision);
        String desc2 = null;
        if(back1Precision>80 ){
            desc2 = "优秀等级：您具有很好的工作记忆能力，您的工作记忆系统容量很大，相比旁人，您能够储存和处理很多的即时信息，比如能记住很长的号码串且记住的时间很长，不容易遗忘。但这并不代表您有过目不忘的记忆能力，不能有这个误区，只是比旁人更能记住更复杂的东西且更不容易遗忘。\n";
            resultMap1.put("1-back结论", "优秀等级：您具有很好的工作记忆能力，您的工作记忆系统容量很大，相比旁人，您能够储存和处理很多的即时信息，比如能记住很长的号码串且记住的时间很长，不容易遗忘。但这并不代表您有过目不忘的记忆能力，不能有这个误区，只是比旁人更能记住更复杂的东西且更不容易遗忘。\n");
            resultDBJson.put("1-back结论", "优秀等级：您具有很好的工作记忆能力，您的工作记忆系统容量很大，相比旁人，您能够储存和处理很多的即时信息，比如能记住很长的号码串且记住的时间很长，不容易遗忘。但这并不代表您有过目不忘的记忆能力，不能有这个误区，只是比旁人更能记住更复杂的东西且更不容易遗忘。\n");
        }else if(back1Precision>60 && back1Precision<=80){
            desc2 = "一般等级：您具有一般水平的工作记忆能力，您的工作记忆系统容量并不很大但也不很小，您能储存和处理的即时信息不会太多也不会太少，比如记号码串，您只能记住5~9个数字的号码串，且在一分钟左右会忘记。\n";
            resultMap1.put("1-back结论", "一般等级：您具有一般水平的工作记忆能力，您的工作记忆系统容量并不很大但也不很小，您能储存和处理的即时信息不会太多也不会太少，比如记号码串，您只能记住5~9个数字的号码串，且在一分钟左右会忘记。\n");
            resultDBJson.put("1-back结论", "一般等级：您具有一般水平的工作记忆能力，您的工作记忆系统容量并不很大但也不很小，您能储存和处理的即时信息不会太多也不会太少，比如记号码串，您只能记住5~9个数字的号码串，且在一分钟左右会忘记。\n");
        }else if(back1Precision<=60){
            desc2 = "较差等级：您具有较差的工作记忆能力，您的工作记忆系统容量较小，相比旁人，您能够储存和处理的即时信息更少，更难记住东西且往往过目就忘，记住相同难度的内容要花费更多的时间和要更多复述。因此鼓励您后续加强记忆训练，增强记忆能力，掌握对记忆材料深度加工的技巧，掌握记忆材料呈现规律，从而更好记住。\n";
            resultMap1.put("1-back结论", "较差等级：您具有较差的工作记忆能力，您的工作记忆系统容量较小，相比旁人，您能够储存和处理的即时信息更少，更难记住东西且往往过目就忘，记住相同难度的内容要花费更多的时间和要更多复述。因此鼓励您后续加强记忆训练，增强记忆能力，掌握对记忆材料深度加工的技巧，掌握记忆材料呈现规律，从而更好记住。\n");
            resultDBJson.put("1-back结论", "较差等级：您具有较差的工作记忆能力，您的工作记忆系统容量较小，相比旁人，您能够储存和处理的即时信息更少，更难记住东西且往往过目就忘，记住相同难度的内容要花费更多的时间和要更多复述。因此鼓励您后续加强记忆训练，增强记忆能力，掌握对记忆材料深度加工的技巧，掌握记忆材料呈现规律，从而更好记住。\n");
        }
        dimension1.put("Describe",desc2);
        dimension1.put("maximum",100);
        dimension1.put("groupName","第二组");


        JSONObject dimension2= new JSONObject(true);
        dimension2.put("name","2back");
        Map<String, String> resultMap2 = new LinkedHashMap<>();
        double back2RightTime = 0;
        double back2Precision = 0;
        for (int i = 0; i < back2.size(); i++) {
            back2RightTime += rightNum2[i] == 0 ? 0 : new BigDecimal((double) (rightTime2[i]) / (double) (Constant.CHAR_COUNT / 2)).setScale(2, RoundingMode.HALF_UP).doubleValue();
            back2Precision += new BigDecimal((double) (rightNum2[i] * 100) / (double) (Constant.CHAR_COUNT)).setScale(2, RoundingMode.HALF_UP).doubleValue();
            resultMap2.put("2-back第"+(i+1)+"组块平均响应时长(ms)",String.valueOf(rightNum2[i]==0?0:new BigDecimal((double)(rightTime2[i])/(double)(Constant.CHAR_COUNT/2)).setScale(2, RoundingMode.HALF_UP).doubleValue()));
            resultDBJson.put("2-back第"+(i+1)+"组块平均响应时长(ms)",String.valueOf(rightNum2[i]==0?0:new BigDecimal((double)(rightTime2[i])/(double)(Constant.CHAR_COUNT/2)).setScale(2, RoundingMode.HALF_UP).doubleValue()));
            resultMap2.put("2-back第"+(i+1)+"组块响应正确率(%)",String.valueOf(new BigDecimal((double)(rightNum2[i]*100)/(double)(Constant.CHAR_COUNT)).setScale(2, RoundingMode.HALF_UP).doubleValue()));
            resultDBJson.put("2-back第"+(i+1)+"组块响应正确率(%)",String.valueOf(new BigDecimal((double)(rightNum2[i]*100)/(double)(Constant.CHAR_COUNT)).setScale(2, RoundingMode.HALF_UP).doubleValue()));

        }

        //2-back平均响应时长(ms)
        back2RightTime = Double.parseDouble(df.format(back2RightTime / back2.size()));
        //2-back正确率
        back2Precision = Double.parseDouble(df.format(back2Precision / back2.size()));
        resultMap2.put("2-back平均响应时长(ms)", String.valueOf(back2RightTime));
        resultDBJson.put("2-back平均响应时长(ms)", String.valueOf(back2RightTime));
        resultMap2.put("2-back正确率", back2Precision + "%");
        resultDBJson.put("2-back正确率", back2Precision + "%");
        resultMapList.add(resultMap2);

        dimension2.put("score",back2Precision);
        String desc3 = null;
        if(back2Precision>80 ){
            desc3 = "优秀等级：您具有很好的工作记忆能力，您的工作记忆系统容量很大，相比旁人，您能够储存和处理很多的即时信息，比如能记住很长的号码串且记住的时间很长，不容易遗忘。但这并不代表您有过目不忘的记忆能力，不能有这个误区，只是比旁人更能记住更复杂的东西且更不容易遗忘。\n";
            resultMap2.put("2-back结论", "优秀等级：您具有很好的工作记忆能力，您的工作记忆系统容量很大，相比旁人，您能够储存和处理很多的即时信息，比如能记住很长的号码串且记住的时间很长，不容易遗忘。但这并不代表您有过目不忘的记忆能力，不能有这个误区，只是比旁人更能记住更复杂的东西且更不容易遗忘。\n");
            resultDBJson.put("2-back结论", "优秀等级：您具有很好的工作记忆能力，您的工作记忆系统容量很大，相比旁人，您能够储存和处理很多的即时信息，比如能记住很长的号码串且记住的时间很长，不容易遗忘。但这并不代表您有过目不忘的记忆能力，不能有这个误区，只是比旁人更能记住更复杂的东西且更不容易遗忘。\n");
        }else if(back2Precision>60 && back2Precision<=80){
            desc3 = "一般等级：您具有一般水平的工作记忆能力，您的工作记忆系统容量并不很大但也不很小，您能储存和处理的即时信息不会太多也不会太少，比如记号码串，您只能记住5~9个数字的号码串，且在一分钟左右会忘记。\n";
            resultMap2.put("2-back结论", "一般等级：您具有一般水平的工作记忆能力，您的工作记忆系统容量并不很大但也不很小，您能储存和处理的即时信息不会太多也不会太少，比如记号码串，您只能记住5~9个数字的号码串，且在一分钟左右会忘记。\n");
            resultDBJson.put("2-back结论", "一般等级：您具有一般水平的工作记忆能力，您的工作记忆系统容量并不很大但也不很小，您能储存和处理的即时信息不会太多也不会太少，比如记号码串，您只能记住5~9个数字的号码串，且在一分钟左右会忘记。\n");
        }else if(back2Precision<=60){
            desc3 = "较差等级：您具有较差的工作记忆能力，您的工作记忆系统容量较小，相比旁人，您能够储存和处理的即时信息更少，更难记住东西且往往过目就忘，记住相同难度的内容要花费更多的时间和要更多复述。因此鼓励您后续加强记忆训练，增强记忆能力，掌握对记忆材料深度加工的技巧，掌握记忆材料呈现规律，从而更好记住。\n";
            resultMap2.put("2-back结论", "较差等级：您具有较差的工作记忆能力，您的工作记忆系统容量较小，相比旁人，您能够储存和处理的即时信息更少，更难记住东西且往往过目就忘，记住相同难度的内容要花费更多的时间和要更多复述。因此鼓励您后续加强记忆训练，增强记忆能力，掌握对记忆材料深度加工的技巧，掌握记忆材料呈现规律，从而更好记住。\n");
            resultDBJson.put("2-back结论", "较差等级：您具有较差的工作记忆能力，您的工作记忆系统容量较小，相比旁人，您能够储存和处理的即时信息更少，更难记住东西且往往过目就忘，记住相同难度的内容要花费更多的时间和要更多复述。因此鼓励您后续加强记忆训练，增强记忆能力，掌握对记忆材料深度加工的技巧，掌握记忆材料呈现规律，从而更好记住。\n");
        }
        dimension2.put("Describe",desc3);
        dimension2.put("maximum",100);
        dimension2.put("groupName","第三组");
        list.add(dimension0);
        list.add(dimension1);
        list.add(dimension2);
        resultDBJson.put("dimensions",list);
        //表格数据
        JSONArray tableModule = new JSONArray();
        JSONObject table1 = new JSONObject(true);
        JSONArray columnName = new JSONArray();
        columnName.add("指标名称");
        columnName.add("指标值");
        JSONArray columnValue = new JSONArray();
        columnValue.add("0back正确率;0back平均正确反应时;1back正确率;1back平均正确反应时;2back正确率;2back平均正确反应时");
        columnValue.add(back0Precision + "%" +";"+back0RightTime +";"+back1Precision + "%" +";"+back1RightTime +";" + back2Precision + "%" +";"+back2RightTime);
        table1.put("tableName","table1");
        table1.put("columnName",columnName);
        table1.put("columnValue",columnValue);
        tableModule.add(table1);
        resultDBJson.put("tableModule", tableModule);
        JSONObject ifShow = new JSONObject(true);
        ifShow.put("totalScore",false);
        ifShow.put("dimensions",true);
        ifShow.put("note",false);
        ifShow.put("radar",false);
        ifShow.put("table",true);
        resultDBJson.put("ifShow",ifShow);

        Map<String, String> resultMap = new LinkedHashMap<>();
        resultMap.put("0back正确率", back0Precision + "%");
        resultDBJson.put("0back正确率", back0Precision + "%");
        resultMap.put("0back平均正确反应时", String.valueOf(back0RightTime));
        resultDBJson.put("0back平均正确反应时", back0RightTime);
        resultMap.put("1back正确率", back1Precision + "%");
        resultDBJson.put("1back正确率", back1Precision + "%");
        resultMap.put("1back平均正确反应时", String.valueOf(back1RightTime));
        resultDBJson.put("1back平均正确反应时", back1RightTime);
        resultMap.put("2back正确率", String.valueOf(back2Precision));
        resultDBJson.put("2back正确率", back2Precision);
        resultMap.put("2back平均正确反应时", String.valueOf(back2RightTime));
        resultDBJson.put("2back平均正确反应时", back2RightTime);

        fileName = fileName + "-" + Constant.SHEET_NAME_MEMORY + ".xlsx";
        name = Constant.SHEET_NAME_MEMORY;
        String datas = jsonObject0.toString();
        ExcelUtil.createExcelFile(WebMemoryEntity.class, dataList, resultMapList, new ExcelClass().contentExcel(Constant.QUEST_TYPE_MEMORY), fileName, Constant.SHEET_NAME_MEMORY);

        JSONObject returnJson = new JSONObject(true);
        returnJson.put("fileName",fileName);
        returnJson.put("name", name);
        returnJson.put("resultJson",resultDBJson);
        returnJson.put("datas",datas);

        return returnJson;
    }


}
