package jnpf.tmsService.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;
import jnpf.exception.DataException;
import jnpf.tmsEntity.TmsExamEntity;
import jnpf.tmsEntity.TmsExamItemEntity;
import jnpf.tmsEntity.TmsPaperEntity;
import jnpf.tmsEntity.TmsPaperQuestionEntity;
import jnpf.tmsEntity.TmsPaperSectionEntity;
import jnpf.tmsEntity.TmsPersonTaskEntity;
import jnpf.tmsEntity.TmsQuestionEntity;
import jnpf.tmsEntity.TmsQuestionOptionEntity;
import jnpf.tmsEntity.TmsTaskEntity;
import jnpf.tmsEntity.exam.TmsOnlineExamAttemptVO;
import jnpf.tmsEntity.exam.TmsOnlineExamDetailVO;
import jnpf.tmsEntity.exam.TmsOnlineExamGradeItemVO;
import jnpf.tmsEntity.exam.TmsOnlineExamListVO;
import jnpf.tmsEntity.exam.TmsOnlineExamOptionVO;
import jnpf.tmsEntity.exam.TmsOnlineExamPaperVO;
import jnpf.tmsEntity.exam.TmsOnlineExamQuery;
import jnpf.tmsEntity.exam.TmsOnlineExamQuestionVO;
import jnpf.tmsEntity.exam.TmsOnlineExamSubmitForm;
import jnpf.tmsEntity.exam.TmsOnlineExamSubmitResultVO;
import jnpf.tmsMapper.TmsExamItemMapper;
import jnpf.tmsMapper.TmsExamMapper;
import jnpf.tmsMapper.TmsPaperMapper;
import jnpf.tmsMapper.TmsPaperQuestionMapper;
import jnpf.tmsMapper.TmsPaperSectionMapper;
import jnpf.tmsMapper.TmsPersonTaskMapper;
import jnpf.tmsMapper.TmsQuestionMapper;
import jnpf.tmsMapper.TmsQuestionOptionMapper;
import jnpf.tmsMapper.TmsTaskMapper;
import jnpf.tmsService.TmsOnlineExamService;
import jnpf.util.DateUtil;
import jnpf.util.RandomUtil;
import jnpf.util.StringUtil;
import jnpf.util.UserProvider;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
@RequiredArgsConstructor
public class TmsOnlineExamServiceImpl implements TmsOnlineExamService {
    private static final String STATUS_OPEN = "open";
    private static final String EXAM_DOING = "doing";
    private static final String EXAM_SUBMITTED = "submitted";
    private static final String NOT_STARTED = "notStarted";
    private static final String GRADE_AUTO = "auto";
    private static final String GRADE_PENDING = "pending";
    private static final String SORT_RANDOM = "random";
    private static final String TYPE_ESSAY = "essay";
    private static final String TYPE_BLANK = "blank";
    private static final String TYPE_MULTI = "multi";
    private static final String FMT = "yyyy-MM-dd HH:mm:ss";
    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
    private final TmsPaperMapper paperMapper;
    private final TmsPaperSectionMapper sectionMapper;
    private final TmsPaperQuestionMapper paperQuestionMapper;
    private final TmsQuestionMapper questionMapper;
    private final TmsQuestionOptionMapper optionMapper;
    private final TmsExamMapper examMapper;
    private final TmsExamItemMapper examItemMapper;
    private final TmsTaskMapper taskMapper;
    private final TmsPersonTaskMapper personTaskMapper;

    @Override
    public List<TmsOnlineExamListVO> getMyPapers(TmsOnlineExamQuery query) {
        String userId = UserProvider.getLoginUserId();
        LambdaQueryWrapper<TmsPaperEntity> qw = new LambdaQueryWrapper<>();
        qw.eq(TmsPaperEntity::getBizStatus, STATUS_OPEN);
        if (StringUtil.isNotEmpty(query.getKeyword()) && !"null".equalsIgnoreCase(query.getKeyword())) {
            qw.like(TmsPaperEntity::getPaperName, query.getKeyword().trim());
        }
        qw.orderByDesc(TmsPaperEntity::getCreatorTime);
        List<TmsPaperEntity> papers = this.paperMapper.selectList(qw);
        Map<String, TmsExamEntity> examMap = this.loadLatestExams(userId, papers);
        ArrayList<TmsOnlineExamListVO> all = new ArrayList<TmsOnlineExamListVO>();
        for (TmsPaperEntity paper : papers) {
            TmsExamEntity exam = examMap.get(paper.getId());
            String status = this.statusOf(exam);
            if (StringUtil.isNotEmpty(query.getStatus()) && !"null".equalsIgnoreCase(query.getStatus()) && !query.getStatus().equals(status)) continue;
            all.add(this.toListVo(paper, exam, status));
        }
        long current = query.getCurrentPage() > 0L ? query.getCurrentPage() : 1L;
        long size = query.getPageSize() > 0L ? query.getPageSize() : 20L;
        int from = (int)((current - 1L) * size);
        int to = Math.min(from + (int)size, all.size());
        ArrayList<TmsOnlineExamListVO> page = from >= all.size() ? new ArrayList<TmsOnlineExamListVO>() : new ArrayList(all.subList(from, to));
        query.setData(page, (long)all.size());
        return page;
    }

