package jnpf.tmsService.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import jnpf.exception.DataException;
import jnpf.tmsEntity.TmsMaterialEntity;
import jnpf.tmsEntity.TmsPersonTaskEntity;
import jnpf.tmsEntity.TmsTaskEntity;
import jnpf.tmsEntity.TmsTaskFileEntity;
import jnpf.tmsEntity.TmsTrainModeEntity;
import jnpf.tmsEntity.person.TmsPersonTaskFileForm;
import jnpf.tmsEntity.person.TmsPersonTaskLearnResult;
import jnpf.tmsEntity.person.TmsPersonTaskMineForm;
import jnpf.tmsEntity.person.TmsPersonTaskQuery;
import jnpf.tmsEntity.person.TmsPersonTaskSignResult;
import jnpf.tmsMapper.TmsMaterialMapper;
import jnpf.tmsMapper.TmsPersonTaskMapper;
import jnpf.tmsMapper.TmsTaskFileMapper;
import jnpf.tmsMapper.TmsTaskMapper;
import jnpf.tmsMapper.TmsTrainModeMapper;
import jnpf.tmsService.TmsPersonTaskService;
import jnpf.util.DateUtil;
import jnpf.util.StringUtil;
import jnpf.util.UserProvider;
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.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

@Service
@RequiredArgsConstructor
public class TmsPersonTaskServiceImpl implements TmsPersonTaskService {

    private static final String FMT = "yyyy-MM-dd HH:mm:ss";
    private static final String STATUS_CANCELLED = "cancelled";
    private static final String STATUS_DONE = "done";
    private static final String STATUS_SIGNED = "signed";
    private static final String STATUS_TODO = "todo";
    private static final String SIGN_MODE_ONLINE = "online";
    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();

    private final TmsPersonTaskMapper personTaskMapper;
    private final TmsTaskMapper taskMapper;
    private final TmsTaskFileMapper taskFileMapper;
    private final TmsMaterialMapper materialMapper;
    private final TmsTrainModeMapper trainModeMapper;

