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.examscore.TmsExamScoreDetailVO;
import jnpf.tmsEntity.examscore.TmsExamScoreOptionVO;
import jnpf.tmsEntity.examscore.TmsExamScorePaperItemVO;
import jnpf.tmsEntity.examscore.TmsExamScorePaperVO;
import jnpf.tmsEntity.examscore.TmsExamScoreQuery;
import jnpf.tmsEntity.examscore.TmsExamScoreRowVO;
import jnpf.tmsEntity.examscore.TmsExamScoreSummaryVO;
import jnpf.tmsMapper.TmsExamItemMapper;
import jnpf.tmsMapper.TmsExamMapper;
import jnpf.tmsMapper.TmsPaperMapper;
import jnpf.tmsService.TmsExamScoreService;
import jnpf.util.DateUtil;
import jnpf.util.StringUtil;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
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 TmsExamScoreServiceImpl implements TmsExamScoreService {

    private static final String EXAM_SUBMITTED = "submitted";
    private static final String STATUS_INVALID = "invalid";
    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<TmsExamScoreSummaryVO> getList(TmsExamScoreQuery query) {
        List<TmsExamEntity> exams = loadSubmittedExams();
        Map<String, List<TmsExamEntity>> byPaper = groupByPaper(exams);
        Map<String, TmsPaperEntity> papers = loadPapers(new ArrayList<>(byPaper.keySet()));

        List<TmsExamScoreSummaryVO> all = new ArrayList<>();
        for (Map.Entry<String, List<TmsExamEntity>> entry : byPaper.entrySet()) {
            TmsPaperEntity paper = papers.get(entry.getKey());
            all.add(toSummary(entry.getKey(), paper, entry.getValue()));
        }
        all.sort(Comparator.comparing(TmsExamScoreSummaryVO::getPaperName, 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<TmsExamScoreSummaryVO> page = from >= all.size() ? new ArrayList<>() : new ArrayList<>(all.subList(from, to));
        query.setData(page, all.size());
        return page;
    }

    @Override
    public TmsExamScoreDetailVO getDetail(String summaryId) {
        if (StringUtil.isEmpty(summaryId)) {
            throw new DataException("成绩汇总不存在");
        }
        List<TmsExamEntity> exams = loadSubmittedByPaper(summaryId);
        if (exams.isEmpty()) {
            throw new DataException("成绩汇总不存在");
        }
        TmsPaperEntity paper = paperMapper.selectById(summaryId);
        TmsExamScoreSummaryVO summary = toSummary(summaryId, paper, exams);
        Map<String, String> names = loadUserNames(exams.stream().map(TmsExamEntity::getUserId).collect(Collectors.toList()));

        List<TmsExamScoreRowVO> rows = new ArrayList<>();
        for (TmsExamEntity exam : exams) {
            TmsExamScoreRowVO row = new TmsExamScoreRowVO();
            row.setId(exam.getId());
            row.setSummaryId(summaryId);
            row.setTaskSubject(summary.getTaskSubject());
            row.setTaskNo(summary.getTaskNo());
            row.setUserId(exam.getUserId());
            row.setUserName(names.getOrDefault(exam.getUserId(), exam.getUserId()));
            row.setExamStart(fmt(exam.getStartTime()));
            row.setExamEnd(fmt(exam.getSubmitTime()));
            row.setScore(exam.getTotalScore());
            row.setPassScore(exam.getPassScore() != null ? exam.getPassScore() : summary.getPassScore());
            row.setPassFlag(exam.getPassFlag());
            rows.add(row);
        }
        rows.sort(Comparator.comparing(TmsExamScoreRowVO::getExamEnd, Comparator.nullsLast(String::compareTo)).reversed());

        TmsExamScoreDetailVO detail = new TmsExamScoreDetailVO();
        BeanUtils.copyProperties(summary, detail);
        detail.setRows(rows);
        return detail;
    }

    @Override
    public TmsExamScorePaperVO getPaperView(String examId) {
        TmsExamEntity exam = examMapper.selectById(examId);
        if (exam == null || !EXAM_SUBMITTED.equals(exam.getExamStatus())) {
            throw new DataException("答卷不存在或尚未交卷");
        }
        TmsPaperEntity paper = paperMapper.selectById(exam.getPaperId());
        Map<String, String> names = loadUserNames(Collections.singletonList(exam.getUserId()));

        LambdaQueryWrapper<TmsExamItemEntity> qw = new LambdaQueryWrapper<>();
        qw.eq(TmsExamItemEntity::getForeignId, examId);
        qw.orderByAsc(TmsExamItemEntity::getSortNo);
        List<TmsExamItemEntity> items = examItemMapper.selectList(qw);

        BigDecimal paperTotal = BigDecimal.ZERO;
        List<TmsExamScorePaperItemVO> itemVos = new ArrayList<>();
        for (TmsExamItemEntity item : items) {
            paperTotal = paperTotal.add(nvl(item.getScore()));
            TmsExamScorePaperItemVO vo = new TmsExamScorePaperItemVO();
            vo.setId(item.getId());
            vo.setQuestionType(item.getQuestionType());
            vo.setStem(item.getStem());
            vo.setOptions(toOptions(item.getOptionsJson()));
            vo.setCorrectAnswer(item.getCorrectAnswer());
            vo.setUserAnswer(item.getUserAnswer());
            vo.setScore(item.getScore());
            vo.setGotScore(item.getGotScore());
            vo.setIsSubjective(item.getIsSubjective());
            if ("1".equals(item.getIsSubjective())) {
                vo.setIsCorrect(null);
            } else if (item.getScore() != null && item.getScore().compareTo(BigDecimal.ZERO) > 0) {
                vo.setIsCorrect(nvl(item.getGotScore()).compareTo(item.getScore()) >= 0);
            } else {
                vo.setIsCorrect(Objects.equals(normalize(item.getCorrectAnswer()), normalize(item.getUserAnswer())));
            }
            itemVos.add(vo);
        }

        TmsExamScorePaperVO vo = new TmsExamScorePaperVO();
        vo.setExamId(exam.getId());
        vo.setSummaryId(exam.getPaperId());
        vo.setTaskSubject(paper != null ? paper.getPaperName() : exam.getPaperName());
        vo.setTaskNo(paper != null && StringUtil.isNotEmpty(paper.getPaperNo()) ? paper.getPaperNo() : exam.getPaperId());
        vo.setPaperName(exam.getPaperName());
        vo.setUserId(exam.getUserId());
        vo.setUserName(names.getOrDefault(exam.getUserId(), exam.getUserId()));
        vo.setExamStart(fmt(exam.getStartTime()));
        vo.setExamEnd(fmt(exam.getSubmitTime()));
        vo.setScore(exam.getTotalScore());
        vo.setPassScore(exam.getPassScore());
        vo.setTotalScore(paper != null && paper.getTotalScore() != null ? paper.getTotalScore() : paperTotal);
        vo.setPassFlag(exam.getPassFlag());
        vo.setItems(itemVos);
        return vo;
    }

    @Override
    public List<TmsExamScoreRowVO> exportRows(List<String> summaryIds) {
        if (summaryIds == null || summaryIds.isEmpty()) {
            throw new DataException("请选择要导出的考试");
        }
        List<TmsExamScoreRowVO> rows = new ArrayList<>();
        for (String id : summaryIds) {
            if (StringUtil.isEmpty(id)) {
                continue;
            }
            List<TmsExamEntity> exams = loadSubmittedByPaper(id);
            if (exams.isEmpty()) {
                continue;
            }
            TmsExamScoreDetailVO detail = getDetail(id);
            if (detail.getRows() != null) {
                rows.addAll(detail.getRows());
            }
        }
        if (rows.isEmpty()) {
            throw new DataException("所选试卷暂无已交卷成绩");
        }
        return rows;
    }

    private TmsExamScoreSummaryVO toSummary(String paperId, TmsPaperEntity paper, List<TmsExamEntity> exams) {
        TmsExamScoreSummaryVO vo = new TmsExamScoreSummaryVO();
        vo.setId(paperId);
        vo.setPaperId(paperId);
        String paperName = paper != null ? 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.setPaperInvalid(paper != null && STATUS_INVALID.equals(paper.getBizStatus()));

        BigDecimal passScore = paper != null && paper.getPassScore() != null
                ? paper.getPassScore()
                : exams.stream().map(TmsExamEntity::getPassScore).filter(Objects::nonNull).findFirst().orElse(BigDecimal.ZERO);
        BigDecimal totalScore = paper != null && paper.getTotalScore() != null
                ? paper.getTotalScore()
                : BigDecimal.ZERO;
        vo.setPassScore(passScore);
        vo.setTotalScore(totalScore);

        int fail = 0;
        BigDecimal max = null;
        BigDecimal min = null;
        BigDecimal sum = BigDecimal.ZERO;
        int scored = 0;
        for (TmsExamEntity exam : exams) {
            if ("0".equals(exam.getPassFlag())) {
                fail++;
            }
            BigDecimal score = exam.getTotalScore();
            if (score == null) {
                continue;
            }
            scored++;
            sum = sum.add(score);
            if (max == null || score.compareTo(max) > 0) {
                max = score;
            }
            if (min == null || score.compareTo(min) < 0) {
                min = score;
            }
        }
        vo.setParticipantCount(exams.size());
        vo.setFailCount(fail);
        vo.setMaxScore(max == null ? BigDecimal.ZERO : max);
        vo.setMinScore(min == null ? BigDecimal.ZERO : min);
        vo.setAvgScore(scored == 0
                ? BigDecimal.ZERO
                : sum.divide(BigDecimal.valueOf(scored), 1, RoundingMode.HALF_UP));
        return vo;
    }

    private List<TmsExamEntity> loadSubmittedExams() {
        LambdaQueryWrapper<TmsExamEntity> qw = new LambdaQueryWrapper<>();
        qw.eq(TmsExamEntity::getExamStatus, EXAM_SUBMITTED);
        qw.isNotNull(TmsExamEntity::getPaperId);
        qw.orderByDesc(TmsExamEntity::getSubmitTime);
        return examMapper.selectList(qw);
    }

    private List<TmsExamEntity> loadSubmittedByPaper(String paperId) {
        LambdaQueryWrapper<TmsExamEntity> qw = new LambdaQueryWrapper<>();
        qw.eq(TmsExamEntity::getExamStatus, EXAM_SUBMITTED);
        qw.eq(TmsExamEntity::getPaperId, paperId);
        qw.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> paperIds) {
        if (paperIds == null || paperIds.isEmpty()) {
            return Collections.emptyMap();
        }
        Map<String, TmsPaperEntity> map = new HashMap<>();
        for (TmsPaperEntity paper : paperMapper.selectBatchIds(paperIds)) {
            map.put(paper.getId(), paper);
        }
        return map;
    }

    private Map<String, String> loadUserNames(List<String> userIds) {
        if (userIds == null || userIds.isEmpty()) {
            return Collections.emptyMap();
        }
        List<String> ids = userIds.stream().filter(StringUtil::isNotEmpty).distinct().collect(Collectors.toList());
        if (ids.isEmpty()) {
            return Collections.emptyMap();
        }
        try {
            List<UserEntity> users = userApi.getUserName(ids);
            if (users == null || users.isEmpty()) {
                return Collections.emptyMap();
            }
            return users.stream()
                    .filter(Objects::nonNull)
                    .collect(Collectors.toMap(UserEntity::getId, UserEntity::getRealName, (a, b) -> a));
        } catch (Exception ex) {
            return Collections.emptyMap();
        }
    }

    private List<TmsExamScoreOptionVO> toOptions(String json) {
        if (StringUtil.isEmpty(json)) {
            return Collections.emptyList();
        }
        try {
            List<StoredOption> stored = OBJECT_MAPPER.readValue(json, new TypeReference<List<StoredOption>>() {
            });
            List<TmsExamScoreOptionVO> list = new ArrayList<>();
            for (StoredOption opt : stored) {
                TmsExamScoreOptionVO vo = new TmsExamScoreOptionVO();
                vo.setOptionLabel(opt.getOptionLabel());
                vo.setOptionContent(opt.getOptionContent());
                list.add(vo);
            }
            return list;
        } catch (Exception e) {
            return Collections.emptyList();
        }
    }

    private String normalize(String text) {
        if (StringUtil.isEmpty(text)) {
            return "";
        }
        return text.trim();
    }

    private String trim(String text) {
        if (StringUtil.isEmpty(text) || "null".equalsIgnoreCase(text)) {
            return null;
        }
        return text.trim();
    }

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

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

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

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