    @Override
    public TmsOnlineExamDetailVO getDetail(String paperId) {
        if (StringUtil.isEmpty(paperId)) {
            throw new DataException("请选择试卷");
        }
        TmsPaperEntity paper = this.paperMapper.selectById(paperId);
        if (paper == null) {
            throw new DataException("试卷不存在");
        }
        TmsExamEntity exam = this.latestExam(UserProvider.getLoginUserId(), paperId);
        if (exam == null && !STATUS_OPEN.equals(paper.getBizStatus())) {
            throw new DataException("试卷未开放");
        }
        TmsOnlineExamDetailVO vo = new TmsOnlineExamDetailVO();
        vo.setId(paper.getId());
        vo.setPaperId(paper.getId());
        vo.setPaperName(paper.getPaperName());
        vo.setStatus(this.statusOf(exam));
        vo.setExamTimeText(this.timeText(paper.getExamStart(), paper.getExamEnd()));
        vo.setTotalScore(paper.getTotalScore());
        vo.setPassScore(paper.getPassScore());
        vo.setDurationMin(paper.getDurationMin());
        if (exam != null) {
            vo.setExamId(exam.getId());
            vo.setGotScore(exam.getTotalScore());
            vo.setStartTime(this.fmt(exam.getStartTime()));
            vo.setSubmitTime(this.fmt(exam.getSubmitTime()));
            vo.setPassFlag(exam.getPassFlag());
            vo.setGradeStatus(exam.getGradeStatus());
            if (EXAM_SUBMITTED.equals(exam.getExamStatus())) {
                vo.setQuestions(this.toReviewQuestions(this.loadItems(exam.getId())));
                if (vo.getTotalScore() == null) {
                    BigDecimal total = BigDecimal.ZERO;
                    for (TmsOnlineExamQuestionVO q : vo.getQuestions()) {
                        total = total.add(this.nvl(q.getScore()));
                    }
                    vo.setTotalScore(total);
                }
            }
        }
        this.fillRetakeMeta(vo, paper.getId(), exam, UserProvider.getLoginUserId());
        vo.setAttempts(this.listAttempts(UserProvider.getLoginUserId(), paper.getId()));
        return vo;
    }

    @Override
    public TmsOnlineExamDetailVO getExamReview(String examId) {
        if (StringUtil.isEmpty(examId)) {
            throw new DataException("请选择答卷");
        }
        TmsExamEntity exam = this.examMapper.selectById(examId);
        if (exam == null) {
            throw new DataException("答卷不存在");
        }
        if (!Objects.equals(UserProvider.getLoginUserId(), exam.getUserId())) {
            throw new DataException("无权查看该答卷");
        }
        if (!EXAM_SUBMITTED.equals(exam.getExamStatus())) {
            throw new DataException("交卷后才能进行考试回顾");
        }
        TmsPaperEntity paper = this.paperMapper.selectById((exam.getPaperId()));
        if (paper == null) {
            throw new DataException("试卷不存在");
        }
        TmsOnlineExamDetailVO vo = new TmsOnlineExamDetailVO();
        vo.setId(paper.getId());
        vo.setPaperId(paper.getId());
        vo.setPaperName(paper.getPaperName());
        vo.setStatus(this.statusOf(exam));
        vo.setExamTimeText(this.timeText(paper.getExamStart(), paper.getExamEnd()));
        vo.setTotalScore(paper.getTotalScore());
        vo.setPassScore(paper.getPassScore() != null ? paper.getPassScore() : exam.getPassScore());
        vo.setDurationMin(paper.getDurationMin());
        vo.setExamId(exam.getId());
        vo.setGotScore(exam.getTotalScore());
        vo.setStartTime(this.fmt(exam.getStartTime()));
        vo.setSubmitTime(this.fmt(exam.getSubmitTime()));
        vo.setPassFlag(exam.getPassFlag());
        vo.setGradeStatus(exam.getGradeStatus());
        vo.setAttemptNo(Integer.valueOf(exam.getAttemptNo() == null ? 1 : exam.getAttemptNo()));
        vo.setAttemptLabel(this.attemptLabel(vo.getAttemptNo()));
        vo.setQuestions(this.toReviewQuestions(this.loadItems(exam.getId())));
        if (vo.getTotalScore() == null) {
            BigDecimal total = BigDecimal.ZERO;
            for (TmsOnlineExamQuestionVO q : vo.getQuestions()) {
                total = total.add(this.nvl(q.getScore()));
            }
            vo.setTotalScore(total);
        }
        return vo;
    }

    private List<TmsOnlineExamAttemptVO> listAttempts(String userId, String paperId) {
        if (StringUtil.isEmpty(userId) || StringUtil.isEmpty(paperId)) {
            return Collections.emptyList();
        }
        LambdaQueryWrapper<TmsExamEntity> qw = new LambdaQueryWrapper<>();
        qw.eq(TmsExamEntity::getUserId, userId);
        qw.eq(TmsExamEntity::getPaperId, paperId);
        qw.orderByAsc(TmsExamEntity::getAttemptNo);
        qw.orderByAsc(TmsExamEntity::getCreatorTime);
        List<TmsExamEntity> exams = this.examMapper.selectList(qw);
        ArrayList<TmsOnlineExamAttemptVO> list = new ArrayList<TmsOnlineExamAttemptVO>(exams.size());
        for (TmsExamEntity exam : exams) {
            TmsOnlineExamAttemptVO row = new TmsOnlineExamAttemptVO();
            row.setExamId(exam.getId());
            int attemptNo = exam.getAttemptNo() == null ? 1 : exam.getAttemptNo();
            row.setAttemptNo(Integer.valueOf(attemptNo));
            row.setAttemptLabel(this.attemptLabel(attemptNo));
            row.setStatus(this.statusOf(exam));
            row.setGradeStatus(exam.getGradeStatus());
            row.setStartTime(this.fmt(exam.getStartTime()));
            row.setSubmitTime(this.fmt(exam.getSubmitTime()));
            row.setGotScore(exam.getTotalScore());
            row.setPassFlag(exam.getPassFlag());
            list.add(row);
        }
        return list;
    }