    @Override
    public List<TmsPersonTaskMineForm> getMine(TmsPersonTaskQuery query) {
        String userId = UserProvider.getLoginUserId();
        LambdaQueryWrapper<TmsPersonTaskEntity> qw = new LambdaQueryWrapper<>();
        qw.eq(TmsPersonTaskEntity::getUserId, userId);
        qw.ne(TmsPersonTaskEntity::getBizStatus, STATUS_CANCELLED);
        if (StringUtil.isNotEmpty(query.getBizStatus())) {
            qw.eq(TmsPersonTaskEntity::getBizStatus, query.getBizStatus().trim());
        }
        qw.orderByDesc(TmsPersonTaskEntity::getCreatorTime);
        List<TmsPersonTaskEntity> persons = personTaskMapper.selectList(qw);

        Map<String, TmsTaskEntity> taskMap = loadTasks(persons);
        String keyword = StringUtil.isNotEmpty(query.getKeyword()) ? query.getKeyword().trim() : null;
        List<TmsPersonTaskMineForm> all = new ArrayList<>();
        for (TmsPersonTaskEntity person : persons) {
            TmsTaskEntity task = taskMap.get(person.getTaskId());
            if (task == null || !"published".equals(task.getPublishStatus())) {
                continue;
            }
            if (keyword != null && !matchKeyword(person, task, keyword)) {
                continue;
            }
            all.add(toForm(person, task, false));
        }
        all.sort(Comparator.comparing(TmsPersonTaskMineForm::getStartTime,
                Comparator.nullsLast(Comparator.reverseOrder())));

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

    @Override
    public TmsPersonTaskMineForm getInfo(String id) {
        TmsPersonTaskEntity person = requireMine(id);
        TmsTaskEntity task = taskMapper.selectById(person.getTaskId());
        if (task == null) {
            throw new DataException("培训任务不存在");
        }
        TmsPersonTaskMineForm form = toForm(person, task, true);
        form.setFiles(loadFiles(task.getId()));
        return form;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public TmsPersonTaskLearnResult markLearned(String id, Integer seconds) {
        TmsPersonTaskEntity person = requireMine(id);
        TmsTaskEntity task = taskMapper.selectById(person.getTaskId());
        if (task == null) {
            throw new DataException("培训任务不存在");
        }

        int before = person.getLearnSeconds() == null ? 0 : person.getLearnSeconds();
        int required = toRequiredSeconds(person.getHours());
        boolean alreadyFull = required > 0 && before >= required;

        int add = seconds == null ? 0 : Math.max(0, seconds);
        if (add > 0) {
            person.setLearnSeconds(before + add);
            person.setLastModifyUserId(UserProvider.getLoginUserId());
            person.setLastModifyTime(new Date());
            personTaskMapper.updateById(person);
        }

        int learned = person.getLearnSeconds() == null ? 0 : person.getLearnSeconds();
        boolean justFull = required > 0 && !alreadyFull && learned >= required;

        TmsPersonTaskLearnResult result = new TmsPersonTaskLearnResult();
        result.setLearnedSeconds(learned);
        result.setRequiredSeconds(required);
        result.setLearnStatus(resolveLearnStatus(learned, required));
        result.setBizStatus(person.getBizStatus());
        result.setAutoCompleted(false);
        result.setMessage("");

        boolean needExam = "exam".equals(task.getEvalMode()) && StringUtil.isNotEmpty(task.getPaperId());
        if (justFull) {
            if (!needExam && !STATUS_DONE.equals(person.getBizStatus())
                    && !STATUS_CANCELLED.equals(person.getBizStatus())) {
                person.setBizStatus(STATUS_DONE);
                person.setLastModifyUserId(UserProvider.getLoginUserId());
                person.setLastModifyTime(new Date());
                personTaskMapper.updateById(person);
                result.setAutoCompleted(true);
                result.setBizStatus(STATUS_DONE);
                result.setMessage("已学满规定课时，系统已自动确认完成");
            } else if (needExam) {
                if (person.getSignTime() == null) {
                    result.setMessage("已学满规定课时，请先签到后再进入考试");
                } else {
                    result.setMessage("已学满规定课时，可以进入考试");
                }
            }
        }

        TmsPersonTaskMineForm tmp = new TmsPersonTaskMineForm();
        fillExamFlag(tmp, task, person);
        result.setCanExam(Boolean.TRUE.equals(tmp.getCanExam()));
        result.setExamTip(tmp.getExamTip());
        return result;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public TmsPersonTaskSignResult sign(String id) {
        TmsPersonTaskEntity person = requireMine(id);
        TmsTaskEntity task = taskMapper.selectById(person.getTaskId());
        if (task == null) {
            throw new DataException("培训任务不存在");
        }
        if (!"published".equals(task.getPublishStatus())) {
            throw new DataException("任务未发布，不可签到");
        }
        if (STATUS_CANCELLED.equals(person.getBizStatus())) {
            throw new DataException("任务已取消，不可签到");
        }
        if (person.getSignTime() != null) {
            throw new DataException("您已签到，无需重复签到");
        }
        String deny = resolveSignDenyReason(task, person);
        if (StringUtil.isNotEmpty(deny)) {
            throw new DataException(deny);
        }

        Date now = new Date();
        person.setSignTime(now);
        person.setSignMode(SIGN_MODE_ONLINE);
        if (STATUS_TODO.equals(person.getBizStatus()) || StringUtil.isEmpty(person.getBizStatus())) {
            person.setBizStatus(STATUS_SIGNED);
        }
        person.setLastModifyUserId(UserProvider.getLoginUserId());
        person.setLastModifyTime(now);
        personTaskMapper.updateById(person);

        TmsPersonTaskSignResult result = new TmsPersonTaskSignResult();
        result.setSignTime(formatDate(now));
        result.setBizStatus(person.getBizStatus());
        result.setSigned(true);
        result.setCanSign(false);
        result.setSignTip("已签到");
        result.setMessage("签到成功");
        TmsPersonTaskMineForm tmp = new TmsPersonTaskMineForm();
        fillExamFlag(tmp, task, person);
        result.setCanExam(Boolean.TRUE.equals(tmp.getCanExam()));
        result.setExamTip(tmp.getExamTip());
        return result;
    }

    private TmsPersonTaskMineForm toForm(TmsPersonTaskEntity person, TmsTaskEntity task, boolean detail) {
        TmsPersonTaskMineForm form = new TmsPersonTaskMineForm();
        form.setId(person.getId());
        form.setTaskId(task.getId());
        form.setTaskNo(StringUtil.isNotEmpty(person.getTaskNo()) ? person.getTaskNo() : task.getTaskNo());
        form.setSubject(task.getSubject());
        form.setCategory(task.getCategory());
        form.setTrainMode(task.getTrainMode());
        form.setEvalMode(task.getEvalMode());
        form.setStartTime(formatDate(task.getStartTime()));
        form.setEndTime(formatDate(task.getEndTime()));
        form.setCloseTime(formatDate(task.getCloseTime()));
        form.setPlaceName(task.getPlaceName());
        form.setBizStatus(person.getBizStatus());
        form.setSignTime(formatDate(person.getSignTime()));
        form.setSigned(person.getSignTime() != null);
        fillSignFlag(form, task, person);
        form.setLearnSeconds(person.getLearnSeconds());
        int learned = person.getLearnSeconds() == null ? 0 : person.getLearnSeconds();
        form.setLearnedSeconds(learned);
        BigDecimal hours = person.getHours();
        form.setRequiredHours(hours);
        int requiredSeconds = toRequiredSeconds(hours);
        form.setRequiredSeconds(requiredSeconds);
        form.setLearnStatus(resolveLearnStatus(learned, requiredSeconds));
        form.setExamScore(person.getExamScore());
        form.setPassFlag(person.getPassFlag());
        form.setPaperId(task.getPaperId());
        form.setPaperName(task.getPaperName());
        fillExamFlag(form, task, person);
        if (detail) {
            form.setKeyPoints(task.getKeyPoints());
        }
        return form;
    }

    private void fillExamFlag(TmsPersonTaskMineForm form, TmsTaskEntity task, TmsPersonTaskEntity person) {
        if (!"exam".equals(task.getEvalMode())) {
            form.setCanExam(false);
            form.setExamTip("本次培训无需在线考试");
            return;
        }
        if (StringUtil.isEmpty(task.getPaperId())) {
            form.setCanExam(false);
            form.setExamTip("未配置试卷");
            return;
        }
        if (person.getSignTime() == null) {
            form.setCanExam(false);
            form.setExamTip("请先签到后再考试");
            return;
        }
        if ("online".equals(task.getTrainMode())) {
            int required = toRequiredSeconds(person.getHours());
            int learned = person.getLearnSeconds() == null ? 0 : person.getLearnSeconds();
            if (required <= 0) {
                form.setCanExam(false);
                form.setExamTip("未配置课时，暂不能考试");
                return;
            }
            if (learned < required) {
                form.setCanExam(false);
                form.setExamTip("请先学满规定课时后再考试（已学 "
                        + formatDuration(learned) + " / 需学 " + formatDuration(required) + "）");
                return;
            }
        }
        Date now = new Date();
        if (task.getExamStart() != null && now.before(task.getExamStart())) {
            form.setCanExam(false);
            form.setExamTip("未到考试开始时间");
            return;
        }
        if (task.getExamEnd() != null && now.after(task.getExamEnd())) {
            form.setCanExam(false);
            form.setExamTip("已过考试结束时间");
            return;
        }
        form.setCanExam(true);
        form.setExamTip("");
    }

    private void fillSignFlag(TmsPersonTaskMineForm form, TmsTaskEntity task, TmsPersonTaskEntity person) {
        if (person.getSignTime() != null) {
            form.setCanSign(false);
            form.setSignTip("已签到");
            return;
        }
        String deny = resolveSignDenyReason(task, person);
        if (StringUtil.isNotEmpty(deny)) {
            form.setCanSign(false);
            form.setSignTip(deny);
            return;
        }
        form.setCanSign(true);
        form.setSignTip("");
    }

    /** 返回不可签到原因；空字符串表示可签到 */
    private String resolveSignDenyReason(TmsTaskEntity task, TmsPersonTaskEntity person) {
        if (STATUS_CANCELLED.equals(person.getBizStatus())) {
            return "任务已取消，不可签到";
        }
        if (task == null || !"published".equals(task.getPublishStatus())) {
            return "任务未发布，不可签到";
        }
        if (!allowOnlineSign(task.getTrainMode())) {
            return "该培训方式不支持在线签到，请扫码签到";
        }
        Date now = new Date();
        if (task.getStartTime() != null && now.before(task.getStartTime())) {
            return "未到培训开始时间，暂不可签到";
        }
        if (task.getCloseTime() != null && now.after(task.getCloseTime())) {
            return "培训已关闭，不可签到";
        }
        if (task.getEndTime() != null && now.after(task.getEndTime()) && task.getCloseTime() == null) {
            return "已过培训结束时间，不可签到";
        }
        return "";
    }

    private boolean allowOnlineSign(String trainMode) {
        if (StringUtil.isEmpty(trainMode)) {
            return false;
        }
        // 配置表优先：sign_rule=both 才允许在线；无配置时按字典约定 online 允许
        TmsTrainModeEntity mode = trainModeMapper.selectOne(
                new LambdaQueryWrapper<TmsTrainModeEntity>()
                        .eq(TmsTrainModeEntity::getModeCode, trainMode)
                        .last("LIMIT 1"));
        if (mode != null && StringUtil.isNotEmpty(mode.getSignRule())) {
            return "both".equalsIgnoreCase(mode.getSignRule());
        }
        return "online".equalsIgnoreCase(trainMode);
    }

    private int toRequiredSeconds(BigDecimal hours) {
        if (hours == null || hours.compareTo(BigDecimal.ZERO) <= 0) {
            return 0;
        }
        return hours.multiply(BigDecimal.valueOf(3600)).intValue();
    }

    private String resolveLearnStatus(int learned, int required) {
        if (required > 0 && learned >= required) {
            return "已学满";
        }
        if (learned > 0) {
            return "学习中";
        }
        return "未学习";
    }

    private String formatDuration(int seconds) {
        int h = seconds / 3600;
        int m = (seconds % 3600) / 60;
        int s = seconds % 60;
        if (h > 0) {
            return h + "小时" + m + "分";
        }
        if (m > 0) {
            return m + "分" + s + "秒";
        }
        return s + "秒";
    }

    private List<TmsPersonTaskFileForm> loadFiles(String taskId) {
        List<TmsTaskFileEntity> files = taskFileMapper.selectList(
                new LambdaQueryWrapper<TmsTaskFileEntity>()
                        .eq(TmsTaskFileEntity::getForeignId, taskId)
                        .orderByAsc(TmsTaskFileEntity::getCreatorTime));
        if (files.isEmpty()) {
            return Collections.emptyList();
        }
        List<String> materialIds = files.stream()
                .map(TmsTaskFileEntity::getMaterialId)
                .filter(StringUtil::isNotEmpty)
                .distinct()
                .collect(Collectors.toList());
        Map<String, TmsMaterialEntity> materialMap = new HashMap<>();
        if (!materialIds.isEmpty()) {
            for (TmsMaterialEntity material : materialMapper.selectBatchIds(materialIds)) {
                materialMap.put(material.getId(), material);
            }
        }
        List<TmsPersonTaskFileForm> list = new ArrayList<>();
        for (TmsTaskFileEntity file : files) {
            String url = extractUrl(file.getFileJson());
            String ext = extractExt(file.getFileJson(), file.getFileName());
            if ((StringUtil.isEmpty(url) || StringUtil.isEmpty(ext)) && StringUtil.isNotEmpty(file.getMaterialId())) {
                TmsMaterialEntity material = materialMap.get(file.getMaterialId());
                if (material != null) {
                    if (StringUtil.isEmpty(url)) {
                        url = extractUrl(material.getFileJson());
                    }
                    if (StringUtil.isEmpty(ext)) {
                        ext = extractExt(material.getFileJson(), material.getMaterialName());
                    }
                }
            }
            TmsPersonTaskFileForm item = new TmsPersonTaskFileForm();
            item.setId(file.getId());
            item.setName(file.getFileName());
            item.setUrl(url);
            item.setFileExt(ext);
            item.setPreviewType(resolvePreviewType(ext));
            list.add(item);
        }
        return list;
    }

    private String extractExt(String fileJson, String fileName) {
        try {
            if (StringUtil.isNotEmpty(fileJson)) {
                String text = fileJson.trim();
                if (text.startsWith("[")) {
                    List<Map<String, Object>> arr = OBJECT_MAPPER.readValue(text, new TypeReference<List<Map<String, Object>>>() {
                    });
                    if (arr != null && !arr.isEmpty() && arr.get(0).get("fileExtension") != null) {
                        return String.valueOf(arr.get(0).get("fileExtension")).toLowerCase();
                    }
                    if (arr != null && !arr.isEmpty() && arr.get(0).get("name") != null) {
                        fileName = String.valueOf(arr.get(0).get("name"));
                    }
                } else {
                    Map<String, Object> map = OBJECT_MAPPER.readValue(text, new TypeReference<Map<String, Object>>() {
                    });
                    if (map.get("fileExtension") != null) {
                        return String.valueOf(map.get("fileExtension")).toLowerCase();
                    }
                    if (map.get("name") != null) {
                        fileName = String.valueOf(map.get("name"));
                    }
                }
            }
        } catch (Exception ignored) {
            // ignore
        }
        if (StringUtil.isEmpty(fileName) || !fileName.contains(".")) {
            return "";
        }
        return fileName.substring(fileName.lastIndexOf('.') + 1).toLowerCase();
    }

    private String resolvePreviewType(String ext) {
        if (StringUtil.isEmpty(ext)) {
            return "other";
        }
        String e = ext.toLowerCase();
        if (Set.of("jpg", "jpeg", "png", "gif", "webp", "bmp", "svg").contains(e)) {
            return "image";
        }
        if (Set.of("mp4", "webm", "ogg", "mov", "m4v").contains(e)) {
            return "video";
        }
        if (Set.of("mp3", "wav", "aac", "m4a", "flac").contains(e)) {
            return "audio";
        }
        if ("pdf".equals(e)) {
            return "pdf";
        }
        if (Set.of("doc", "docx", "xls", "xlsx", "ppt", "pptx").contains(e)) {
            return "office";
        }
        return "other";
    }

    private String extractUrl(String fileJson) {
        if (StringUtil.isEmpty(fileJson)) {
            return null;
        }
        try {
            String text = fileJson.trim();
            if (text.startsWith("[")) {
                List<Map<String, Object>> arr = OBJECT_MAPPER.readValue(text, new TypeReference<List<Map<String, Object>>>() {
                });
                if (arr == null || arr.isEmpty() || arr.get(0).get("url") == null) {
                    return null;
                }
                return String.valueOf(arr.get(0).get("url"));
            }
            Map<String, Object> map = OBJECT_MAPPER.readValue(text, new TypeReference<Map<String, Object>>() {
            });
            return map.get("url") == null ? null : String.valueOf(map.get("url"));
        } catch (Exception ex) {
            return null;
        }
    }

    private Map<String, TmsTaskEntity> loadTasks(List<TmsPersonTaskEntity> persons) {
        List<String> ids = persons.stream()
                .map(TmsPersonTaskEntity::getTaskId)
                .filter(StringUtil::isNotEmpty)
                .distinct()
                .collect(Collectors.toList());
        if (ids.isEmpty()) {
            return Collections.emptyMap();
        }
        Map<String, TmsTaskEntity> map = new HashMap<>();
        for (TmsTaskEntity task : taskMapper.selectBatchIds(ids)) {
            map.put(task.getId(), task);
        }
        return map;
    }

    private boolean matchKeyword(TmsPersonTaskEntity person, TmsTaskEntity task, String keyword) {
        String no = person.getTaskNo() == null ? "" : person.getTaskNo();
        String taskNo = task.getTaskNo() == null ? "" : task.getTaskNo();
        String subject = task.getSubject() == null ? "" : task.getSubject();
        return no.contains(keyword) || taskNo.contains(keyword) || subject.contains(keyword);
    }

    private TmsPersonTaskEntity requireMine(String id) {
        if (StringUtil.isEmpty(id)) {
            throw new DataException("个人任务ID不能为空");
        }
        TmsPersonTaskEntity person = personTaskMapper.selectById(id);
        if (person == null) {
            throw new DataException("个人培训任务不存在");
        }
        if (!UserProvider.getLoginUserId().equals(person.getUserId())) {
            throw new DataException("只能查看自己的培训任务");
        }
        return person;
    }

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