package com.mindskip.xzs.service.impl;

import cn.hutool.core.lang.Dict;
import com.mindskip.xzs.domain.*;
import com.mindskip.xzs.domain.enums.QuestionTypeEnum;
import com.mindskip.xzs.domain.enums.RoleEnum;
import com.mindskip.xzs.domain.enums.UserStatusEnum;
import com.mindskip.xzs.domain.other.QuestionImportCellIndex;
import com.mindskip.xzs.repository.ClassesMapper;
import com.mindskip.xzs.repository.ClassesUserMapper;
import com.mindskip.xzs.service.*;
import com.mindskip.xzs.utility.ExamUtil;
import com.mindskip.xzs.viewmodel.admin.question.QuestionEditItemVM;
import com.mindskip.xzs.viewmodel.admin.question.QuestionEditRequestVM;
import lombok.AllArgsConstructor;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.xssf.usermodel.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import java.io.*;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

@Service
@AllArgsConstructor
public class ExcelImportImportServiceImpl implements ExcelImportService {

    private final ClassesService classesService;
    private final QuestionService questionService;
    private final SubjectService subjectService;
    private final UserService userService;
    private final KnowledgeService knowledgeService;
    private final AuthenticationService authenticationService;
    private final ClassesMapper classesMapper;
    private final ClassesUserMapper classesUserMapper;

    private final DepartmentService departmentService;

    private static final Logger logger = LoggerFactory.getLogger(ExcelImportImportServiceImpl.class);

    @Override
    public void teacherQuestionImport(InputStream inputStream, String outFilePath, User user) {
        try {
            XSSFWorkbook workbook = new XSSFWorkbook(inputStream);
            XSSFCellStyle cellStyle = workbook.createCellStyle();
            cellStyle.setWrapText(true);
            singleChoice(workbook.getSheetAt(0), cellStyle, user, new QuestionImportCellIndex(null, 0, 1, 16, 2, 11, 12, 13, 14, 3, 11, 15));
            multipleChoice(workbook.getSheetAt(1), cellStyle, user, new QuestionImportCellIndex(null, 0, 1, 16, 2, 11, 12, 13, 14, 3, 11, 15));
            trueFalse(workbook.getSheetAt(2), cellStyle, user, new QuestionImportCellIndex(null, 0, 1, 10, 2, 5, 6, 7, 8, 3, 4, 9));
            gapFilling(workbook.getSheetAt(3), cellStyle, user, new QuestionImportCellIndex(null, 0, 1, 15, 2, 11, 12, 13, null, 2, null, 14));
            shortAnswer(workbook.getSheetAt(4), cellStyle, user, new QuestionImportCellIndex(null, 0, 1, 8, 2, 4, 5, 6, 3, null, null, 7));
            try (FileOutputStream excelOutStream = new FileOutputStream(outFilePath)) {
                workbook.write(excelOutStream);
            }
        } catch (IOException e) {
            logger.error(e.getMessage(), e);
        }
    }

    @Override
    public void adminQuestionImport(InputStream inputStream, String outFilePath, User user) {
        try {
            XSSFWorkbook workbook = new XSSFWorkbook(inputStream);
            XSSFCellStyle cellStyle = workbook.createCellStyle();
            cellStyle.setWrapText(true);
            singleChoice(workbook.getSheetAt(0), cellStyle, user, new QuestionImportCellIndex(0, 1, 2, 17, 3, 12, 13, 14, 15, 4, 12, 16));
            multipleChoice(workbook.getSheetAt(1), cellStyle, user, new QuestionImportCellIndex(0, 1, 2, 17, 3, 12, 13, 14, 15, 4, 12, 16));
            trueFalse(workbook.getSheetAt(2), cellStyle, user, new QuestionImportCellIndex(0, 1, 2, 11, 3, 6, 7, 8, 9, 4, 5, 10));
            gapFilling(workbook.getSheetAt(3), cellStyle, user, new QuestionImportCellIndex(0, 1, 2, 16, 3, 12, 13, 14, null, 3, null, 15));
            shortAnswer(workbook.getSheetAt(4), cellStyle, user, new QuestionImportCellIndex(0, 1, 2, 9, 3, 5, 6, 7, 4, null, null, 8));
            try (FileOutputStream excelOutStream = new FileOutputStream(outFilePath)) {
                workbook.write(excelOutStream);
            }
        } catch (IOException e) {
            logger.error(e.getMessage(), e);
        }
    }

