package com.mzl.flower.service.system;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.mzl.flower.base.cache.DictCacheClient;
import com.mzl.flower.config.exception.ValidationException;
import com.mzl.flower.config.security.SecurityUtils;
import com.mzl.flower.dto.request.system.*;
import com.mzl.flower.dto.response.system.CodeTypeDTO;
import com.mzl.flower.dto.response.system.CodeValueDTO;
import com.mzl.flower.entity.system.CodeType;
import com.mzl.flower.entity.system.CodeValue;
import com.mzl.flower.mapper.system.CodeTypeMapper;
import com.mzl.flower.mapper.system.CodeValueMapper;
import com.mzl.flower.service.BaseService;
import com.mzl.flower.utils.UUIDGenerator;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

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

@Service
@Transactional
public class CodeService extends BaseService {

    @Autowired
    private CodeValueMapper valueMapper;

    @Autowired
    private CodeTypeMapper typeMapper;

    @Autowired
    private DictCacheClient dictCacheClient;

    public List<CodeValueDTO> searchValue(String typeCode) {
        return valueMapper.selectByTypeCode(typeCode);
    }

    public Map<String, List<CodeValueDTO>> searchMultipleValue(String typeCode) {
        List<String> types = splitParam(typeCode);
        if (types == null || types.size() == 0) {
            return new HashMap<>();
        }

        List<CodeValueDTO> result = valueMapper.selectByMultipleTypeCode(types);
        Map<String, List<CodeValueDTO>> map = new HashMap<>();
        if (result != null && result.size() > 0) {
            for (CodeValueDTO d : result) {
                String code = d.getTypeCode();
                List<CodeValueDTO> ll = map.computeIfAbsent(code, k -> new ArrayList<>());
                ll.add(d);
            }
        }

        return map;
    }

    public void refreshCache() {
        dictCacheClient.deleteAll();
        List<CodeValue> dictValues = valueMapper.selectList(new QueryWrapper<>());
        for (CodeValue dictValue : dictValues) {
            dictCacheClient.addDict(dictValue.getTypeCode(), dictValue.getValue(), dictValue.getLabel());
        }
    }

    /**
     * 新增字典类型
     */
    public void addType(CreateCodeTypeDTO dto) {
        Integer count = typeMapper.selectCount(new QueryWrapper<CodeType>()
                .eq("code", dto.getCode()));
        if(count > 0){
            throw new ValidationException("类型已存在");
        }
        CodeType type = new CodeType();
        type.setId(UUIDGenerator.getUUID());
        type.setName(dto.getName());
        type.setCode(dto.getCode());
        type.setDescription(dto.getDescription());
        type.create(SecurityUtils.getUserId());
        typeMapper.insert(type);
    }

    /**
     * 更新字典类型
     */
    public void updateType(UpdateCodeTypeDTO dto) {
        CodeType type = typeMapper.selectById(dto.getId());
        type.setName(dto.getName());
        type.setDescription(dto.getDescription());
        type.update(SecurityUtils.getUserId());
        typeMapper.updateById(type);
    }

    /**
     * 新增字典值
     */
    public void addCodeValue(CreateCodeValueDTO dto) {
        CodeValue c = new CodeValue();
        String typeCode = dto.getTypeCode();
        String stringValue = dto.getValue();
        String label = dto.getLabel();
        List<Integer> seq = valueMapper.selectSeqByCode(typeCode);
        c.setId(UUIDGenerator.getUUID());
        c.setTypeCode(dto.getTypeCode());
        c.setValue(stringValue);
        c.setLabel(label);
        c.setDescription(dto.getDescription());
        if (seq != null && seq.size() > 0) {
            c.setSeq(seq.get(0) + 1);
        } else {
            c.setSeq(0);
        }
        c.create(SecurityUtils.getUserId());
        valueMapper.insert(c);
        dictCacheClient.addDict(typeCode, stringValue, label);
    }

    /**
     * 更新字典值
     */
    public void updateValue(UpdateCodeValueDTO dto) {
        CodeValue c = valueMapper.selectById(dto.getId());
        String typeCode = c.getTypeCode();
        String stringValue = dto.getValue();
        String label = dto.getLabel();
        c.setLabel(label);
        c.setDescription(dto.getDescription());
        c.setValue(stringValue);
        c.update(SecurityUtils.getUserId());
        valueMapper.updateById(c);
        dictCacheClient.addDict(typeCode, stringValue, label);
    }

    /**
     * 按条件查询字典类型
     */
    public Page<CodeTypeDTO> searchCodeType(Page page, QueryCodeTypeDTO dto) {
        List<CodeTypeDTO> result = typeMapper.searchCodeType(page, dto);
        page.setRecords(result);
        return page;
    }

    /**
     * 按ID逻辑删除字典类型
     */
    public void deleteCodeType(String id) {
        CodeType type = typeMapper.selectById(id);
        if(type == null){
            throw new ValidationException("类型不存在");
        }
        List<CodeValueDTO> valueDTOS = valueMapper.selectByTypeCode(type.getCode());
        for (CodeValueDTO v : valueDTOS) {
            deleteCodeValue(v.getId());
            dictCacheClient.deleteDict(v.getTypeCode(), v.getValue());
        }
        typeMapper.deleteById(id);
    }

    public void deleteCodeValue(String id) {
        CodeValue v = valueMapper.selectById(id);
        if(v == null){
            throw new ValidationException("字典不存在");
        }
        String typeCode = v.getTypeCode();
        String stringValue = v.getValue();
        dictCacheClient.deleteDict(typeCode, stringValue);

        valueMapper.deleteById(id);
    }
}