    @Override
    @Transactional(rollbackFor = Exception.class, noRollbackFor = ExamTimedOutException.class)
    public TmsOnlineExamPaperVO start(String paperId) {
        if (StringUtil.isEmpty(paperId)) {
            throw new DataException("请选择试卷");
        }
        String userId = UserProvider.getLoginUserId();
        TmsExamEntity doing = this.findDoing(userId, paperId);
        if (doing != null) {
            if (this.isTimedOut(doing)) {
                // 超时须先交卷再返回；抛异常会导致事务回滚，答卷一直停在考试中
                this.submitInternal(doing, null);
                TmsOnlineExamPaperVO vo = this.toPaperVo(doing, this.loadItems(doing.getId()));
                vo.setAutoSubmitted(Boolean.TRUE);
                vo.setRemainSeconds(Integer.valueOf(0));
                return vo;
            }
            return this.toPaperVo(doing, this.loadItems(doing.getId()));
        }
        TmsPaperEntity paper = this.requireOpenPaper(paperId);
        this.assertExamWindow(paper);
        RetakeContext retake = this.resolveRetake(userId, paperId);
        if (!retake.allowStart) {
            throw new DataException(retake.message);
        }
        TmsExamEntity exam = this.createExam(paper, userId, retake);
        return this.toPaperVo(exam, this.loadItems(exam.getId()));
    }

    @Override
    @Transactional(rollbackFor = Exception.class, noRollbackFor = ExamTimedOutException.class)
    public void saveAnswers(String examId, TmsOnlineExamSubmitForm form) {
        TmsExamEntity exam = this.requireDoingExam(examId);
        if (this.isTimedOut(exam)) {
            this.submitInternal(exam, form == null ? null : form.getAnswers());
            throw new ExamTimedOutException();
        }
        this.writeAnswers(exam.getId(), form == null ? null : form.getAnswers());
    }

    @Override
    @Transactional(rollbackFor={Exception.class})
    public TmsOnlineExamSubmitResultVO submit(String examId, TmsOnlineExamSubmitForm form) {
        TmsExamEntity exam = this.requireDoingExam(examId);
        return this.submitInternal(exam, form == null ? null : form.getAnswers());
    }

    private TmsOnlineExamSubmitResultVO submitInternal(TmsExamEntity exam, Map<String, Object> answers) {
        List<TmsExamItemEntity> items = this.loadItems(exam.getId());
        HashMap<String, String> normalized = new HashMap<String, String>();
        for (TmsExamItemEntity item : items) {
            if (answers != null && answers.containsKey(item.getId())) {
                normalized.put(item.getId(), this.normalizeAnswer(answers.get(item.getId()), item.getQuestionType()));
                continue;
            }
            normalized.put(item.getId(), item.getUserAnswer() == null ? "" : item.getUserAnswer());
        }
        BigDecimal objective = BigDecimal.ZERO;
        boolean pending = false;
        ArrayList<TmsOnlineExamGradeItemVO> grades = new ArrayList<TmsOnlineExamGradeItemVO>();
        Date now = new Date();
        for (TmsExamItemEntity item : items) {
            String userAnswer = normalized.getOrDefault(item.getId(), "");
            item.setUserAnswer(userAnswer);
            TmsOnlineExamGradeItemVO grade = new TmsOnlineExamGradeItemVO();
            grade.setId(item.getId());
            grade.setCorrectAnswer(item.getCorrectAnswer());
            boolean subjective = "1".equals(item.getIsSubjective());
            grade.setSubjective(Boolean.valueOf(subjective));
            if (subjective) {
                pending = true;
                item.setGotScore(null);
                grade.setGotScore(null);
                grade.setRight(null);
            } else {
                boolean right = this.answerRight(item, userAnswer);
                BigDecimal got = right ? this.nvl(item.getScore()) : BigDecimal.ZERO;
                item.setGotScore(got);
                objective = objective.add(got);
                grade.setGotScore(got);
                grade.setRight(Boolean.valueOf(right));
            }
            item.setLastModifyTime(now);
            this.examItemMapper.updateById(item);
            grades.add(grade);
        }
        objective = objective.setScale(1, RoundingMode.HALF_UP);
        exam.setObjectiveScore(objective);
        exam.setSubmitTime(now);
        exam.setExamStatus(EXAM_SUBMITTED);
        exam.setLastModifyTime(now);
        if (pending) {
            exam.setGradeStatus(GRADE_PENDING);
            exam.setSubjectiveScore(null);
            exam.setTotalScore(objective);
            exam.setPassFlag(null);
        } else {
            exam.setGradeStatus(GRADE_AUTO);
            exam.setSubjectiveScore(BigDecimal.ZERO);
            exam.setTotalScore(objective);
            exam.setPassFlag(this.passFlag(objective, exam.getPassScore()));
        }
        this.examMapper.updateById(exam);
        TmsOnlineExamSubmitResultVO result = new TmsOnlineExamSubmitResultVO();
        result.setObjectiveScore(exam.getObjectiveScore());
        result.setTotalScore(exam.getTotalScore());
        result.setPassFlag(exam.getPassFlag());
        result.setGradeStatus(exam.getGradeStatus());
        result.setPendingGrade(Boolean.valueOf(pending));
        result.setItems(grades);
        return result;
    }