    @Override
    public void studentImport(InputStream inputStream, String outFilePath, User user) {
        try {
            Date now = new Date();
            List<Classes> classesList = classesService.getClassesByCreate(user.getId());
            XSSFWorkbook workbook = new XSSFWorkbook(inputStream);
            XSSFCellStyle cellStyle = workbook.createCellStyle();
            cellStyle.setWrapText(true);
            XSSFSheet sheet = workbook.getSheetAt(0);
            if (null != sheet && sheet.getLastRowNum() >= 1) {
                Integer errorIndex = 4;
                for (int i = 1; i <= sheet.getLastRowNum(); i++) {
                    XSSFRow row = sheet.getRow(i);
                    try {
                        if (null != row.getCell(5)) {  //已经导入过
                            continue;
                        }

                        String userName = stringCheck(row, cellStyle, 0, errorIndex, "用户名不能为空");
                        if (null == userName) {
                            continue;
                        }

                        String passWord = stringCheck(row, cellStyle, 1, errorIndex, "密码不能为空");
                        if (null == passWord) {
                            continue;
                        }

                        String realName = stringCheck(row, cellStyle, 2, errorIndex, "真实姓名不能为空");
                        if (null == realName) {
                            continue;
                        }

                        String classes = stringCheck(row, cellStyle, 3, errorIndex, "班级不能为空");
                        if (null == classes) {
                            continue;
                        }

                        User existUser = userService.getUserByUserName(userName);
                        if (null != existUser) {
                            writeError(row, cellStyle, errorIndex, "用户名已存在");
                            continue;
                        }

                        User newUser = new User();
                        newUser.setUserName(userName);
                        newUser.setRealName(realName);
                        String encodePwd = authenticationService.pwdEncode(passWord);
                        newUser.setUserUuid(UUID.randomUUID().toString());
                        newUser.setPassword(encodePwd);
                        newUser.setRole(RoleEnum.STUDENT.getCode());
                        newUser.setUserLevel(user.getUserLevel());
                        newUser.setStatus(UserStatusEnum.Enable.getCode());
                        newUser.setLastActiveTime(now);
                        newUser.setCreateTime(now);
                        newUser.setDeleted(false);
                        userService.insertByFilter(newUser);
                        row.createCell(5).setCellValue(newUser.getId());

                        for (String classItem : classes.split(" ")) {
                            if (!StringUtils.isBlank(classItem)) {
                                classesList.stream().filter(c -> c.getName().equals(classItem)).findFirst().ifPresent(d -> {
                                    ClassesUser newClassesUser = new ClassesUser();
                                    newClassesUser.setClassesId(d.getId());
                                    newClassesUser.setUserId(newUser.getId());
                                    newClassesUser.setDeleted(false);
                                    newClassesUser.setCreateTime(now);
                                    newClassesUser.setClassesName(d.getName());
                                    classesUserMapper.insertSelective(newClassesUser);
                                    classesMapper.classesNumAdd(d.getId());
                                });
                            }
                        }
                    } catch (Exception ex) {
                        writeError(row, cellStyle, errorIndex, ex.getMessage());
                    }
                }
            }
            try (FileOutputStream excelOutStream = new FileOutputStream(outFilePath)) {
                workbook.write(excelOutStream);
            }
        } catch (IOException e) {
            logger.error(e.getMessage(), e);
        }
    }


