package jnpf.tmsService.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import jnpf.exception.DataException;
import jnpf.tmsEntity.TmsCourseEntity;
import jnpf.tmsEntity.TmsPaperEntity;
import jnpf.tmsEntity.course.TmsCourseForm;
import jnpf.tmsEntity.course.TmsCourseQuery;
import jnpf.tmsEntity.course.TmsPaperOption;
import jnpf.tmsMapper.TmsCourseMapper;
import jnpf.tmsMapper.TmsPaperMapper;
import jnpf.tmsService.TmsCourseService;
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;

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

@Service
@RequiredArgsConstructor
public class TmsCourseServiceImpl implements TmsCourseService {

    private final TmsCourseMapper courseMapper;
    private final TmsPaperMapper paperMapper;

    @Override
    public List<TmsCourseForm> getList(TmsCourseQuery query) {
        LambdaQueryWrapper<TmsCourseEntity> qw = new LambdaQueryWrapper<>();
        if (StringUtil.isNotEmpty(query.getEnabled())) {
            qw.eq(TmsCourseEntity::getEnabled, query.getEnabled());
        }
        if (StringUtil.isNotEmpty(query.getCategory())) {
            qw.eq(TmsCourseEntity::getCategory, query.getCategory());
        }
        if (StringUtil.isNotEmpty(query.getTrainMode())) {
            qw.eq(TmsCourseEntity::getTrainMode, query.getTrainMode());
        }
        if (StringUtil.isNotEmpty(query.getEvalMode())) {
            qw.eq(TmsCourseEntity::getEvalMode, query.getEvalMode());
        }
        if (StringUtil.isNotEmpty(query.getKeyword())) {
            String kw = query.getKeyword().trim();
            qw.and(w -> w.like(TmsCourseEntity::getCourseNo, kw)
                    .or()
                    .like(TmsCourseEntity::getCourseName, kw));
        }
        qw.orderByDesc(TmsCourseEntity::getCourseNo);
        qw.orderByDesc(TmsCourseEntity::getCreatorTime);

        long current = query.getCurrentPage() > 0 ? query.getCurrentPage() : 1;
        long size = query.getPageSize() > 0 ? query.getPageSize() : 20;
        Page<TmsCourseEntity> page = courseMapper.selectPage(new Page<>(current, size), qw);

        Map<String, String> paperNames = loadPaperNames(page.getRecords());
        List<TmsCourseForm> list = new ArrayList<>(page.getRecords().size());
        for (TmsCourseEntity row : page.getRecords()) {
            list.add(toForm(row, paperNames));
        }
        query.setData(list, page.getTotal());
        return list;
    }

