package com.aps.system.service.impl;

import java.util.List;
import java.util.Objects;

import com.aps.common.security.utils.SecurityUtils;
import com.aps.system.api.domain.SysDictType;
import com.aps.system.mapper.SysDictTypeMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.aps.common.security.utils.DictUtils;
import com.aps.system.api.domain.SysDictData;
import com.aps.system.mapper.SysDictDataMapper;
import com.aps.system.service.ISysDictDataService;
import org.springframework.transaction.annotation.Transactional;

/**
 * 字典 业务层处理
 *
 * @author ruoyi
 */
@Service
public class SysDictDataServiceImpl implements ISysDictDataService {
    @Autowired
    private SysDictDataMapper dictDataMapper;

    @Autowired
    private SysDictTypeMapper dictTypeMapper;

    /**
     * 根据条件分页查询字典数据
     *
     * @param dictData 字典数据信息
     * @return 字典数据集合信息
     */
    @Override
    public List<SysDictData> selectDictDataList(SysDictData dictData) {
        return dictDataMapper.selectDictDataList(dictData);
    }

    /**
     * 根据字典类型和字典键值查询字典数据信息
     *
     * @param dictType  字典类型
     * @param dictValue 字典键值
     * @return 字典标签
     */
    @Override
    public String selectDictLabel(String dictType, String dictValue) {
        return dictDataMapper.selectDictLabel(dictType, dictValue);
    }

    /**
     * 根据字典数据ID查询信息
     *
     * @param dictCode 字典数据ID
     * @return 字典数据
     */
    @Override
    public SysDictData selectDictDataById(Long dictCode) {
        return dictDataMapper.selectDictDataById(dictCode);
    }

    /**
     * 批量删除字典数据信息
     *
     * @param dictCodes 需要删除的字典数据ID
     */
    @Override
    public void deleteDictDataByIds(Long[] dictCodes) {
        for (Long dictCode : dictCodes) {
            SysDictData data = selectDictDataById(dictCode);
            dictDataMapper.deleteDictDataById(dictCode);
            List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(data.getDictType());
            DictUtils.setDictCache(data.getDictType(), dictDatas);
        }
    }

    /**
     * 排产专业
     */
    private final static String DICT_TYPE_APS_DOMAIN = "aps_domain";

    /**
     * 排产工厂
     */
    private final static String DICT_TYPE_APS_FACTORY = "aps_factory";

    /**
     * 排产区域
     */
    private final static String DICT_TYPE_APS_AREA = "aps_area";

    private void checkDictArea() {
        SysDictType type = dictTypeMapper.selectDictTypeByType(DICT_TYPE_APS_AREA);
        if (type == null) {
            type = new SysDictType();
            type.setDictType(DICT_TYPE_APS_AREA);
            type.setDictName("排产区域");
            type.setStatus("0");
            type.setCreateBy(SecurityUtils.getUsername());
            int row = dictTypeMapper.insertDictType(type);
            if (row > 0) {
                DictUtils.setDictCache(type.getDictType(), null);
            }
        }
    }

    /**
     * 笛卡尔积: 根据工厂和专业字典生成区域字典数据
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public void updateApsAreaDictData() {
        checkDictArea();
        List<SysDictData> facs = dictDataMapper.selectDictDataByType(DICT_TYPE_APS_FACTORY);
        List<SysDictData> domains = dictDataMapper.selectDictDataByType(DICT_TYPE_APS_DOMAIN);
        List<SysDictData> areas = dictDataMapper.selectDictDataByType(DICT_TYPE_APS_AREA);
        facs.forEach(fac -> {
            domains.forEach(domain -> {
                String dictValue = domain.getDictValue() + "-" + fac.getDictValue();
                SysDictData area = areas.stream().filter(a -> Objects.equals(a.getDictValue(), dictValue)).findFirst().orElse(null);
                if (area == null) {
                    area = new SysDictData();
                    area.setDictValue(dictValue);
                    area.setDictType(DICT_TYPE_APS_AREA);
                    area.setCreateBy(SecurityUtils.getUsername());
                    if (fac.getDictSort() != null && domain.getDictSort() != null) {
                        area.setDictSort(domain.getDictSort() * 1000 + fac.getDictSort());
                    }
                    area.setDictLabel(domain.getDictLabel() + "-" + fac.getDictLabel());
                    area.setStatus("0");
                    area.setCssClass(domain.getCssClass());
                    insertDictData(area);
                } else {
                    area.setUpdateBy(SecurityUtils.getUsername());
                    area.setDictLabel(domain.getDictLabel() + "-" + fac.getDictLabel());
                    if (fac.getDictSort() != null && domain.getDictSort() != null) {
                        area.setDictSort(domain.getDictSort() * 1000 + fac.getDictSort());
                    }
                    updateDictData(area);
                }
            });
        });
    }

    /**
     * 新增保存字典数据信息
     *
     * @param data 字典数据信息
     * @return 结果
     */
    @Override
    public int insertDictData(SysDictData data) {
        int row = dictDataMapper.insertDictData(data);
        if (row > 0) {
            List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(data.getDictType());
            DictUtils.setDictCache(data.getDictType(), dictDatas);
        }
        return row;
    }

    /**
     * 修改保存字典数据信息
     *
     * @param data 字典数据信息
     * @return 结果
     */
    @Override
    public int updateDictData(SysDictData data) {
        int row = dictDataMapper.updateDictData(data);
        if (row > 0) {
            List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(data.getDictType());
            DictUtils.setDictCache(data.getDictType(), dictDatas);
        }
        return row;
    }
}