    private void singleChoice(XSSFSheet sheet, XSSFCellStyle cellStyle, User user, QuestionImportCellIndex questionImportCellIndex) {
        if (null != sheet && sheet.getLastRowNum() >= 1) {
            Integer errorIndex = questionImportCellIndex.getError();
            for (int i = 1; i <= sheet.getLastRowNum(); i++) {
                XSSFRow row = sheet.getRow(i);
                try {
                    if (null != row.getCell(questionImportCellIndex.getId())) {  //已经导入过
                        continue;
                    }

                    Integer level = user.getUserLevel();
                    if (null != questionImportCellIndex.getLevel()) {
                        level = levelCheck(row, cellStyle, questionImportCellIndex.getLevel(), errorIndex);
                        if (null == level) {
                            continue;
                        }
                    }

                    List<Subject> subjects = subjectService.getSubjectByLevel(level);
                    Subject subject = subjectCheck(row, cellStyle, questionImportCellIndex.getSubject(), subjects, errorIndex);
                    if (null == subject) {
                        continue;
                    }
                    String title = stringCheck(row, cellStyle, questionImportCellIndex.getTitle(), errorIndex, "题干不能为空");
                    if (null == title) {
                        continue;
                    }
                    String analyze = stringCheck(row, cellStyle, questionImportCellIndex.getAnalyze(), errorIndex, "解析不能为空");
                    if (null == analyze) {
                        continue;
                    }
                    String score = stringCheck(row, cellStyle, questionImportCellIndex.getScore(), errorIndex, "分数不能为空");
                    if (null == score) {
                        continue;
                    }
                    String difficult = stringCheck(row, cellStyle, questionImportCellIndex.getDifficult(), errorIndex, "难度不能为空");
                    if (null == difficult) {
                        continue;
                    }
                    String correct = stringCheck(row, cellStyle, questionImportCellIndex.getCorrect(), errorIndex, "答案不能为空");
                    if (null == correct) {
                        continue;
                    }

                    List<Integer> knowledgePointId = new ArrayList<>();
                    XSSFCell knowledgeCell = row.getCell(questionImportCellIndex.getKnowledge());
                    if (null != knowledgeCell) {
                        String stringCell = knowledgeCell.getStringCellValue();
                        if (StringUtils.isNotBlank(stringCell)) {
                            Arrays.stream(stringCell.split(" ")).forEach(d -> {
                                if (StringUtils.isNotBlank(d)) {
                                    KnowledgePoint knowledgePoint = knowledgeService.getKnowledgePoint(d, subject.getId(), subject.getLevel());
                                    if (null != knowledgePoint) {
                                        knowledgePointId.add(knowledgePoint.getId());
                                    }
                                }
                            });
                        }
                    }

                    List<QuestionEditItemVM> questionEditItemVMS = new ArrayList<>();
                    char prefix = 'A';
                    for (int j = questionImportCellIndex.getItemStart(); j < questionImportCellIndex.getItemEnd(); j++) {
                        XSSFCell cell = row.getCell(j);
                        if (null != cell) {
                            String value = cell.getStringCellValue();
                            if (!StringUtils.isBlank(value)) {
                                QuestionEditItemVM questionEditItemVM = new QuestionEditItemVM();
                                questionEditItemVM.setPrefix(String.valueOf(prefix));
                                questionEditItemVM.setContent(value);
                                questionEditItemVMS.add(questionEditItemVM);
                                prefix = (char) (((int) prefix) + 1);
                            }
                        }
                    }
                    if (questionEditItemVMS.size() < 1) {
                        writeError(row, cellStyle, errorIndex, "选项不能为空");
                        continue;
                    }


                    QuestionEditRequestVM questionEditRequestVM = new QuestionEditRequestVM();
                    questionEditRequestVM.setQuestionType(QuestionTypeEnum.SingleChoice.getCode());

                    questionEditRequestVM.setGradeLevel(level);
                    questionEditRequestVM.setSubjectId(subject.getId());
                    questionEditRequestVM.setTitle(title);
                    questionEditRequestVM.setAnalyze(analyze);
                    questionEditRequestVM.setScore(score);
                    questionEditRequestVM.setDifficult(Integer.parseInt(difficult));
                    questionEditRequestVM.setCorrect(correct);
                    questionEditRequestVM.setItems(questionEditItemVMS);
                    questionEditRequestVM.setKnowledgeIdList(knowledgePointId);
                    Question question = questionService.insertFullQuestion(questionEditRequestVM, user.getId());
                    row.createCell(questionImportCellIndex.getId()).setCellValue(question.getId());
                } catch (Exception ex) {
                    writeError(row, cellStyle, errorIndex, ex.getMessage());
                }
            }
        }
    }

