package com.moral.api.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.moral.api.entity.SysDictData;
import com.moral.api.entity.SysDictType;
import com.moral.api.mapper.SysDictDataMapper;
import com.moral.api.pojo.dto.sysDictData.SysDictDataDTO;
import com.moral.api.pojo.form.sysDictData.SysDictDataDeleteForm;
import com.moral.api.pojo.form.sysDictData.SysDictDataInsertForm;
import com.moral.api.pojo.form.sysDictData.SysDictDataUpdateForm;
import com.moral.api.service.SysDictDataService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.moral.api.service.SysDictTypeService;
import com.moral.api.util.CacheUtils;
import com.moral.api.util.LogUtils;
import com.moral.constant.Constants;
import com.moral.constant.RedisConstants;
import com.moral.constant.ResponseCodeEnum;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.ObjectUtils;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * <p>
 * 字典表 服务实现类
 * </p>
 *
 * @author moral
 * @since 2021-04-13
 */
@Service
public class SysDictDataServiceImpl extends ServiceImpl<SysDictDataMapper, SysDictData> implements SysDictDataService {

    @Autowired
    SysDictTypeService sysDictTypeService;
    @Autowired
    SysDictDataMapper sysDictDataMapper;
    @Autowired
    RedisTemplate redisTemplate;
    @Autowired
    LogUtils logUtils;

    @Override
    @Transactional
    public SysDictDataDTO deleteData(SysDictDataDeleteForm form) {
        //创建返回对象
        SysDictDataDTO dto = new SysDictDataDTO();
        //取参
        Integer id = form.getId();
        //查询要删除的数据和类型，用于插入日志
        QueryWrapper existWrapper = new QueryWrapper();
        existWrapper.eq("is_delete", Constants.NOT_DELETE);
        existWrapper.eq("id", id);
        SysDictData existData = sysDictDataMapper.selectOne(existWrapper);
        SysDictType type = sysDictTypeService.getDictTypeById(existData.getDictTypeId());
        //执行删除
        UpdateWrapper deleteWrapper = new UpdateWrapper();
        deleteWrapper.set("is_delete", Constants.DELETE);
        deleteWrapper.eq("id", id);
        sysDictDataMapper.update(null, deleteWrapper);
        //插入日志
        StringBuilder content = new StringBuilder("删除了字典数据;");
        content.append("类型:"+type.getName()+"("+type.getDesc()+")"+";");
        content.append("key:"+existData.getDataKey()+";");
        content.append("value:"+existData.getDataValue()+";");
        logUtils.saveOperationForManage(content.toString(),Constants.DELETE_OPERATE_TYPE);
        //刷新缓存
        refreshCache();
        //封装返回对象
        dto.setCode(ResponseCodeEnum.SUCCESS.getCode());
        dto.setMsg(ResponseCodeEnum.SUCCESS.getMsg());
        return dto;
    }

    @Override
    public SysDictDataDTO updateData(SysDictDataUpdateForm form) {
        SysDictDataDTO dto = new SysDictDataDTO();
        //取参
        SysDictData sysDictData = form.formConvertEntity();
        //查询旧数据用于更新
        QueryWrapper<SysDictData> existWrapper = new QueryWrapper<>();
        existWrapper.eq("is_delete", Constants.NOT_DELETE);
        existWrapper.eq("id", sysDictData.getId());
        SysDictData existData = sysDictDataMapper.selectOne(existWrapper);
        SysDictType type = sysDictTypeService.getDictTypeById(existData.getDictTypeId());
        //判断key是否重复
        String key = sysDictData.getDataKey();
        if (!ObjectUtils.isEmpty(key)) {
            QueryWrapper<SysDictData> wrapper = new QueryWrapper<>();
            wrapper.eq("is_delete", Constants.NOT_DELETE);
            wrapper.eq("dataKey", key);
            wrapper.eq("dict_type_id", existData.getDictTypeId());
            SysDictData existKeyData = sysDictDataMapper.selectOne(wrapper);
            if (!ObjectUtils.isEmpty(existKeyData)) {
                dto.setCode(ResponseCodeEnum.DICTDATA_KEY_EXIST.getCode());
                dto.setMsg(ResponseCodeEnum.DICTDATA_KEY_EXIST.getMsg());
                return dto;
            }
        }
        //执行更新
        sysDictDataMapper.updateById(sysDictData);
        //插入日志
        StringBuilder content = new StringBuilder("修改了字典数据;");
        content.append("类型:"+type.getName()+"("+type.getDesc()+")"+";");
        content.append("key:"+existData.getDataKey()+";");
        content.append("value:"+existData.getDataValue()+"->"+sysDictData.getDataValue()+";");
        logUtils.saveOperationForManage(content.toString(),Constants.UPDATE_OPERATE_TYPE);
        //刷新缓存
        refreshCache();
        //封装返回结果
        dto.setCode(ResponseCodeEnum.SUCCESS.getCode());
        dto.setMsg(ResponseCodeEnum.SUCCESS.getMsg());
        return dto;
    }


