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 jnpf.exception.DataException;
import jnpf.permission.UserApi;
import jnpf.permission.entity.UserEntity;
import jnpf.tmsEntity.TmsExamEntity;
import jnpf.tmsEntity.TmsExamItemEntity;
import jnpf.tmsEntity.TmsPaperEntity;
import jnpf.tmsEntity.examgrade.TmsExamGradeDetailVO;
import jnpf.tmsEntity.examgrade.TmsExamGradeExamVO;
import jnpf.tmsEntity.examgrade.TmsExamGradeItemVO;
import jnpf.tmsEntity.examgrade.TmsExamGradeOptionVO;
import jnpf.tmsEntity.examgrade.TmsExamGradeQuery;
import jnpf.tmsEntity.examgrade.TmsExamGradeSessionVO;
import jnpf.tmsEntity.examgrade.TmsExamGradeSubmitForm;
import jnpf.tmsEntity.examgrade.TmsExamGradeSubmitResultVO;
import jnpf.tmsMapper.TmsExamItemMapper;
import jnpf.tmsMapper.TmsExamMapper;
import jnpf.tmsMapper.TmsPaperMapper;
import jnpf.tmsService.TmsExamGradeService;
import jnpf.util.DateUtil;
import jnpf.util.StringUtil;
import jnpf.util.UserProvider;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

@Service
@RequiredArgsConstructor
public class TmsExamGradeServiceImpl implements TmsExamGradeService {

    private static final String EXAM_SUBMITTED = "submitted";
    private static final String GRADE_PENDING = "pending";
    private static final String GRADE_GRADED = "graded";
    private static final String FMT = "yyyy-MM-dd HH:mm:ss";
    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();

    private final TmsExamMapper examMapper;
    private final TmsExamItemMapper examItemMapper;
    private final TmsPaperMapper paperMapper;
    private final UserApi userApi;

    @Override
    public List<TmsExamGradeSessionVO> getSessionList(TmsExamGradeQuery query) {
        List<TmsExamEntity> exams = loadGradeExams(null);
        Map<String, List<TmsExamEntity>> byPaper = groupByPaper(exams);
        Map<String, TmsPaperEntity> papers = loadPapers(new ArrayList<>(byPaper.keySet()));

        List<TmsExamGradeSessionVO> all = new ArrayList<>();
        for (Map.Entry<String, List<TmsExamEntity>> entry : byPaper.entrySet()) {
            all.add(toSession(entry.getKey(), papers.get(entry.getKey()), entry.getValue()));
        }
        all.sort(Comparator
                .comparing(TmsExamGradeSessionVO::getPendingCount, Comparator.nullsLast(Integer::compareTo)).reversed()
                .thenComparing(TmsExamGradeSessionVO::getExamEnd, Comparator.nullsLast(String::compareTo)).reversed());

        String keyword = trim(query.getKeyword());
        String taskNo = trim(query.getTaskNo());
        if (StringUtil.isNotEmpty(keyword)) {
            String kw = keyword.toLowerCase();
            all = all.stream()
                    .filter(x -> contains(x.getTaskSubject(), kw)
                            || contains(x.getPaperName(), kw)
                            || contains(x.getTaskNo(), kw))
                    .collect(Collectors.toList());
        }
        if (StringUtil.isNotEmpty(taskNo)) {
            String tn = taskNo.toLowerCase();
            all = all.stream().filter(x -> contains(x.getTaskNo(), tn)).collect(Collectors.toList());
        }

        long current = query.getCurrentPage() > 0 ? query.getCurrentPage() : 1;
        long size = query.getPageSize() > 0 ? query.getPageSize() : 20;
        int from = (int) ((current - 1) * size);
        int to = Math.min(from + (int) size, all.size());
        List<TmsExamGradeSessionVO> page = from >= all.size() ? new ArrayList<>() : new ArrayList<>(all.subList(from, to));
        query.setData(page, all.size());
        return page;
    }

    @Override
    public TmsExamGradeSessionVO getSession(String sessionId) {
        if (StringUtil.isEmpty(sessionId)) {
            throw new DataException("阅卷场次不存在");
        }
        List<TmsExamEntity> exams = loadGradeExams(sessionId);
        if (exams.isEmpty()) {
            throw new DataException("阅卷场次不存在");
        }
        return toSession(sessionId, paperMapper.selectById(sessionId), exams);
    }