    private void multipleChoice(XSSFSheet sheet, XSSFCellStyle cellStyle, User user, QuestionImportCellIndex questionImportCellIndex) {
        if (null != sheet && sheet.getLastRowNum() >= 1) {
            Integer errorIndex = 14;
            for (int i = 1; i <= sheet.getLastRowNum(); i++) {
                XSSFRow row = sheet.getRow(i);
                try {
                    if (null != row.getCell(questionImportCellIndex.getId())) {  //已经导入过
                        continue;
                    }

                    Integer level = user.getUserLevel();
                    if (null != questionImportCellIndex.getLevel()) {
                        level = levelCheck(row, cellStyle, questionImportCellIndex.getLevel(), errorIndex);
                        if (null == level) {
                            continue;
                        }
                    }

                    List<Subject> subjects = subjectService.getSubjectByLevel(level);
                    Subject subject = subjectCheck(row, cellStyle, questionImportCellIndex.getSubject(), subjects, errorIndex);
                    if (null == subject) {
                        continue;
                    }
                    String title = stringCheck(row, cellStyle, questionImportCellIndex.getTitle(), errorIndex, "题干不能为空");
                    if (null == title) {
                        continue;
                    }
                    String analyze = stringCheck(row, cellStyle, questionImportCellIndex.getAnalyze(), errorIndex, "解析不能为空");
                    if (null == analyze) {
                        continue;
                    }
                    String score = stringCheck(row, cellStyle, questionImportCellIndex.getScore(), errorIndex, "分数不能为空");
                    if (null == score) {
                        continue;
                    }
                    String difficult = stringCheck(row, cellStyle, questionImportCellIndex.getDifficult(), errorIndex, "难度不能为空");
                    if (null == difficult) {
                        continue;
                    }

                    List<Integer> knowledgePointId = new ArrayList<>();
                    XSSFCell knowledgeCell = row.getCell(questionImportCellIndex.getKnowledge());
                    if (null != knowledgeCell) {
                        String stringCell = knowledgeCell.getStringCellValue();
                        if (StringUtils.isNotBlank(stringCell)) {
                            Arrays.stream(stringCell.split(" ")).forEach(d -> {
                                if (StringUtils.isNotBlank(d)) {
                                    KnowledgePoint knowledgePoint = knowledgeService.getKnowledgePoint(d, subject.getId(), subject.getLevel());
                                    if (null != knowledgePoint) {
                                        knowledgePointId.add(knowledgePoint.getId());
                                    }
                                }
                            });
                        }
                    }


                    String correct = stringCheck(row, cellStyle, questionImportCellIndex.getCorrect(), errorIndex, "答案不能为空");
                    if (null == correct) {
                        continue;
                    }
                    List<String> correctArray = new ArrayList<>();
                    for (char item : correct.toCharArray()) {
                        correctArray.add(String.valueOf(item));
                    }

                    List<QuestionEditItemVM> questionEditItemVMS = new ArrayList<>();
                    char prefix = 'A';
                    for (int j = questionImportCellIndex.getItemStart(); j < questionImportCellIndex.getItemEnd(); j++) {
                        XSSFCell cell = row.getCell(j);
                        if (null != cell) {
                            String value = cell.getStringCellValue();
                            if (!StringUtils.isBlank(value)) {
                                QuestionEditItemVM questionEditItemVM = new QuestionEditItemVM();
                                questionEditItemVM.setPrefix(String.valueOf(prefix));
                                questionEditItemVM.setContent(value);
                                questionEditItemVMS.add(questionEditItemVM);
                                prefix = (char) (((int) prefix) + 1);
                            }
                        }
                    }
                    if (questionEditItemVMS.size() < 1) {
                        writeError(row, cellStyle, errorIndex, "选项不能为空");
                        continue;
                    }
                    QuestionEditRequestVM questionEditRequestVM = new QuestionEditRequestVM();
                    questionEditRequestVM.setQuestionType(QuestionTypeEnum.MultipleChoice.getCode());
                    questionEditRequestVM.setGradeLevel(level);
                    questionEditRequestVM.setSubjectId(subject.getId());
                    questionEditRequestVM.setTitle(title);
                    questionEditRequestVM.setAnalyze(analyze);
                    questionEditRequestVM.setScore(score);
                    questionEditRequestVM.setDifficult(Integer.parseInt(difficult));
                    questionEditRequestVM.setCorrect(correct);
                    questionEditRequestVM.setCorrectArray(correctArray);
                    questionEditRequestVM.setItems(questionEditItemVMS);
                    questionEditRequestVM.setKnowledgeIdList(knowledgePointId);
                    Question question = questionService.insertFullQuestion(questionEditRequestVM, user.getId());
                    row.createCell(questionImportCellIndex.getId()).setCellValue(question.getId());
                } catch (Exception ex) {
                    writeError(row, cellStyle, errorIndex, ex.getMessage());
                }
            }
        }
    }

