package com.ruoyi.cs.service.impl;

import java.util.List;

import com.ruoyi.common.constant.UserConstants;
import com.ruoyi.common.core.domain.entity.SysDictData;
import com.ruoyi.common.core.domain.entity.SysDictType;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.DictUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.cs.domain.CsResourceDictData;
import com.ruoyi.cs.mapper.CsResourceDictDataMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.cs.mapper.CsResourceDictTypeMapper;
import com.ruoyi.cs.domain.CsResourceDictType;
import com.ruoyi.cs.service.ICsResourceDictTypeService;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;

/**
 * 资源字典类型Service业务层处理
 * 
 * @author ruoyi
 * @date 2024-04-29
 */
@Service
public class CsResourceDictTypeServiceImpl implements ICsResourceDictTypeService 
{
    @Resource
    private CsResourceDictTypeMapper csResourceDictTypeMapper;

    @Resource
    private CsResourceDictDataMapper csResourceDictDataMapper;

    /**
     * 查询资源字典类型列表
     *
     * @param csResourceDictType 资源字典类型
     * @return 资源字典类型
     */
    @Override
    public List<CsResourceDictType> selectCsResourceDictTypeList(CsResourceDictType csResourceDictType)
    {
        return csResourceDictTypeMapper.selectCsResourceDictTypeList(csResourceDictType);
    }

    /**
     * 根据所有字典类型
     *
     * @return 字典类型集合信息
     */
    @Override
    public List<CsResourceDictType> selectDictTypeAll() {
        return csResourceDictTypeMapper.selectDictTypeAll();
    }

    /**
     * 根据字典类型查询字典数据
     *
     * @param dictType 字典类型
     * @return 字典数据集合信息
     */
    @Override
    public List<CsResourceDictData> selectDictDataByType(String dictType) {
        List<CsResourceDictData> dictDatas = csResourceDictDataMapper.selectDictDataByType(dictType);
        return dictDatas;
    }

    /**
     * 查询资源字典类型
     *
     * @param dictId 资源字典类型主键
     * @return 资源字典类型
     */
    @Override
    public CsResourceDictType selectCsResourceDictTypeByDictId(Long dictId)
    {
        return csResourceDictTypeMapper.selectCsResourceDictTypeByDictId(dictId);
    }

    /**
     * 根据字典类型查询信息
     *
     * @param dictType 字典类型
     * @return 字典类型
     */
    @Override
    public CsResourceDictType selectDictTypeByType(String dictType) {
        return csResourceDictTypeMapper.selectDictTypeByType(dictType);
    }

    /**
     * 批量删除资源字典类型
     *
     * @param dictIds 需要删除的资源字典类型主键
     * @return 结果
     */
    @Override
    public void deleteCsResourceDictTypeByDictIds(Long[] dictIds)
    {
        for (Long dictId : dictIds)
        {
            CsResourceDictType dictType = selectCsResourceDictTypeByDictId(dictId);
            if (csResourceDictDataMapper.countDictDataByType(dictType.getDictType()) > 0)
            {
                throw new ServiceException(String.format("%1$s已分配,不能删除", dictType.getDictName()));
            }
            csResourceDictTypeMapper.deleteCsResourceDictTypeByDictId(dictId);
            DictUtils.removeDictCache(dictType.getDictType());
        }
    }


    /**
     * 新增资源字典类型
     *
     * @param csResourceDictType 资源字典类型
     * @return 结果
     */
    @Override
    public int insertCsResourceDictType(CsResourceDictType csResourceDictType)
    {
        csResourceDictType.setCreateTime(DateUtils.getNowDate());
        return csResourceDictTypeMapper.insertCsResourceDictType(csResourceDictType);
    }

    /**
     * 修改资源字典类型
     *
     * @param csResourceDictType 资源字典类型
     * @return 结果
     */
    @Override
    public int updateCsResourceDictType(CsResourceDictType csResourceDictType)
    {

        CsResourceDictType oldDict = csResourceDictTypeMapper.selectDictTypeById(csResourceDictType.getDictId());
        csResourceDictDataMapper.updateDictDataType(oldDict.getDictType(), csResourceDictType.getDictType());
        int row = csResourceDictTypeMapper.updateCsResourceDictType(csResourceDictType);
        if (row > 0)
        {
            List<CsResourceDictData> dictDatas = csResourceDictDataMapper.selectDictDataByType(csResourceDictType.getDictType());
        }
        return row;
    }

    /**
     * 校验字典类型称是否唯一
     *
     * @param type 字典类型
     * @return 结果
     */
    @Override
    public String checkDictTypeUnique(CsResourceDictType type) {
        Long dictId = StringUtils.isNull(type.getDictId()) ? -1L : type.getDictId();
        CsResourceDictType dictType = csResourceDictTypeMapper.checkDictTypeUnique(type.getDictType());
        if (StringUtils.isNotNull(dictType) && dictType.getDictId().longValue() != dictId.longValue())
        {
            return UserConstants.NOT_UNIQUE;
        }
        return UserConstants.UNIQUE;
    }


    /**
     * 删除资源字典类型信息
     * 
     * @param dictId 资源字典类型主键
     * @return 结果
     */
    @Override
    public int deleteCsResourceDictTypeByDictId(Long dictId)
    {
        return csResourceDictTypeMapper.deleteCsResourceDictTypeByDictId(dictId);
    }
}
