package com.ycl.service.impl;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.ycl.common.enums.business.CodingRulerCodeTypeEnum;
import com.ycl.common.enums.business.CodingRulerStatusEnum;
import com.ycl.domain.entity.CodingRuler;
import com.ycl.mapper.CodingRulerMapper;
import com.ycl.service.CodingRulerService;
import com.ycl.common.base.Result;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ycl.domain.form.CodingRulerForm;
import com.ycl.domain.vo.CodingRulerVO;
import com.ycl.domain.query.CodingRulerQuery;
import org.springframework.stereotype.Service;
import lombok.RequiredArgsConstructor;
import com.ycl.framework.utils.PageUtil;
import org.springframework.beans.BeanUtils;
import org.springframework.util.Assert;
import org.springframework.util.CollectionUtils;

import java.util.List;
import java.util.stream.Collectors;

/**
 *  服务实现类
 *
 * @author zxl
 * @since 2025-03-18
 */
@Service
@RequiredArgsConstructor
public class CodingRulerServiceImpl extends ServiceImpl<CodingRulerMapper, CodingRuler> implements CodingRulerService {

    private final CodingRulerMapper codingRulerMapper;

    /**
     * 添加
     * @param form
     * @return
     */
    @Override
    public Result add(CodingRulerForm form) {
        CodingRuler entity = CodingRulerForm.getEntityByForm(form, null);
        //设置默认未启动
        entity.setStatus(0);
        baseMapper.insert(entity);
        return Result.ok("添加成功");
    }

    /**
     * 修改
     * @param form
     * @return
     */
    @Override
    public Result update(CodingRulerForm form) {
        CodingRuler entity = baseMapper.selectById(form.getId());
        // 为空抛IllegalArgumentException，做全局异常处理
        Assert.notNull(entity, "记录不存在");
        BeanUtils.copyProperties(form, entity);
        baseMapper.updateById(entity);
        return Result.ok("修改成功");
    }

    /**
     * 批量删除
     * @param ids
     * @return
     */
    @Override
    public Result remove(List<String> ids) {
        baseMapper.deleteBatchIds(ids);
        return Result.ok("删除成功");
    }

    /**
     * id删除
     * @param id
     * @return
     */
    @Override
    public Result removeById(String id) {
        baseMapper.deleteById(id);
        return Result.ok("删除成功");
    }

    /**
     * 分页查询
     * @param query
     * @return
     */
    @Override
    public Result page(CodingRulerQuery query) {
        IPage<CodingRulerVO> page = PageUtil.getPage(query, CodingRulerVO.class);

        baseMapper.getPage(page, query);
        return Result.ok().data(page.getRecords()).total(page.getTotal());
    }

    /**
     * 根据id查找
     * @param id
     * @return
     */
    @Override
    public Result detail(Integer id) {
        CodingRulerVO vo = baseMapper.getById(id);
        Assert.notNull(vo, "记录不存在");
        return Result.ok().data(vo);
    }

    /**
     * 列表
     * @return
     */
    @Override
    public Result all() {
        List<CodingRuler> entities = baseMapper.selectList(null);
        List<CodingRulerVO> vos = entities.stream()
                .map(entity -> CodingRulerVO.getVoByEntity(entity, null))
                .collect(Collectors.toList());
        return Result.ok().data(vos);
    }

    @Override
    public Result changeCodingRulerStatus(Integer id) {
        //红码 绿码 同时只能启动一个
        CodingRuler codingRuler = baseMapper.selectById(id);
        String msg = "";
        //判断传入 id 当前状态
        if (CodingRulerStatusEnum.off.getValue().equals(codingRuler.getStatus())){
            // 当前状态未启动 -- 修改为启动状态
            //查询（红码'绿码）规则是否启动
            CodingRuler statusStartCodingRuler = new LambdaQueryChainWrapper<CodingRuler>(baseMapper)
                    .eq(CodingRuler::getStatus, CodingRulerStatusEnum.on.getValue())
                    .eq(CodingRuler::getProjectCodeType, codingRuler.getProjectCodeType())
                    .eq(CodingRuler::getDeleted,0)
                    .one();
            if (statusStartCodingRuler != null) {
                throw new RuntimeException("相同项目码类型同时只能启动一种");
            }

            codingRuler.setStatus(CodingRulerStatusEnum.on.getValue());
            msg = CodingRulerStatusEnum.on.getDesc();
        }else {
            // 当前状态启动 -- 修改为未启动状态
            codingRuler.setStatus(CodingRulerStatusEnum.off.getValue());
            msg =  CodingRulerStatusEnum.off.getDesc();
        }
        baseMapper.updateById(codingRuler);
        return Result.ok(msg);
    }
    /**
     * 获得启动的赋码规则
     * @return 存放的字段 yellowRuler启用的黄码规则，redRuler启用的红码规则
     */
    @Override
    public Result getStartRuler() {
        Result result = new Result();
        //获得启用的赋码规则
        List<CodingRulerVO> codingRulerVOS = codingRulerMapper.getStartRuler();
        if (CollectionUtils.isEmpty(codingRulerVOS)){
            log.error("未启用赋码规则");
            return result;
        }
        CodingRulerVO yellowRuler = null;
        CodingRulerVO redRuler = null;
        for (CodingRulerVO codingRulerVO : codingRulerVOS){
            if (CodingRulerCodeTypeEnum.YELLOW.getValue().equals(codingRulerVO.getProjectCodeType())){
                yellowRuler = codingRulerVO;
            }else if (CodingRulerCodeTypeEnum.RED.getValue().equals(codingRulerVO.getProjectCodeType())){
                redRuler = codingRulerVO;
            }
        }
        result.put("yellowRuler",yellowRuler);
        result.put("redRuler",redRuler);
        return result;
    }
}