    private void trueFalse(XSSFSheet sheet, XSSFCellStyle cellStyle, User user, QuestionImportCellIndex questionImportCellIndex) {
        if (null != sheet && sheet.getLastRowNum() >= 1) {
            Integer errorIndex = questionImportCellIndex.getError();
            for (int i = 1; i <= sheet.getLastRowNum(); i++) {
                XSSFRow row = sheet.getRow(i);
                try {
                    if (null != row.getCell(questionImportCellIndex.getId())) {  //已经导入过
                        continue;
                    }

                    Integer level = user.getUserLevel();
                    if (null != questionImportCellIndex.getLevel()) {
                        level = levelCheck(row, cellStyle, questionImportCellIndex.getLevel(), errorIndex);
                        if (null == level) {
                            continue;
                        }
                    }

                    List<Subject> subjects = subjectService.getSubjectByLevel(level);
                    Subject subject = subjectCheck(row, cellStyle, questionImportCellIndex.getSubject(), subjects, errorIndex);
                    if (null == subject) {
                        continue;
                    }
                    String title = stringCheck(row, cellStyle, questionImportCellIndex.getTitle(), errorIndex, "题干不能为空");
                    if (null == title) {
                        continue;
                    }
                    String analyze = stringCheck(row, cellStyle, questionImportCellIndex.getAnalyze(), errorIndex, "解析不能为空");
                    if (null == analyze) {
                        continue;
                    }
                    String score = stringCheck(row, cellStyle, questionImportCellIndex.getScore(), errorIndex, "分数不能为空");
                    if (null == score) {
                        continue;
                    }
                    String difficult = stringCheck(row, cellStyle, questionImportCellIndex.getDifficult(), errorIndex, "难度不能为空");
                    if (null == difficult) {
                        continue;
                    }
                    String correct = stringCheck(row, cellStyle, questionImportCellIndex.getCorrect(), errorIndex, "答案不能为空");
                    if (null == correct) {
                        continue;
                    }

                    List<Integer> knowledgePointId = new ArrayList<>();
                    XSSFCell knowledgeCell = row.getCell(questionImportCellIndex.getKnowledge());
                    if (null != knowledgeCell) {
                        String stringCell = knowledgeCell.getStringCellValue();
                        if (StringUtils.isNotBlank(stringCell)) {
                            Arrays.stream(stringCell.split(" ")).forEach(d -> {
                                if (StringUtils.isNotBlank(d)) {
                                    KnowledgePoint knowledgePoint = knowledgeService.getKnowledgePoint(d, subject.getId(), subject.getLevel());
                                    if (null != knowledgePoint) {
                                        knowledgePointId.add(knowledgePoint.getId());
                                    }
                                }
                            });
                        }
                    }


                    List<QuestionEditItemVM> questionEditItemVMS = new ArrayList<>();
                    char prefix = 'A';
                    for (int j = questionImportCellIndex.getItemStart(); j <= questionImportCellIndex.getItemEnd(); j++) {
                        XSSFCell cell = row.getCell(j);
                        if (null != cell) {
                            String value = cell.getStringCellValue();
                            if (!StringUtils.isBlank(value)) {
                                QuestionEditItemVM questionEditItemVM = new QuestionEditItemVM();
                                questionEditItemVM.setPrefix(String.valueOf(prefix));
                                questionEditItemVM.setContent(value);
                                questionEditItemVMS.add(questionEditItemVM);
                                prefix = (char) (((int) prefix) + 1);
                            }
                        }
                    }
                    if (questionEditItemVMS.size() < 1) {
                        writeError(row, cellStyle, errorIndex, "选项不能为空");
                        continue;
                    }
                    QuestionEditRequestVM questionEditRequestVM = new QuestionEditRequestVM();
                    questionEditRequestVM.setQuestionType(QuestionTypeEnum.TrueFalse.getCode());
                    questionEditRequestVM.setGradeLevel(level);
                    questionEditRequestVM.setSubjectId(subject.getId());
                    questionEditRequestVM.setTitle(title);
                    questionEditRequestVM.setAnalyze(analyze);
                    questionEditRequestVM.setScore(score);
                    questionEditRequestVM.setDifficult(Integer.parseInt(difficult));
                    questionEditRequestVM.setCorrect(correct);
                    questionEditRequestVM.setItems(questionEditItemVMS);
                    questionEditRequestVM.setKnowledgeIdList(knowledgePointId);
                    Question question = questionService.insertFullQuestion(questionEditRequestVM, user.getId());
                    row.createCell(questionImportCellIndex.getId()).setCellValue(question.getId());
                } catch (Exception ex) {
                    writeError(row, cellStyle, errorIndex, ex.getMessage());
                }
            }
        }
    }