    private TmsExamEntity createExam(TmsPaperEntity paper, String userId, RetakeContext retake) {
        List<QuestionSnap> snaps = this.loadPaperQuestions(paper.getId());
        if (snaps.isEmpty()) {
            throw new DataException("试卷没有试题，无法开考");
        }
        if (SORT_RANDOM.equals(paper.getSortMode())) {
            Collections.shuffle(snaps);
        }
        Date now = new Date();
        TmsExamEntity exam = new TmsExamEntity();
        exam.setId(RandomUtil.uuId());
        exam.setTaskId(retake == null ? null : retake.taskId);
        exam.setPersonTaskId(retake == null ? null : retake.personTaskId);
        exam.setPaperId(paper.getId());
        exam.setPaperName(paper.getPaperName());
        exam.setUserId(userId);
        exam.setAttemptNo(Integer.valueOf(retake == null || retake.nextAttemptNo == null ? 1 : retake.nextAttemptNo));
        exam.setStartTime(now);
        exam.setDurationMin(paper.getDurationMin());
        BigDecimal passScore = paper.getPassScore();
        if (retake != null && retake.passScore != null) {
            passScore = retake.passScore;
        }
        exam.setPassScore(passScore);
        exam.setGradeStatus(GRADE_AUTO);
        exam.setExamStatus(EXAM_DOING);
        exam.setCreatorUserId(userId);
        exam.setCreatorTime(now);
        this.examMapper.insert(exam);
        int sort = 1;
        for (QuestionSnap snap : snaps) {
            TmsExamItemEntity item = new TmsExamItemEntity();
            item.setId(RandomUtil.uuId());
            item.setForeignId(exam.getId());
            item.setQuestionId(snap.question.getId());
            item.setQuestionType(snap.question.getQuestionType());
            item.setStem(snap.question.getStem());
            item.setOptionsJson(this.toJson(snap.options));
            item.setCorrectAnswer(this.correctOf(snap));
            item.setScore(snap.score);
            item.setIsSubjective(TYPE_ESSAY.equals(snap.question.getQuestionType()) ? "1" : "0");
            item.setAnalysis(snap.question.getAnalysis());
            item.setSortNo(Integer.valueOf(sort++));
            item.setCreatorUserId(userId);
            item.setCreatorTime(now);
            this.examItemMapper.insert(item);
        }
        return exam;
    }

    private List<QuestionSnap> loadPaperQuestions(String paperId) {
        LambdaQueryWrapper<TmsPaperSectionEntity> secQw = new LambdaQueryWrapper<>();
        secQw.eq(TmsPaperSectionEntity::getForeignId, paperId);
        secQw.orderByAsc(TmsPaperSectionEntity::getSortNo);
        List<TmsPaperSectionEntity> sections = this.sectionMapper.selectList(secQw);
        LambdaQueryWrapper<TmsPaperQuestionEntity> qQw = new LambdaQueryWrapper<>();
        qQw.eq(TmsPaperQuestionEntity::getForeignId, paperId);
        qQw.orderByAsc(TmsPaperQuestionEntity::getSortNo);
        List<TmsPaperQuestionEntity> links = this.paperQuestionMapper.selectList(qQw);
        HashMap<String, List<TmsPaperQuestionEntity>> bySection = new HashMap<>();
        for (TmsPaperQuestionEntity link : links) {
            bySection.computeIfAbsent(link.getSectionId(), k -> new ArrayList<>()).add(link);
        }
        List<String> questionIds = links.stream().map(TmsPaperQuestionEntity::getQuestionId).collect(Collectors.toList());
        HashMap<String, TmsQuestionEntity> questions = new HashMap<String, TmsQuestionEntity>();
        if (!questionIds.isEmpty()) {
            for (TmsQuestionEntity q : this.questionMapper.selectBatchIds(questionIds)) {
                questions.put(q.getId(), q);
            }
        }
        Map<String, List<TmsQuestionOptionEntity>> optionMap = this.loadOptions(questionIds);
        ArrayList<QuestionSnap> snaps = new ArrayList<QuestionSnap>();
        for (TmsPaperSectionEntity section : sections) {
            List<TmsPaperQuestionEntity> rows = bySection.getOrDefault(section.getId(), Collections.emptyList());
            rows.sort(Comparator.comparing(r -> r.getSortNo() == null ? 0 : r.getSortNo()));
            for (TmsPaperQuestionEntity row : rows) {
                TmsQuestionEntity question = questions.get(row.getQuestionId());
                if (question == null) {
                    throw new DataException("试卷中的试题已不存在，无法开考");
                }
                QuestionSnap snap = new QuestionSnap();
                snap.question = question;
                snap.score = row.getScore() == null ? BigDecimal.ZERO : row.getScore();
                snap.options = this.toStoredOptions(optionMap.getOrDefault(question.getId(), Collections.emptyList()));
                snaps.add(snap);
            }
        }
        return snaps;
    }

    private void writeAnswers(String examId, Map<String, Object> answers) {
        List<TmsExamItemEntity> items = this.loadItems(examId);
        Date now = new Date();
        for (TmsExamItemEntity item : items) {
            Object raw = answers == null ? null : answers.get(item.getId());
            item.setUserAnswer(this.normalizeAnswer(raw, item.getQuestionType()));
            item.setLastModifyTime(now);
            this.examItemMapper.updateById(item);
        }
    }

    private TmsOnlineExamPaperVO toPaperVo(TmsExamEntity exam, List<TmsExamItemEntity> items) {
        TmsOnlineExamPaperVO vo = new TmsOnlineExamPaperVO();
        vo.setExamId(exam.getId());
        vo.setPaperId(exam.getPaperId());
        vo.setPaperName(exam.getPaperName());
        vo.setPassScore(exam.getPassScore());
        vo.setDurationMin(exam.getDurationMin());
        vo.setStartTime(this.fmt(exam.getStartTime()));
        vo.setRemainSeconds(this.remainSeconds(exam));
        BigDecimal total = BigDecimal.ZERO;
        ArrayList<TmsOnlineExamQuestionVO> questions = new ArrayList<TmsOnlineExamQuestionVO>();
        for (TmsExamItemEntity item : items) {
            total = total.add(this.nvl(item.getScore()));
            TmsOnlineExamQuestionVO q = new TmsOnlineExamQuestionVO();
            q.setId(item.getId());
            q.setQuestionId(item.getQuestionId());
            q.setQuestionType(item.getQuestionType());
            q.setStem(item.getStem());
            q.setScore(item.getScore());
            q.setUserAnswer(item.getUserAnswer());
            q.setOptions(this.toClientOptions(item.getOptionsJson()));
            questions.add(q);
        }
        vo.setTotalScore(total);
        vo.setQuestions(questions);
        vo.setAttemptNo(Integer.valueOf(exam.getAttemptNo() == null ? 1 : exam.getAttemptNo()));
        vo.setAttemptLabel(this.attemptLabel(vo.getAttemptNo()));
        return vo;
    }