    @Override
    public List<TmsExamGradeExamVO> getExamList(String sessionId) {
        if (StringUtil.isEmpty(sessionId)) {
            return Collections.emptyList();
        }
        List<TmsExamEntity> exams = loadGradeExams(sessionId);
        exams.sort(Comparator.comparing(TmsExamEntity::getSubmitTime, Comparator.nullsLast(Date::compareTo)).reversed());
        Map<String, String> names = loadUserNames(exams.stream().map(TmsExamEntity::getUserId).collect(Collectors.toList()));
        List<TmsExamGradeExamVO> rows = new ArrayList<>();
        for (TmsExamEntity exam : exams) {
            TmsExamGradeExamVO vo = new TmsExamGradeExamVO();
            vo.setId(exam.getId());
            vo.setSessionId(sessionId);
            vo.setUserId(exam.getUserId());
            vo.setUserName(names.getOrDefault(exam.getUserId(), exam.getUserId()));
            vo.setSubmitTime(fmt(exam.getSubmitTime()));
            vo.setObjectiveScore(exam.getObjectiveScore());
            vo.setSubjectiveScore(exam.getSubjectiveScore());
            vo.setTotalScore(GRADE_PENDING.equals(exam.getGradeStatus()) ? null : exam.getTotalScore());
            vo.setPassScore(exam.getPassScore());
            vo.setGradeStatus(exam.getGradeStatus());
            vo.setPassFlag(exam.getPassFlag());
            rows.add(vo);
        }
        return rows;
    }

