package cn.cslg.pas.service.business;

import cn.cslg.pas.common.utils.Response;
import cn.cslg.pas.domain.business.SystemDict;
import cn.cslg.pas.mapper.SystemDictMapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.RequiredArgsConstructor;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.stream.Collectors;

/**
 * <p>
 * 系统字典 服务类
 * </p>
 *
 * @author 王岩
 * @since 2022-03-30
 */
@Service
@RequiredArgsConstructor(onConstructor_ = {@Lazy})
public class SystemDictService extends ServiceImpl<SystemDictMapper, SystemDict> {

    public Map<String, List<SystemDict>> getOsSystemDict(List<String> types) {
        Map<String, List<SystemDict>> systemDictMap = new HashMap<>();
        LambdaQueryWrapper<SystemDict> queryWrapper = new LambdaQueryWrapper<>();
        if (types != null && types.size() > 0) {
            queryWrapper.in(SystemDict::getType, types);
        }
        List<SystemDict> systemDictList = this.list(queryWrapper);
        types = systemDictList.stream().map(SystemDict::getType).collect(Collectors.toList());
        types = types.stream().distinct().collect(Collectors.toList());
        Set set = new HashSet();
        set.addAll(systemDictList);
        types.forEach(item -> {
            List<SystemDict> systemDictList1 = systemDictList.stream().filter(t -> t.getType().equals(item)).collect(Collectors.toList());
            systemDictMap.put(item, systemDictList1);

        });
        return systemDictMap;
    }

    public List<SystemDict> getSystemDictListByType(List<String> type) {
        if (type == null || type.size() == 0) {
            return new ArrayList<>();
        }
        LambdaQueryWrapper<SystemDict> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.in(SystemDict::getType, type);
        return this.list(queryWrapper);
    }

    public String getSystemDictLabelByTypeAndValue(String type, Object value) {
        LambdaQueryWrapper<SystemDict> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(SystemDict::getType, type);
        queryWrapper.eq(SystemDict::getValue, value);
        SystemDict systemDict = this.getOne(queryWrapper);
        if (systemDict != null) {
            return systemDict.getLabel();
        }
        return "";
    }


    public List<String> getScenarioOrderIds(Integer orderType) {
        LambdaQueryWrapper<SystemDict> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.select(SystemDict::getValue);
        queryWrapper.eq(SystemDict::getType, "ENTERPRISE_APPLICATION_SCENARIO");
        if (orderType != null && orderType.equals(0)) {
            queryWrapper.orderByAsc(SystemDict::getLabel);
        } else {
            queryWrapper.orderByDesc(SystemDict::getLabel);
        }
        java.util.function.Function<Object, String> f = (o -> o.toString());
        List<String> ids = this.listObjs(queryWrapper, f);
        return ids;
    }

    public List<String> getCronsOrderIds(Integer orderType) {
        LambdaQueryWrapper<SystemDict> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.select(SystemDict::getValue);
        queryWrapper.eq(SystemDict::getGroupType, "ASSESS");
        if (orderType.equals(0)) {
            queryWrapper.orderByAsc(SystemDict::getLabel);
        } else {
            queryWrapper.orderByDesc(SystemDict::getLabel);
        }
        java.util.function.Function<Object, String> f = (o -> o.toString());
        List<String> ids = this.listObjs(queryWrapper, f);
        return ids;
    }


    public List<SystemDict> getCrons(Integer reportType) {
        String type = "";
        if (reportType == null) {
            type = "";
            reportType = -1;
        }

        switch (reportType) {
            case 0:
                type = "INVALID_ASSESS";
                break;
        }
        LambdaQueryWrapper<SystemDict> queryWrapper = new LambdaQueryWrapper<>();
        if (type.equals("")) {
            queryWrapper.eq(SystemDict::getGroupType, "ASSESS");
        } else {
            queryWrapper.eq(SystemDict::getType, type);
        }
        List<SystemDict> systemDictList = this.list(queryWrapper);
        return systemDictList;
    }

    public List<SystemDict> getSystemDictByTypeAndValue(String type, List<String> values) {
        LambdaQueryWrapper<SystemDict> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(SystemDict::getType, type);
        if (values != null) {
            queryWrapper.in(SystemDict::getValue, values);
        }
        List<SystemDict> systemDictList = this.list(queryWrapper);
        return systemDictList;
    }

    public List<SystemDict> getSystemDictByTypeAndSimpleLabel(String type, List<String> labels) {
        LambdaQueryWrapper<SystemDict> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(SystemDict::getType, type)
                .in(SystemDict::getSimpleLabel, labels);
        List<SystemDict> systemDictList = this.list(queryWrapper);
        return systemDictList;
    }
}