    @Override
    public SysDictDataDTO insertData(SysDictDataInsertForm form) {
        SysDictDataDTO dto = new SysDictDataDTO();
        //取参
        SysDictData sysDictData = form.formConvertEntity();
        //取出类型用于插入日志使用
        SysDictType type = sysDictTypeService.getDictTypeById(sysDictData.getDictTypeId());
        if (ObjectUtils.isEmpty(type)) {
            dto.setCode(ResponseCodeEnum.DICTTYPE_NOT_EXIST.getCode());
            dto.setMsg(ResponseCodeEnum.DICTTYPE_NOT_EXIST.getMsg());
            return dto;
        }
        //判断Key是否重复
        String key = sysDictData.getDataKey();
        QueryWrapper<SysDictData> wrapper = new QueryWrapper<>();
        wrapper.eq("is_delete", Constants.NOT_DELETE);
        wrapper.eq("dataKey", key);
        wrapper.eq("dict_type_id", type.getId());
        SysDictData existKeyData = sysDictDataMapper.selectOne(wrapper);
        if (!ObjectUtils.isEmpty(existKeyData)) {
            dto.setCode(ResponseCodeEnum.DICTDATA_KEY_EXIST.getCode());
            dto.setMsg(ResponseCodeEnum.DICTDATA_KEY_EXIST.getMsg());
            return dto;
        }
        //执行插入
        sysDictDataMapper.insert(sysDictData);
        //插入日志
        StringBuilder content = new StringBuilder("添加了字典数据;");
        content.append("类型:"+type.getName()+"("+type.getDesc()+")"+";");
        content.append("key:"+sysDictData.getDataKey()+";");
        content.append("value:"+sysDictData.getDataValue()+";");
        logUtils.saveOperationForManage(content.toString(),Constants.INSERT_OPERATE_TYPE);
        //刷新缓存
        refreshCache();
        //封装返回结果
        dto.setCode(ResponseCodeEnum.SUCCESS.getCode());
        dto.setMsg(ResponseCodeEnum.SUCCESS.getMsg());
        return dto;
    }

    @Override
    public Map<String, Object> queryDataByTypeName(String typeName) {
        Map<String, List<SysDictData>> datas = getAllDictData();
        //获取字典数据
        List<SysDictData> sysDictData = datas.get(typeName);
        //将字典数据进行封装 Map  key：dataKey  value：dataValue
        Map<String, Object> result = new HashMap<>();
        for (SysDictData data : sysDictData) {
            result.put(data.getDataKey(), data.getDataValue());
        }
        return result;
    }

    @Override
    public Map<String, List<SysDictData>> getAllDictData() {
        Map<String, List<SysDictData>> datas = new HashMap<>();
        //从缓存中读取
        datas = (Map<String, List<SysDictData>>) redisTemplate.opsForValue().get(RedisConstants.DICT_DATA_KEY);
        if (ObjectUtils.isEmpty(datas)) {//从数据库中读取
            datas = getDictDataFromDB();
            //插入缓存
            redisTemplate.opsForValue().set(RedisConstants.DICT_DATA_KEY, datas);
        }
        return datas;
    }

    @Override
    public Map<String, SysDictData> getDictDatasByType(String type) {
        Map<String, List<SysDictData>> allDictData = getAllDictData();
        List<SysDictData> sysDictDatas = allDictData.get(type);
        Map<String, SysDictData> result = new HashMap<>();
        for (SysDictData sysDictData : sysDictDatas) {
            result.put(sysDictData.getDataKey(), sysDictData);
        }
        return result;
    }

    @Override
    public void refreshCache(){
        redisTemplate.delete(RedisConstants.DICT_DATA_KEY);
        Map<String, List<SysDictData>> datas = getDictDataFromDB();
        redisTemplate.opsForValue().set(RedisConstants.DICT_DATA_KEY, datas);
    }


    /**
     * @Description: 从数据库中根据字典类型读取字典数据，返回Map  Key：类型名称 value：数据集合
     * @Param: []
     * @return: java.util.Map<java.lang.String                                                               ,                                                               java.util.List                                                               <                                                               com.moral.api.entity.sysDictData>>
     * @Author: 陈凯裕
     * @Date: 2021/4/14
     */
    private Map<String, List<SysDictData>> getDictDataFromDB() {
        Map<String, List<SysDictData>> result = new HashMap<>();
        List<SysDictType> types = sysDictTypeService.getAllDictType();
        for (SysDictType type : types) {
            QueryWrapper<SysDictData> wrapper = new QueryWrapper<>();
            wrapper.eq("is_delete", Constants.NOT_DELETE);
            wrapper.eq("dict_type_id", type.getId());
            List<SysDictData> datas = sysDictDataMapper.selectList(wrapper);
            result.put(type.getName(), datas);
        }
        return result;
    }
}