package com.klp.service.impl;

import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.klp.common.core.domain.PageQuery;
import com.klp.common.core.page.TableDataInfo;
import com.klp.common.exception.ServiceException;
import com.klp.common.utils.StringUtils;
import com.klp.domain.WmsProcessSpec;
import com.klp.domain.WmsProcessPlan;
import com.klp.domain.WmsProcessSpecVersion;
import com.klp.domain.bo.WmsProcessSpecVersionBo;
import com.klp.domain.vo.WmsProcessSpecVersionVo;
import com.klp.mapper.WmsProcessPlanMapper;
import com.klp.mapper.WmsProcessSpecMapper;
import com.klp.mapper.WmsProcessSpecVersionMapper;
import com.klp.service.IWmsProcessSpecVersionService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Collection;
import java.util.List;

/**
 * 规程版本Service实现
 *
 * @author klp
 */
@RequiredArgsConstructor
@Service
public class WmsProcessSpecVersionServiceImpl implements IWmsProcessSpecVersionService {

    private final WmsProcessSpecVersionMapper baseMapper;
    private final WmsProcessSpecMapper wmsProcessSpecMapper;
    private final WmsProcessPlanMapper wmsProcessPlanMapper;

    @Override
    public WmsProcessSpecVersionVo queryById(Long versionId) {
        return baseMapper.selectVoById(versionId);
    }

    @Override
    public TableDataInfo<WmsProcessSpecVersionVo> queryPageList(WmsProcessSpecVersionBo bo, PageQuery pageQuery) {
        LambdaQueryWrapper<WmsProcessSpecVersion> lqw = buildQueryWrapper(bo);
        Page<WmsProcessSpecVersionVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
        return TableDataInfo.build(result);
    }

    @Override
    public List<WmsProcessSpecVersionVo> queryList(WmsProcessSpecVersionBo bo) {
        return baseMapper.selectVoList(buildQueryWrapper(bo));
    }

    private LambdaQueryWrapper<WmsProcessSpecVersion> buildQueryWrapper(WmsProcessSpecVersionBo bo) {
        LambdaQueryWrapper<WmsProcessSpecVersion> lqw = Wrappers.lambdaQuery();
        lqw.eq(bo.getSpecId() != null, WmsProcessSpecVersion::getSpecId, bo.getSpecId());
        lqw.eq(StringUtils.isNotBlank(bo.getVersionCode()), WmsProcessSpecVersion::getVersionCode, bo.getVersionCode());
        lqw.eq(bo.getIsActive() != null, WmsProcessSpecVersion::getIsActive, bo.getIsActive());
        lqw.eq(StringUtils.isNotBlank(bo.getStatus()), WmsProcessSpecVersion::getStatus, bo.getStatus());
        lqw.orderByDesc(WmsProcessSpecVersion::getCreateTime);
        return lqw;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean insertByBo(WmsProcessSpecVersionBo bo) {
        WmsProcessSpec spec = wmsProcessSpecMapper.selectById(bo.getSpecId());
        if (spec == null) {
            throw new ServiceException("规程不存在");
        }
        WmsProcessSpecVersion add = BeanUtil.toBean(bo, WmsProcessSpecVersion.class);
        if (add.getIsActive() == null) {
            add.setIsActive(0);
        }
        if (StringUtils.isBlank(add.getStatus())) {
            add.setStatus("DRAFT");
        }
        validEntityBeforeSave(add);
        boolean ok = baseMapper.insert(add) > 0;
        if (ok) {
            bo.setVersionId(add.getVersionId());
            if (Integer.valueOf(1).equals(add.getIsActive())) {
                activateVersion(add.getVersionId());
            }
        }
        return ok;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean updateByBo(WmsProcessSpecVersionBo bo) {
        WmsProcessSpecVersion exist = baseMapper.selectById(bo.getVersionId());
        if (exist == null) {
            throw new ServiceException("版本不存在");
        }
        WmsProcessSpecVersion update = BeanUtil.toBean(bo, WmsProcessSpecVersion.class);
        validEntityBeforeSave(update);
        boolean ok = baseMapper.updateById(update) > 0;
        if (ok && Integer.valueOf(1).equals(update.getIsActive())) {
            activateVersion(update.getVersionId());
        }
        return ok;
    }

    private void validEntityBeforeSave(WmsProcessSpecVersion entity) {
        LambdaQueryWrapper<WmsProcessSpecVersion> lqw = Wrappers.lambdaQuery();
        lqw.eq(WmsProcessSpecVersion::getSpecId, entity.getSpecId());
        lqw.eq(WmsProcessSpecVersion::getVersionCode, entity.getVersionCode());
        if (entity.getVersionId() != null) {
            lqw.ne(WmsProcessSpecVersion::getVersionId, entity.getVersionId());
        }
        if (baseMapper.selectCount(lqw) > 0) {
            throw new ServiceException("同一规程下版本号已存在");
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean activateVersion(Long versionId) {
        WmsProcessSpecVersion v = baseMapper.selectById(versionId);
        if (v == null) {
            throw new ServiceException("版本不存在");
        }
        LambdaUpdateWrapper<WmsProcessSpecVersion> clear = Wrappers.lambdaUpdate();
        clear.eq(WmsProcessSpecVersion::getSpecId, v.getSpecId());
        clear.set(WmsProcessSpecVersion::getIsActive, 0);
        baseMapper.update(null, clear);

        WmsProcessSpecVersion one = new WmsProcessSpecVersion();
        one.setVersionId(versionId);
        one.setIsActive(1);
        return baseMapper.updateById(one) > 0;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
        for (Long versionId : ids) {
            LambdaQueryWrapper<WmsProcessPlan> pq = Wrappers.lambdaQuery();
            pq.eq(WmsProcessPlan::getVersionId, versionId);
            wmsProcessPlanMapper.delete(pq);
        }
        return baseMapper.deleteBatchIds(ids) > 0;
    }
}