    private void gapFilling(XSSFSheet sheet, XSSFCellStyle cellStyle, User user, QuestionImportCellIndex questionImportCellIndex) {
        if (null != sheet && sheet.getLastRowNum() >= 1) {
            Integer errorIndex = questionImportCellIndex.getError();
            for (int i = 1; i <= sheet.getLastRowNum(); i++) {
                XSSFRow row = sheet.getRow(i);
                try {
                    if (null != row.getCell(questionImportCellIndex.getId())) {  //已经导入过
                        continue;
                    }

                    Integer level = user.getUserLevel();
                    if (null != questionImportCellIndex.getLevel()) {
                        level = levelCheck(row, cellStyle, questionImportCellIndex.getLevel(), errorIndex);
                        if (null == level) {
                            continue;
                        }
                    }

                    List<Subject> subjects = subjectService.getSubjectByLevel(level);
                    Subject subject = subjectCheck(row, cellStyle, questionImportCellIndex.getSubject(), subjects, errorIndex);
                    if (null == subject) {
                        continue;
                    }
                    String title = stringCheck(row, cellStyle, questionImportCellIndex.getTitle(), errorIndex, "题干不能为空");
                    if (null == title) {
                        continue;
                    }
                    String analyze = stringCheck(row, cellStyle, questionImportCellIndex.getAnalyze(), errorIndex, "解析不能为空");
                    if (null == analyze) {
                        continue;
                    }
                    String score = stringCheck(row, cellStyle, questionImportCellIndex.getScore(), errorIndex, "分数不能为空");
                    if (null == score) {
                        continue;
                    }
                    String difficult = stringCheck(row, cellStyle, questionImportCellIndex.getDifficult(), errorIndex, "难度不能为空");
                    if (null == difficult) {
                        continue;
                    }

                    List<Integer> knowledgePointId = new ArrayList<>();
                    XSSFCell knowledgeCell = row.getCell(questionImportCellIndex.getKnowledge());
                    if (null != knowledgeCell) {
                        String stringCell = knowledgeCell.getStringCellValue();
                        if (StringUtils.isNotBlank(stringCell)) {
                            Arrays.stream(stringCell.split(" ")).forEach(d -> {
                                if (StringUtils.isNotBlank(d)) {
                                    KnowledgePoint knowledgePoint = knowledgeService.getKnowledgePoint(d, subject.getId(), subject.getLevel());
                                    if (null != knowledgePoint) {
                                        knowledgePointId.add(knowledgePoint.getId());
                                    }
                                }
                            });
                        }
                    }

                    List<QuestionEditItemVM> questionEditItemVMS = new ArrayList<>();
                    StringBuilder stringBuilder = new StringBuilder(title);
                    Pattern pattern = Pattern.compile("\\$.*?\\$");
                    Matcher matcher = pattern.matcher(stringBuilder);
                    Integer index = 0;
                    while (matcher.find()) {
                        ++index;
                        String grapFormat = String.format("<span class=\"gapfilling-span %s\">%d</span>", UUID.randomUUID().toString(), index);
                        stringBuilder = stringBuilder.replace(matcher.start(), matcher.end(), grapFormat);
                        matcher = pattern.matcher(stringBuilder);

                        String stringCell = row.getCell(questionImportCellIndex.getItemStart() + index).getStringCellValue();
                        QuestionEditItemVM questionEditItemVM = new QuestionEditItemVM();
                        questionEditItemVM.setPrefix(index.toString());
                        questionEditItemVM.setScore(score);
                        questionEditItemVM.setContent(stringCell);
                        questionEditItemVMS.add(questionEditItemVM);
                    }
                    if (questionEditItemVMS.size() < 1) {
                        writeError(row, cellStyle, errorIndex, "空答案不能为空");
                        continue;
                    }

                    String qScore = ExamUtil.scoreToVM(ExamUtil.scoreFromVM(score) * questionEditItemVMS.size());
                    QuestionEditRequestVM questionEditRequestVM = new QuestionEditRequestVM();
                    questionEditRequestVM.setQuestionType(QuestionTypeEnum.GapFilling.getCode());
                    questionEditRequestVM.setGradeLevel(level);
                    questionEditRequestVM.setSubjectId(subject.getId());
                    questionEditRequestVM.setTitle(stringBuilder.toString());
                    questionEditRequestVM.setAnalyze(analyze);
                    questionEditRequestVM.setScore(qScore);
                    questionEditRequestVM.setDifficult(Integer.parseInt(difficult));
                    questionEditRequestVM.setItems(questionEditItemVMS);
                    questionEditRequestVM.setKnowledgeIdList(knowledgePointId);
                    Question question = questionService.insertFullQuestion(questionEditRequestVM, user.getId());
                    row.createCell(questionImportCellIndex.getId()).setCellValue(question.getId());
                } catch (Exception ex) {
                    writeError(row, cellStyle, errorIndex, ex.getMessage());
                }
            }
        }
    }