    private List<TmsOnlineExamQuestionVO> toReviewQuestions(List<TmsExamItemEntity> items) {
        ArrayList<TmsOnlineExamQuestionVO> questions = new ArrayList<TmsOnlineExamQuestionVO>();
        for (TmsExamItemEntity item : items) {
            TmsOnlineExamQuestionVO q = new TmsOnlineExamQuestionVO();
            q.setId(item.getId());
            q.setQuestionId(item.getQuestionId());
            q.setQuestionType(item.getQuestionType());
            q.setStem(item.getStem());
            q.setScore(item.getScore());
            q.setGotScore(item.getGotScore());
            q.setUserAnswer(item.getUserAnswer());
            q.setCorrectAnswer(item.getCorrectAnswer());
            boolean subjective = "1".equals(item.getIsSubjective());
            q.setSubjective(Boolean.valueOf(subjective));
            if (subjective) {
                q.setRight(null);
            } else if (item.getScore() != null && item.getScore().compareTo(BigDecimal.ZERO) > 0) {
                q.setRight(Boolean.valueOf(this.nvl(item.getGotScore()).compareTo(item.getScore()) >= 0));
            } else {
                q.setRight(Boolean.valueOf(Objects.equals(this.normalizeCorrect(item.getCorrectAnswer()), this.normalizeCorrect(item.getUserAnswer()))));
            }
            q.setOptions(this.toReviewOptions(item.getOptionsJson()));
            questions.add(q);
        }
        return questions;
    }

    private List<TmsOnlineExamOptionVO> toReviewOptions(String json) {
        List<StoredOption> stored = this.parseOptions(json);
        ArrayList<TmsOnlineExamOptionVO> list = new ArrayList<TmsOnlineExamOptionVO>(stored.size());
        for (StoredOption opt : stored) {
            TmsOnlineExamOptionVO vo = new TmsOnlineExamOptionVO();
            vo.setOptionLabel(opt.getOptionLabel());
            vo.setOptionContent(opt.getOptionContent());
            vo.setIsCorrect(opt.getIsCorrect());
            list.add(vo);
        }
        return list;
    }

    private List<TmsOnlineExamOptionVO> toClientOptions(String json) {
        List<StoredOption> stored = this.parseOptions(json);
        ArrayList<TmsOnlineExamOptionVO> list = new ArrayList<TmsOnlineExamOptionVO>(stored.size());
        for (StoredOption opt : stored) {
            TmsOnlineExamOptionVO vo = new TmsOnlineExamOptionVO();
            vo.setOptionLabel(opt.getOptionLabel());
            vo.setOptionContent(opt.getOptionContent());
            list.add(vo);
        }
        return list;
    }

    private TmsOnlineExamListVO toListVo(TmsPaperEntity paper, TmsExamEntity exam, String status) {
        TmsOnlineExamListVO vo = new TmsOnlineExamListVO();
        vo.setId(paper.getId());
        vo.setPaperId(paper.getId());
        vo.setPaperName(paper.getPaperName());
        vo.setStatus(status);
        vo.setExamStart(this.fmt(paper.getExamStart()));
        vo.setExamEnd(this.fmt(paper.getExamEnd()));
        vo.setExamTimeText(this.timeText(paper.getExamStart(), paper.getExamEnd()));
        vo.setTotalScore(paper.getTotalScore());
        vo.setPassScore(paper.getPassScore());
        vo.setDurationMin(paper.getDurationMin());
        if (exam != null && EXAM_SUBMITTED.equals(exam.getExamStatus())) {
            vo.setGotScore(exam.getTotalScore());
            vo.setPassFlag(exam.getPassFlag());
            vo.setExamId(exam.getId());
        } else if (exam != null) {
            vo.setExamId(exam.getId());
        }
        this.fillRetakeMeta(vo, paper.getId(), exam, UserProvider.getLoginUserId());
        return vo;
    }

    private void fillRetakeMeta(TmsOnlineExamListVO vo, String paperId, TmsExamEntity exam, String userId) {
        RetakeMeta meta = this.buildRetakeMeta(paperId, exam, userId);
        vo.setAttemptNo(meta.attemptNo);
        vo.setAttemptLabel(meta.attemptLabel);
        vo.setSubmittedCount(meta.submittedCount);
        vo.setRetakeLimit(meta.retakeLimit);
        vo.setRemainingRetakes(meta.remainingRetakes);
        vo.setCanRetake(meta.canRetake);
    }

    private void fillRetakeMeta(TmsOnlineExamDetailVO vo, String paperId, TmsExamEntity exam, String userId) {
        RetakeMeta meta = this.buildRetakeMeta(paperId, exam, userId);
        vo.setAttemptNo(meta.attemptNo);
        vo.setAttemptLabel(meta.attemptLabel);
        vo.setSubmittedCount(meta.submittedCount);
        vo.setRetakeLimit(meta.retakeLimit);
        vo.setRemainingRetakes(meta.remainingRetakes);
        vo.setCanRetake(meta.canRetake);
    }

    private RetakeMeta buildRetakeMeta(String paperId, TmsExamEntity exam, String userId) {
        RetakeMeta meta = new RetakeMeta();
        RetakeContext ctx = this.resolveRetake(userId, paperId);
        meta.retakeLimit = ctx.retakeLimit;
        meta.submittedCount = ctx.submittedCount == null ? 0 : ctx.submittedCount;
        meta.attemptNo = exam != null && exam.getAttemptNo() != null ? exam.getAttemptNo() : (ctx.nextAttemptNo != null ? ctx.nextAttemptNo : Integer.valueOf(1));
        meta.attemptLabel = this.attemptLabel(meta.attemptNo);
        if (meta.retakeLimit == null) {
            meta.remainingRetakes = 0;
            meta.canRetake = false;
        } else {
            int usedRetakes = Math.max(0, meta.submittedCount - 1);
            meta.remainingRetakes = Math.max(0, meta.retakeLimit - usedRetakes);
            boolean submittedFail = exam != null && EXAM_SUBMITTED.equals(exam.getExamStatus()) && !"1".equals(exam.getPassFlag());
            meta.canRetake = submittedFail && ctx.allowStart;
        }
        return meta;
    }