    @Override
    public TmsCourseForm getInfo(String id) {
        TmsCourseEntity entity = requireOne(id);
        Map<String, String> paperNames = loadPaperNames(Collections.singletonList(entity));
        return toForm(entity, paperNames);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public String create(TmsCourseForm form) {
        validateForm(form);
        TmsCourseEntity entity = new TmsCourseEntity();
        entity.setId(RandomUtil.uuId());
        entity.setCourseNo(nextCourseNo());
        applyForm(entity, form);
        entity.setCreatorUserId(UserProvider.getLoginUserId());
        entity.setCreatorTime(new Date());
        courseMapper.insert(entity);
        return entity.getId();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void update(String id, TmsCourseForm form) {
        TmsCourseEntity entity = requireOne(id);
        validateForm(form);
        applyForm(entity, form);
        entity.setLastModifyUserId(UserProvider.getLoginUserId());
        entity.setLastModifyTime(new Date());
        courseMapper.updateById(entity);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void setEnabled(String id, String enabled) {
        if (!"0".equals(enabled) && !"1".equals(enabled)) {
            throw new DataException("启用状态无效");
        }
        TmsCourseEntity entity = requireOne(id);
        entity.setEnabled(enabled);
        entity.setLastModifyUserId(UserProvider.getLoginUserId());
        entity.setLastModifyTime(new Date());
        courseMapper.updateById(entity);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void delete(String id) {
        TmsCourseEntity entity = requireOne(id);
        if (!"0".equals(entity.getEnabled())) {
            throw new DataException("请先停用后再删除");
        }
        courseMapper.deleteById(id);
    }

    @Override
    public List<TmsPaperOption> paperOptions() {
        LambdaQueryWrapper<TmsPaperEntity> qw = new LambdaQueryWrapper<>();
        qw.eq(TmsPaperEntity::getBizStatus, "open");
        qw.orderByDesc(TmsPaperEntity::getCreatorTime);
        List<TmsPaperEntity> rows = paperMapper.selectList(qw);
        List<TmsPaperOption> list = new ArrayList<>(rows.size());
        for (TmsPaperEntity row : rows) {
            TmsPaperOption opt = new TmsPaperOption();
            opt.setId(row.getId());
            opt.setFullName(row.getPaperName());
            list.add(opt);
        }
        return list;
    }

    private String nextCourseNo() {
        String prefix = "KC" + LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMM"));
        String maxNo = courseMapper.selectMaxCourseNo(prefix);
        int next = 1;
        if (StringUtil.isNotEmpty(maxNo) && maxNo.length() >= prefix.length() + 4 && maxNo.startsWith(prefix)) {
            try {
                next = Integer.parseInt(maxNo.substring(prefix.length())) + 1;
            } catch (NumberFormatException ignored) {
                next = 1;
            }
        }
        if (next > 9999) {
            throw new DataException("当月课程编号已用尽（" + prefix + "9999）");
        }
        return prefix + String.format("%04d", next);
    }

    private Map<String, String> loadPaperNames(List<TmsCourseEntity> rows) {
        Set<String> ids = new HashSet<>();
        for (TmsCourseEntity row : rows) {
            if (StringUtil.isNotEmpty(row.getPaperId())) {
                ids.add(row.getPaperId());
            }
        }
        if (ids.isEmpty()) {
            return Collections.emptyMap();
        }
        List<TmsPaperEntity> papers = paperMapper.selectBatchIds(ids);
        Map<String, String> map = new HashMap<>(papers.size());
        for (TmsPaperEntity paper : papers) {
            map.put(paper.getId(), paper.getPaperName());
        }
        return map;
    }

    private TmsCourseEntity requireOne(String id) {
        if (StringUtil.isEmpty(id)) {
            throw new DataException("培训课程不存在");
        }
        TmsCourseEntity entity = courseMapper.selectById(id);
        if (entity == null) {
            throw new DataException("培训课程不存在");
        }
        return entity;
    }

    private void validateForm(TmsCourseForm form) {
        if (form == null || StringUtil.isEmpty(form.getCourseName())) {
            throw new DataException("请填写课程名称");
        }
        if ("exam".equals(form.getEvalMode()) && StringUtil.isEmpty(form.getPaperId())) {
            throw new DataException("在线考试须关联考核试卷");
        }
        if (StringUtil.isNotEmpty(form.getPaperId())) {
            TmsPaperEntity paper = paperMapper.selectById(form.getPaperId());
            if (paper == null) {
                throw new DataException("关联试卷不存在");
            }
        }
    }

    private void applyForm(TmsCourseEntity entity, TmsCourseForm form) {
        entity.setCourseName(form.getCourseName().trim());
        entity.setCategory(StringUtil.isEmpty(form.getCategory()) ? null : form.getCategory().trim());
        entity.setTrainMode(StringUtil.isEmpty(form.getTrainMode()) ? null : form.getTrainMode().trim());
        entity.setEvalMode(StringUtil.isEmpty(form.getEvalMode()) ? null : form.getEvalMode().trim());
        if ("exam".equals(entity.getEvalMode())) {
            entity.setPaperId(form.getPaperId());
        } else {
            entity.setPaperId(StringUtil.isEmpty(form.getPaperId()) ? null : form.getPaperId());
        }
        entity.setHours(form.getHours());
        entity.setEnabled(yn(form.getEnabled(), "1"));
        entity.setRemark(form.getRemark());
    }

    private static String yn(String v, String def) {
        if ("0".equals(v) || "1".equals(v)) {
            return v;
        }
        return def;
    }

    private TmsCourseForm toForm(TmsCourseEntity entity, Map<String, String> paperNames) {
        TmsCourseForm form = new TmsCourseForm();
        form.setId(entity.getId());
        form.setCourseNo(entity.getCourseNo());
        form.setCourseName(entity.getCourseName());
        form.setCategory(entity.getCategory());
        form.setTrainMode(entity.getTrainMode());
        form.setEvalMode(entity.getEvalMode());
        form.setPaperId(entity.getPaperId());
        form.setPaperName(StringUtil.isEmpty(entity.getPaperId()) ? null : paperNames.get(entity.getPaperId()));
        form.setHours(entity.getHours());
        form.setEnabled(entity.getEnabled());
        form.setRemark(entity.getRemark());
        return form;
    }
}