    private void shortAnswer(XSSFSheet sheet, XSSFCellStyle cellStyle, User user, QuestionImportCellIndex questionImportCellIndex) {
        if (null != sheet && sheet.getLastRowNum() >= 1) {
            Integer errorIndex = questionImportCellIndex.getError();
            for (int i = 1; i <= sheet.getLastRowNum(); i++) {
                XSSFRow row = sheet.getRow(i);
                try {
                    if (null != row.getCell(questionImportCellIndex.getId())) {  //已经导入过
                        continue;
                    }

                    Integer level = user.getUserLevel();
                    if (null != questionImportCellIndex.getLevel()) {
                        level = levelCheck(row, cellStyle, questionImportCellIndex.getLevel(), errorIndex);
                        if (null == level) {
                            continue;
                        }
                    }

                    List<Subject> subjects = subjectService.getSubjectByLevel(level);
                    Subject subject = subjectCheck(row, cellStyle, questionImportCellIndex.getSubject(), subjects, errorIndex);
                    if (null == subject) {
                        continue;
                    }
                    String title = stringCheck(row, cellStyle, questionImportCellIndex.getTitle(), errorIndex, "题干不能为空");
                    if (null == title) {
                        continue;
                    }

                    String correct = stringCheck(row, cellStyle, questionImportCellIndex.getCorrect(), errorIndex, "答案不能为空");
                    if (null == correct) {
                        continue;
                    }

                    String analyze = stringCheck(row, cellStyle, questionImportCellIndex.getAnalyze(), errorIndex, "解析不能为空");
                    if (null == analyze) {
                        continue;
                    }
                    String score = stringCheck(row, cellStyle, questionImportCellIndex.getScore(), errorIndex, "分数不能为空");
                    if (null == score) {
                        continue;
                    }
                    String difficult = stringCheck(row, cellStyle, questionImportCellIndex.getDifficult(), errorIndex, "难度不能为空");
                    if (null == difficult) {
                        continue;
                    }

                    List<Integer> knowledgePointId = new ArrayList<>();
                    XSSFCell knowledgeCell = row.getCell(questionImportCellIndex.getKnowledge());
                    if (null != knowledgeCell) {
                        String stringCell = knowledgeCell.getStringCellValue();
                        if (StringUtils.isNotBlank(stringCell)) {
                            Arrays.stream(stringCell.split(" ")).forEach(d -> {
                                if (StringUtils.isNotBlank(d)) {
                                    KnowledgePoint knowledgePoint = knowledgeService.getKnowledgePoint(d, subject.getId(), subject.getLevel());
                                    if (null != knowledgePoint) {
                                        knowledgePointId.add(knowledgePoint.getId());
                                    }
                                }
                            });
                        }
                    }

                    QuestionEditRequestVM questionEditRequestVM = new QuestionEditRequestVM();
                    questionEditRequestVM.setQuestionType(QuestionTypeEnum.ShortAnswer.getCode());
                    questionEditRequestVM.setGradeLevel(level);
                    questionEditRequestVM.setSubjectId(subject.getId());
                    questionEditRequestVM.setTitle(title);
                    questionEditRequestVM.setCorrect(correct);
                    questionEditRequestVM.setAnalyze(analyze);
                    questionEditRequestVM.setScore(score);
                    questionEditRequestVM.setDifficult(Integer.parseInt(difficult));
                    questionEditRequestVM.setItems(new ArrayList<>());
                    questionEditRequestVM.setKnowledgeIdList(knowledgePointId);
                    Question question = questionService.insertFullQuestion(questionEditRequestVM, user.getId());
                    row.createCell(questionImportCellIndex.getId()).setCellValue(question.getId());
                } catch (Exception ex) {
                    writeError(row, cellStyle, errorIndex, ex.getMessage());
                }
            }
        }
    }