    private String attemptLabel(Integer attemptNo) {
        int n;
        int n2 = n = attemptNo == null ? 1 : attemptNo;
        if (n <= 1) {
            return "首考";
        }
        return "补考（第" + (n - 1) + "次）";
    }

    private Map<String, TmsExamEntity> loadLatestExams(String userId, List<TmsPaperEntity> papers) {
        HashMap<String, TmsExamEntity> map = new HashMap<String, TmsExamEntity>();
        if (papers.isEmpty() || StringUtil.isEmpty(userId)) {
            return map;
        }
        List<String> ids = papers.stream().map(TmsPaperEntity::getId).collect(Collectors.toList());
        LambdaQueryWrapper<TmsExamEntity> qw = new LambdaQueryWrapper<>();
        qw.eq(TmsExamEntity::getUserId, userId);
        qw.in(TmsExamEntity::getPaperId, ids);
        qw.orderByDesc(TmsExamEntity::getCreatorTime);
        for (TmsExamEntity exam : this.examMapper.selectList(qw)) {
            TmsExamEntity exists = map.get(exam.getPaperId());
            if (exists != null && !EXAM_DOING.equals(exam.getExamStatus())) continue;
            map.put(exam.getPaperId(), exam);
        }
        return map;
    }

    private TmsExamEntity latestExam(String userId, String paperId) {
        LambdaQueryWrapper<TmsExamEntity> qw = new LambdaQueryWrapper<>();
        qw.eq(TmsExamEntity::getUserId, userId);
        qw.eq(TmsExamEntity::getPaperId, paperId);
        qw.orderByDesc(TmsExamEntity::getCreatorTime);
        List<TmsExamEntity> list = this.examMapper.selectList(qw);
        TmsExamEntity picked = null;
        for (TmsExamEntity exam : list) {
            if (EXAM_DOING.equals(exam.getExamStatus())) {
                return exam;
            }
            if (picked != null) continue;
            picked = exam;
        }
        return picked;
    }

    private TmsExamEntity findDoing(String userId, String paperId) {
        LambdaQueryWrapper<TmsExamEntity> qw = new LambdaQueryWrapper<>();
        qw.eq(TmsExamEntity::getUserId, userId);
        qw.eq(TmsExamEntity::getPaperId, paperId);
        qw.eq(TmsExamEntity::getExamStatus, EXAM_DOING);
        qw.orderByDesc(TmsExamEntity::getCreatorTime);
        qw.last("limit 1");
        return this.examMapper.selectOne(qw);
    }

    private TmsExamEntity latestSubmitted(String userId, String paperId) {
        LambdaQueryWrapper<TmsExamEntity> qw = new LambdaQueryWrapper<>();
        qw.eq(TmsExamEntity::getUserId, userId);
        qw.eq(TmsExamEntity::getPaperId, paperId);
        qw.eq(TmsExamEntity::getExamStatus, EXAM_SUBMITTED);
        qw.orderByDesc(TmsExamEntity::getCreatorTime);
        qw.last("limit 1");
        return this.examMapper.selectOne(qw);
    }

    private RetakeContext resolveRetake(String userId, String paperId) {
        RetakeContext ctx = new RetakeContext();
        ctx.allowStart = true;
        ctx.nextAttemptNo = 1;
        TmsExamEntity last = this.latestSubmitted(userId, paperId);
        TmsPersonTaskEntity personTask = this.findActivePersonTask(userId, paperId);
        TmsTaskEntity task = null;
        if (personTask != null) {
            task = this.taskMapper.selectById((personTask.getTaskId()));
        }
        if (task != null) {
            ctx.taskId = task.getId();
            ctx.personTaskId = personTask == null ? null : personTask.getId();
            ctx.passScore = task.getPassScore();
            int retakeLimit = task.getRetakeLimit() == null ? 1 : Math.max(0, task.getRetakeLimit());
            long submitted = this.countSubmitted(userId, paperId, task.getId());
            ctx.retakeLimit = retakeLimit;
            ctx.submittedCount = (int)submitted;
            ctx.nextAttemptNo = (int)submitted + 1;
            if (last == null) {
                return ctx;
            }
            if ("1".equals(last.getPassFlag())) {
                ctx.allowStart = false;
                ctx.message = "该试卷已合格，无需重考";
                return ctx;
            }
            if (submitted > (long)retakeLimit) {
                ctx.allowStart = false;
                ctx.message = "补考次数已用尽（上限 " + retakeLimit + " 次）";
                return ctx;
            }
            return ctx;
        }
        if (last != null) {
            ctx.submittedCount = 1;
            ctx.retakeLimit = 0;
            ctx.allowStart = false;
            ctx.message = "该试卷已交卷";
        }
        return ctx;
    }

    private long countSubmitted(String userId, String paperId, String taskId) {
        Long cnt;
        LambdaQueryWrapper<TmsExamEntity> qw = new LambdaQueryWrapper<>();
        qw.eq(TmsExamEntity::getUserId, userId);
        qw.eq(TmsExamEntity::getPaperId, paperId);
        qw.eq(TmsExamEntity::getExamStatus, EXAM_SUBMITTED);
        if (StringUtil.isNotEmpty(taskId)) {
            qw.and(w -> ((w.eq(TmsExamEntity::getTaskId, taskId)).or()).isNull(TmsExamEntity::getTaskId));
        }
        return (cnt = this.examMapper.selectCount(qw)) == null ? 0L : cnt;
    }