    @Override
    public TmsExamGradeDetailVO getExamDetail(String examId) {
        TmsExamEntity exam = requireGradeExam(examId);
        List<TmsExamItemEntity> items = loadItems(exam.getId());
        Map<String, String> names = loadUserNames(Collections.singletonList(exam.getUserId()));

        TmsExamGradeDetailVO vo = new TmsExamGradeDetailVO();
        vo.setExamId(exam.getId());
        vo.setSessionId(exam.getPaperId());
        vo.setPaperName(exam.getPaperName());
        vo.setUserName(names.getOrDefault(exam.getUserId(), exam.getUserId()));
        vo.setSubmitTime(fmt(exam.getSubmitTime()));
        vo.setTotalScore(resolvePaperTotal(exam));
        vo.setPassScore(exam.getPassScore());
        vo.setObjectiveScore(nvl(exam.getObjectiveScore()));
        vo.setSubjectiveScore(nvl(exam.getSubjectiveScore()));
        vo.setGradeStatus(exam.getGradeStatus());
        vo.setItems(items.stream().map(this::toItemVo).collect(Collectors.toList()));
        return vo;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public TmsExamGradeSubmitResultVO submitGrade(TmsExamGradeSubmitForm form) {
        if (form == null || StringUtil.isEmpty(form.getExamId())) {
            throw new DataException("答卷不存在");
        }
        TmsExamEntity exam = requireGradeExam(form.getExamId());
        if (!GRADE_PENDING.equals(exam.getGradeStatus())) {
            throw new DataException("该答卷已批改，无需重复提交");
        }
        List<TmsExamItemEntity> items = loadItems(exam.getId());
        Map<String, BigDecimal> scoreMap = new HashMap<>();
        if (form.getItems() != null) {
            for (TmsExamGradeSubmitForm.ItemScore row : form.getItems()) {
                if (row == null || StringUtil.isEmpty(row.getId())) {
                    continue;
                }
                scoreMap.put(row.getId(), row.getGotScore());
            }
        }

        BigDecimal subjective = BigDecimal.ZERO;
        Date now = new Date();
        String graderId = UserProvider.getLoginUserId();
        for (TmsExamItemEntity item : items) {
            if (!"1".equals(item.getIsSubjective())) {
                continue;
            }
            if (!scoreMap.containsKey(item.getId()) || scoreMap.get(item.getId()) == null) {
                throw new DataException("请为所有主观题打分");
            }
            BigDecimal got = scoreMap.get(item.getId());
            BigDecimal max = nvl(item.getScore());
            if (got.compareTo(BigDecimal.ZERO) < 0 || got.compareTo(max) > 0) {
                throw new DataException("主观题得分需在 0 ~ " + max.stripTrailingZeros().toPlainString() + " 之间");
            }
            item.setGotScore(got);
            item.setLastModifyUserId(graderId);
            item.setLastModifyTime(now);
            examItemMapper.updateById(item);
            subjective = subjective.add(got);
        }

        BigDecimal objective = nvl(exam.getObjectiveScore());
        BigDecimal total = objective.add(subjective);
        exam.setSubjectiveScore(subjective);
        exam.setTotalScore(total);
        exam.setPassFlag(passFlag(total, exam.getPassScore()));
        exam.setGradeStatus(GRADE_GRADED);
        exam.setGraderId(graderId);
        exam.setGradeTime(now);
        exam.setLastModifyUserId(graderId);
        exam.setLastModifyTime(now);
        examMapper.updateById(exam);

        TmsExamGradeSubmitResultVO result = new TmsExamGradeSubmitResultVO();
        result.setExamId(exam.getId());
        result.setSubjectiveScore(subjective);
        result.setTotalScore(total);
        result.setPassFlag(exam.getPassFlag());
        result.setGradeStatus(GRADE_GRADED);
        result.setNextExamId(findNextPending(exam.getPaperId(), exam.getId()));
        return result;
    }

    private String findNextPending(String paperId, String excludeExamId) {
        List<TmsExamEntity> exams = loadGradeExams(paperId);
        return exams.stream()
                .filter(x -> GRADE_PENDING.equals(x.getGradeStatus()))
                .filter(x -> !Objects.equals(x.getId(), excludeExamId))
                .sorted(Comparator.comparing(TmsExamEntity::getSubmitTime, Comparator.nullsLast(Date::compareTo)))
                .map(TmsExamEntity::getId)
                .findFirst()
                .orElse(null);
    }

    private TmsExamEntity requireGradeExam(String examId) {
        if (StringUtil.isEmpty(examId)) {
            throw new DataException("答卷不存在");
        }
        TmsExamEntity exam = examMapper.selectById(examId);
        if (exam == null || !EXAM_SUBMITTED.equals(exam.getExamStatus())) {
            throw new DataException("答卷不存在");
        }
        if (!GRADE_PENDING.equals(exam.getGradeStatus()) && !GRADE_GRADED.equals(exam.getGradeStatus())) {
            throw new DataException("该答卷无需阅卷");
        }
        return exam;
    }

    private List<TmsExamEntity> loadGradeExams(String paperId) {
        LambdaQueryWrapper<TmsExamEntity> qw = new LambdaQueryWrapper<>();
        qw.eq(TmsExamEntity::getExamStatus, EXAM_SUBMITTED)
                .in(TmsExamEntity::getGradeStatus, GRADE_PENDING, GRADE_GRADED)
                .eq(StringUtil.isNotEmpty(paperId), TmsExamEntity::getPaperId, paperId)
                .orderByDesc(TmsExamEntity::getSubmitTime);
        return examMapper.selectList(qw);
    }

    private Map<String, List<TmsExamEntity>> groupByPaper(List<TmsExamEntity> exams) {
        Map<String, List<TmsExamEntity>> map = new LinkedHashMap<>();
        for (TmsExamEntity exam : exams) {
            if (StringUtil.isEmpty(exam.getPaperId())) {
                continue;
            }
            map.computeIfAbsent(exam.getPaperId(), k -> new ArrayList<>()).add(exam);
        }
        return map;
    }

    private Map<String, TmsPaperEntity> loadPapers(List<String> ids) {
        if (ids == null || ids.isEmpty()) {
            return Collections.emptyMap();
        }
        List<TmsPaperEntity> list = paperMapper.selectBatchIds(ids);
        Map<String, TmsPaperEntity> map = new HashMap<>();
        for (TmsPaperEntity paper : list) {
            map.put(paper.getId(), paper);
        }
        return map;
    }

    private TmsExamGradeSessionVO toSession(String paperId, TmsPaperEntity paper, List<TmsExamEntity> exams) {
        TmsExamGradeSessionVO vo = new TmsExamGradeSessionVO();
        vo.setId(paperId);
        vo.setPaperId(paperId);
        String paperName = paper != null && StringUtil.isNotEmpty(paper.getPaperName())
                ? paper.getPaperName()
                : (exams.isEmpty() ? paperId : exams.get(0).getPaperName());
        vo.setPaperName(paperName);
        vo.setTaskSubject(paperName);
        String paperNo = paper != null && StringUtil.isNotEmpty(paper.getPaperNo()) ? paper.getPaperNo() : paperId;
        vo.setTaskNo(paperNo);
        vo.setDurationMin(paper != null && paper.getDurationMin() != null
                ? paper.getDurationMin()
                : (exams.isEmpty() ? null : exams.get(0).getDurationMin()));
        vo.setTotalScore(paper != null && paper.getTotalScore() != null
                ? paper.getTotalScore()
                : resolvePaperTotal(exams.isEmpty() ? null : exams.get(0)));
        vo.setPassScore(paper != null && paper.getPassScore() != null
                ? paper.getPassScore()
                : (exams.isEmpty() ? null : exams.get(0).getPassScore()));

        Date start = paper != null ? paper.getExamStart() : null;
        Date end = paper != null ? paper.getExamEnd() : null;
        if (start == null) {
            start = exams.stream().map(TmsExamEntity::getStartTime).filter(Objects::nonNull).min(Date::compareTo).orElse(null);
        }
        if (end == null) {
            end = exams.stream().map(TmsExamEntity::getSubmitTime).filter(Objects::nonNull).max(Date::compareTo).orElse(null);
        }
        vo.setExamStart(fmt(start));
        vo.setExamEnd(fmt(end));
        vo.setSubmittedCount(exams.size());
        vo.setPendingCount((int) exams.stream().filter(x -> GRADE_PENDING.equals(x.getGradeStatus())).count());
        return vo;
    }

    private BigDecimal resolvePaperTotal(TmsExamEntity exam) {
        if (exam == null) {
            return BigDecimal.ZERO;
        }
        if (exam.getPaperId() != null) {
            TmsPaperEntity paper = paperMapper.selectById(exam.getPaperId());
            if (paper != null && paper.getTotalScore() != null) {
                return paper.getTotalScore();
            }
        }
        return nvl(exam.getTotalScore());
    }

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

    private TmsExamGradeItemVO toItemVo(TmsExamItemEntity item) {
        TmsExamGradeItemVO vo = new TmsExamGradeItemVO();
        vo.setId(item.getId());
        vo.setQuestionType(item.getQuestionType());
        vo.setStem(item.getStem());
        vo.setOptions(parseOptions(item.getOptionsJson()));
        vo.setCorrectAnswer(item.getCorrectAnswer());
        vo.setUserAnswer(item.getUserAnswer());
        vo.setScore(item.getScore());
        vo.setGotScore(item.getGotScore());
        vo.setIsSubjective(item.getIsSubjective());
        vo.setAnalysis(item.getAnalysis());
        return vo;
    }

    private List<TmsExamGradeOptionVO> parseOptions(String json) {
        if (StringUtil.isEmpty(json)) {
            return Collections.emptyList();
        }
        try {
            List<OptSnap> list = OBJECT_MAPPER.readValue(json, new TypeReference<List<OptSnap>>() {});
            List<TmsExamGradeOptionVO> options = new ArrayList<>();
            for (OptSnap snap : list) {
                TmsExamGradeOptionVO opt = new TmsExamGradeOptionVO();
                opt.setOptionLabel(snap.getOptionLabel());
                opt.setOptionContent(snap.getOptionContent());
                options.add(opt);
            }
            return options;
        } catch (Exception e) {
            return Collections.emptyList();
        }
    }

    private Map<String, String> loadUserNames(List<String> userIds) {
        Map<String, String> map = new HashMap<>();
        List<String> ids = userIds == null ? Collections.emptyList()
                : userIds.stream().filter(StringUtil::isNotEmpty).distinct().collect(Collectors.toList());
        if (ids.isEmpty()) {
            return map;
        }
        try {
            List<UserEntity> users = userApi.getUserName(ids);
            if (users != null) {
                for (UserEntity user : users) {
                    if (user == null || StringUtil.isEmpty(user.getId())) {
                        continue;
                    }
                    map.put(user.getId(), StringUtil.isNotEmpty(user.getRealName()) ? user.getRealName() : user.getId());
                }
            }
        } catch (Exception ignored) {
            // 用户服务不可用时回退 userId
        }
        return map;
    }

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

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

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

    private String trim(String value) {
        return value == null || "null".equalsIgnoreCase(value) ? "" : value.trim();
    }

    private boolean contains(String text, String kw) {
        return text != null && text.toLowerCase().contains(kw);
    }

    @Data
    @JsonIgnoreProperties(ignoreUnknown = true)
    private static class OptSnap {
        private String optionLabel;
        private String optionContent;
    }
}