    private Integer levelCheck(XSSFRow row, XSSFCellStyle cellStyle, Integer cellIndex, Integer errorIndex) {
        List<Department> list = departmentService.gets();
        Dict levelHash = Dict.create();
        for (Department department : list) {
            levelHash.set(department.getName(), department.getId());
        }
//        Dict levelHash = Dict.create().set("一年级", 1).set("二年级", 2).set("三年级", 3).set("四年级", 4).set("五年级", 5).set("六年级", 6).set("初一", 7).set("初二", 8).set("初三", 9).set("高一", 10).set("高二", 11).set("高三", 12);
        String levelName = stringCheck(row, cellStyle, cellIndex, errorIndex, "年级不能为空");
        if (null == levelName) {
            return null;
        }

        Integer level = levelHash.getInt(levelName);
        if (null == level) {
            writeError(row, cellStyle, errorIndex, "年级未找到");
            return null;
        }
        return level;
    }

    private Subject subjectCheck(XSSFRow row, XSSFCellStyle cellStyle, Integer cellIndex, List<Subject> subjects, Integer errorIndex) {
        String subjectName = stringCheck(row, cellStyle, cellIndex, errorIndex, "学科不能为空");
        if (null == subjectName) {
            return null;
        }
        Subject subject = subjects.stream().filter(d -> d.getName().equals(subjectName)).findFirst().orElse(null);
        if (null == subject) {
            writeError(row, cellStyle, errorIndex, "学科未找到");
            return null;
        }
        return subject;
    }


    private String stringCheck(XSSFRow row, XSSFCellStyle cellStyle, Integer cellIndex, Integer errorIndex, String errorMsg) {
        row.getCell(cellIndex).setCellType(CellType.STRING);
        String stringCell = row.getCell(cellIndex).getStringCellValue();
        if (StringUtils.isBlank(stringCell)) {
            writeError(row, cellStyle, errorIndex, errorMsg);
            return null;
        }
        return stringCell;
    }

    private void writeError(XSSFRow row, XSSFCellStyle cellStyle, Integer errorIndex, String errorMsg) {
        XSSFCell xssfCell = row.createCell(errorIndex);
        xssfCell.setCellStyle(cellStyle);
        xssfCell.setCellValue(errorMsg);
    }

}