    private TmsPersonTaskEntity findActivePersonTask(String userId, String paperId) {
        List<TmsTaskEntity> tasks = this.taskMapper.selectList(
                new LambdaQueryWrapper<TmsTaskEntity>()
                        .eq(TmsTaskEntity::getPaperId, paperId)
                        .eq(TmsTaskEntity::getPublishStatus, "published")
                        .orderByDesc(TmsTaskEntity::getPublishTime));
        for (TmsTaskEntity t : tasks) {
            TmsPersonTaskEntity pt = this.findPersonTask(t.getId(), userId);
            if (pt == null || "cancelled".equals(pt.getBizStatus())) {
                continue;
            }
            return pt;
        }
        return null;
    }

    private TmsPersonTaskEntity findPersonTask(String taskId, String userId) {
        return this.personTaskMapper.selectOne(new LambdaQueryWrapper<TmsPersonTaskEntity>()
                .eq(TmsPersonTaskEntity::getTaskId, taskId)
                .eq(TmsPersonTaskEntity::getUserId, userId)
                .last("limit 1"));
    }

    private TmsExamEntity requireDoingExam(String examId) {
        TmsExamEntity exam = this.examMapper.selectById(examId);
        if (exam == null) {
            throw new DataException("答卷不存在");
        }
        if (!Objects.equals(UserProvider.getLoginUserId(), exam.getUserId())) {
            throw new DataException("无权操作该答卷");
        }
        if (!EXAM_DOING.equals(exam.getExamStatus())) {
            throw new DataException("试卷已交卷");
        }
        return exam;
    }

    private TmsPaperEntity requireOpenPaper(String paperId) {
        TmsPaperEntity paper = this.paperMapper.selectById(paperId);
        if (paper == null) {
            throw new DataException("试卷不存在");
        }
        if (!STATUS_OPEN.equals(paper.getBizStatus())) {
            throw new DataException("试卷未开放，不能参加考试");
        }
        return paper;
    }

    private void assertExamWindow(TmsPaperEntity paper) {
        Date now = new Date();
        if (paper.getExamStart() != null && now.before(paper.getExamStart())) {
            throw new DataException("未到考试时间");
        }
        if (paper.getExamEnd() != null && now.after(paper.getExamEnd())) {
            throw new DataException("考试时间已结束");
        }
    }

    private List<TmsExamItemEntity> loadItems(String examId) {
        LambdaQueryWrapper<TmsExamItemEntity> qw = new LambdaQueryWrapper<>();
        qw.eq(TmsExamItemEntity::getForeignId, examId);
        qw.orderByAsc(TmsExamItemEntity::getSortNo);
        return this.examItemMapper.selectList(qw);
    }

    private Map<String, List<TmsQuestionOptionEntity>> loadOptions(List<String> questionIds) {
        if (questionIds == null || questionIds.isEmpty()) {
            return Collections.emptyMap();
        }
        LambdaQueryWrapper<TmsQuestionOptionEntity> qw = new LambdaQueryWrapper<>();
        qw.in(TmsQuestionOptionEntity::getForeignId, questionIds);
        qw.orderByAsc(TmsQuestionOptionEntity::getSortNo);
        HashMap<String, List<TmsQuestionOptionEntity>> map = new HashMap<String, List<TmsQuestionOptionEntity>>();
        for (TmsQuestionOptionEntity opt : this.optionMapper.selectList(qw)) {
            map.computeIfAbsent(opt.getForeignId(), k -> new ArrayList()).add(opt);
        }
        return map;
    }

    private List<StoredOption> toStoredOptions(List<TmsQuestionOptionEntity> opts) {
        ArrayList<StoredOption> list = new ArrayList<StoredOption>();
        for (TmsQuestionOptionEntity opt : opts) {
            StoredOption stored = new StoredOption();
            stored.setOptionLabel(opt.getOptionLabel());
            stored.setOptionContent(opt.getOptionContent());
            stored.setIsCorrect(opt.getIsCorrect());
            list.add(stored);
        }
        return list;
    }

    private String correctOf(QuestionSnap snap) {
        String type = snap.question.getQuestionType();
        if (TYPE_ESSAY.equals(type)) {
            return "";
        }
        if (TYPE_BLANK.equals(type)) {
            return snap.options.stream().map(StoredOption::getOptionContent).filter(StringUtil::isNotEmpty).collect(Collectors.joining("?"));
        }
        return snap.options.stream().filter(o -> "1".equals(o.getIsCorrect())).map(StoredOption::getOptionLabel).filter(StringUtil::isNotEmpty).sorted().collect(Collectors.joining(","));
    }

    private boolean answerRight(TmsExamItemEntity item, String userAnswer) {
        if (StringUtil.isEmpty(item.getCorrectAnswer())) {
            return false;
        }
        if (TYPE_BLANK.equals(item.getQuestionType())) {
            return item.getCorrectAnswer().trim().equals(userAnswer == null ? "" : userAnswer.trim());
        }
        return Objects.equals(this.normalizeCorrect(item.getCorrectAnswer()), this.normalizeCorrect(userAnswer));
    }

    private String normalizeAnswer(Object raw, String questionType) {
        if (raw == null) {
            return "";
        }
        if (TYPE_MULTI.equals(questionType)) {
            LinkedHashSet<String> labels = new LinkedHashSet<String>();
            if (raw instanceof List) {
                for (Object o : (List)raw) {
                    if (o == null || !StringUtil.isNotEmpty(String.valueOf(o))) continue;
                    labels.add(String.valueOf(o).trim());
                }
            } else {
                String text = String.valueOf(raw).trim();
                if (StringUtil.isNotEmpty(text)) {
                    for (String part : text.split("[,?]")) {
                        if (!StringUtil.isNotEmpty(part.trim())) continue;
                        labels.add(part.trim());
                    }
                }
            }
            return labels.stream().sorted().collect(Collectors.joining(","));
        }
        return String.valueOf(raw).trim();
    }

