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.TmsEvalModeEntity;
import jnpf.tmsEntity.evalmode.TmsEvalModeForm;
import jnpf.tmsEntity.evalmode.TmsEvalModeQuery;
import jnpf.tmsMapper.TmsEvalModeMapper;
import jnpf.tmsService.TmsEvalModeService;
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.util.ArrayList;
import java.util.Date;
import java.util.List;

@Service
@RequiredArgsConstructor
public class TmsEvalModeServiceImpl implements TmsEvalModeService {

    private final TmsEvalModeMapper evalModeMapper;

    @Override
    public List<TmsEvalModeForm> getList(TmsEvalModeQuery query) {
        LambdaQueryWrapper<TmsEvalModeEntity> qw = new LambdaQueryWrapper<>();
        if (StringUtil.isNotEmpty(query.getEnabled())) {
            qw.eq(TmsEvalModeEntity::getEnabled, query.getEnabled());
        }
        if (StringUtil.isNotEmpty(query.getKeyword())) {
            String kw = query.getKeyword().trim();
            qw.and(w -> w.like(TmsEvalModeEntity::getModeCode, kw)
                    .or()
                    .like(TmsEvalModeEntity::getModeName, kw));
        }
        qw.orderByDesc(TmsEvalModeEntity::getCreatorTime);

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

        List<TmsEvalModeForm> list = new ArrayList<>(page.getRecords().size());
        for (TmsEvalModeEntity row : page.getRecords()) {
            list.add(toForm(row));
        }
        query.setData(list, page.getTotal());
        return list;
    }

    @Override
    public TmsEvalModeForm getInfo(String id) {
        return toForm(requireOne(id));
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public String create(TmsEvalModeForm form) {
        validateForm(form, null);
        TmsEvalModeEntity entity = new TmsEvalModeEntity();
        entity.setId(RandomUtil.uuId());
        applyForm(entity, form);
        entity.setCreatorUserId(UserProvider.getLoginUserId());
        entity.setCreatorTime(new Date());
        evalModeMapper.insert(entity);
        return entity.getId();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void update(String id, TmsEvalModeForm form) {
        TmsEvalModeEntity entity = requireOne(id);
        validateForm(form, id);
        form.setModeCode(entity.getModeCode());
        applyForm(entity, form);
        entity.setLastModifyUserId(UserProvider.getLoginUserId());
        entity.setLastModifyTime(new Date());
        evalModeMapper.updateById(entity);
    }

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

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

    private TmsEvalModeEntity requireOne(String id) {
        if (StringUtil.isEmpty(id)) {
            throw new DataException("考核方式不存在");
        }
        TmsEvalModeEntity entity = evalModeMapper.selectById(id);
        if (entity == null) {
            throw new DataException("考核方式不存在");
        }
        return entity;
    }

    private void validateForm(TmsEvalModeForm form, String excludeId) {
        if (form == null || StringUtil.isEmpty(form.getModeCode())) {
            throw new DataException("请填写方式编码");
        }
        if (StringUtil.isEmpty(form.getModeName())) {
            throw new DataException("请填写方式名称");
        }
        String code = form.getModeCode().trim();
        form.setModeCode(code);
        LambdaQueryWrapper<TmsEvalModeEntity> qw = new LambdaQueryWrapper<>();
        qw.eq(TmsEvalModeEntity::getModeCode, code);
        if (StringUtil.isNotEmpty(excludeId)) {
            qw.ne(TmsEvalModeEntity::getId, excludeId);
        }
        if (evalModeMapper.selectCount(qw) > 0) {
            throw new DataException("方式编码已存在");
        }
    }

    private void applyForm(TmsEvalModeEntity entity, TmsEvalModeForm form) {
        entity.setModeCode(form.getModeCode().trim());
        entity.setModeName(form.getModeName().trim());
        entity.setNeedPaper(yn(form.getNeedPaper(), "0"));
        entity.setNeedQuiz(yn(form.getNeedQuiz(), "0"));
        entity.setNeedPractice(yn(form.getNeedPractice(), "0"));
        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 TmsEvalModeForm toForm(TmsEvalModeEntity entity) {
        TmsEvalModeForm form = new TmsEvalModeForm();
        form.setId(entity.getId());
        form.setModeCode(entity.getModeCode());
        form.setModeName(entity.getModeName());
        form.setNeedPaper(entity.getNeedPaper());
        form.setNeedQuiz(entity.getNeedQuiz());
        form.setNeedPractice(entity.getNeedPractice());
        form.setEnabled(entity.getEnabled());
        form.setRemark(entity.getRemark());
        return form;
    }
}