    private String normalizeCorrect(String correct) {
        if (StringUtil.isEmpty(correct)) {
            return "";
        }
        return Arrays.stream(correct.split("[,?]")).map(String::trim).filter(StringUtil::isNotEmpty).sorted().collect(Collectors.joining(","));
    }

    private boolean isTimedOut(TmsExamEntity exam) {
        Integer remain = this.remainSeconds(exam);
        return remain != null && remain <= 0;
    }

    private Integer remainSeconds(TmsExamEntity exam) {
        if (exam == null || exam.getDurationMin() == null || exam.getDurationMin() <= 0 || exam.getStartTime() == null) {
            return null;
        }
        long endMs = exam.getStartTime().getTime() + (long)exam.getDurationMin().intValue() * 60000L;
        long remain = (endMs - System.currentTimeMillis()) / 1000L;
        return (int)Math.max(0L, remain);
    }

    private String passFlag(BigDecimal score, BigDecimal passScore) {
        if (passScore == null) {
            return null;
        }
        return this.nvl(score).compareTo(passScore) >= 0 ? "1" : "0";
    }

    private String statusOf(TmsExamEntity exam) {
        if (exam == null) {
            return NOT_STARTED;
        }
        if (EXAM_DOING.equals(exam.getExamStatus())) {
            return EXAM_DOING;
        }
        return EXAM_SUBMITTED;
    }

    private String timeText(Date start, Date end) {
        if (start == null && end == null) {
            return "??";
        }
        String left = start == null ? "??" : this.fmt(start);
        String right = end == null ? "??" : this.fmt(end);
        return left + " ~ " + right;
    }

    private String fmt(Date date) {
        return date == null ? null : DateUtil.dateToString((Date)date, (String)FMT);
    }

    private BigDecimal nvl(BigDecimal value) {
        return value == null ? BigDecimal.ZERO : value;
    }

    private String toJson(Object obj) {
        try {
            return OBJECT_MAPPER.writeValueAsString(obj);
        }
        catch (Exception e) {
            throw new DataException("JSON序列化失败");
        }
    }

    private List<StoredOption> parseOptions(String json) {
        if (StringUtil.isEmpty(json)) {
            return Collections.emptyList();
        }
        try {
            return (List)OBJECT_MAPPER.readValue(json, (TypeReference)new TypeReference<List<StoredOption>>(){});
        }
        catch (Exception e) {
            return Collections.emptyList();
        }
    }

    private static class RetakeContext {
        private boolean allowStart;
        private String message;
        private String taskId;
        private String personTaskId;
        private Integer nextAttemptNo;
        private BigDecimal passScore;
        private Integer retakeLimit;
        private Integer submittedCount;

        private RetakeContext() {
        }
    }

    private static class QuestionSnap {
        private TmsQuestionEntity question;
        private BigDecimal score;
        private List<StoredOption> options;

        private QuestionSnap() {
        }
    }

    @JsonIgnoreProperties(ignoreUnknown=true)
    private static class StoredOption {
        private String optionLabel;
        private String optionContent;
        private String isCorrect;
        public StoredOption() {
        }
        public String getOptionLabel() {
            return this.optionLabel;
        }
        public String getOptionContent() {
            return this.optionContent;
        }
        public String getIsCorrect() {
            return this.isCorrect;
        }
        public void setOptionLabel(String optionLabel) {
            this.optionLabel = optionLabel;
        }
        public void setOptionContent(String optionContent) {
            this.optionContent = optionContent;
        }
        public void setIsCorrect(String isCorrect) {
            this.isCorrect = isCorrect;
        }
        public boolean equals(Object o) {
            if (o == this) {
                return true;
            }
            if (!(o instanceof StoredOption)) {
                return false;
            }
            StoredOption other = (StoredOption)o;
            if (!other.canEqual(this)) {
                return false;
            }
            String this$optionLabel = this.getOptionLabel();
            String other$optionLabel = other.getOptionLabel();
            if (this$optionLabel == null ? other$optionLabel != null : !this$optionLabel.equals(other$optionLabel)) {
                return false;
            }
            String this$optionContent = this.getOptionContent();
            String other$optionContent = other.getOptionContent();
            if (this$optionContent == null ? other$optionContent != null : !this$optionContent.equals(other$optionContent)) {
                return false;
            }
            String this$isCorrect = this.getIsCorrect();
            String other$isCorrect = other.getIsCorrect();
            return !(this$isCorrect == null ? other$isCorrect != null : !this$isCorrect.equals(other$isCorrect));
        }
        protected boolean canEqual(Object other) {
            return other instanceof StoredOption;
        }
        public int hashCode() {
            int PRIME = 59;
            int result = 1;
            String $optionLabel = this.getOptionLabel();
            result = result * 59 + ($optionLabel == null ? 43 : $optionLabel.hashCode());
            String $optionContent = this.getOptionContent();
            result = result * 59 + ($optionContent == null ? 43 : $optionContent.hashCode());
            String $isCorrect = this.getIsCorrect();
            result = result * 59 + ($isCorrect == null ? 43 : $isCorrect.hashCode());
            return result;
        }
        public String toString() {
            return "TmsOnlineExamServiceImpl.StoredOption(optionLabel=" + this.getOptionLabel() + ", optionContent=" + this.getOptionContent() + ", isCorrect=" + this.getIsCorrect() + ")";
        }
    }

    /** 超时已自动交卷：配合 noRollbackFor，保证交卷结果先提交 */
    public static class ExamTimedOutException extends DataException {
        public ExamTimedOutException() {
            super("考试时间已到，已自动交卷");
        }
    }

    private static class RetakeMeta {
        private Integer attemptNo;
        private String attemptLabel;
        private Integer submittedCount;
        private Integer retakeLimit;
        private Integer remainingRetakes;
        private Boolean canRetake;

        private RetakeMeta() {
        }
    }
}