package com.xly.util;

import cn.hutool.core.util.ObjectUtil;
import com.xly.entity.ParamRule;

import java.lang.reflect.Array;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

public class Validator {

    // 判断对象是否有效（非0，非空字符串，非空数组/集合）
    public static boolean isValid(Object obj) {
        if (obj == null)
            return false;

        // 数值
        if (obj instanceof Number) {
            return ((Number) obj).doubleValue() != 0;
        }

        // 数组
        if (obj.getClass().isArray()) {
            return Array.getLength(obj) > 0;
        }

        // 集合
        if (obj instanceof Collection) {
            return !((Collection<?>) obj).isEmpty();
        }

        // Map
        if (obj instanceof Map) {
            return !((Map<?, ?>) obj).isEmpty();
        }
        return ObjectUtil.isNotEmpty(obj);
    }

    /**
     * 根据指定 key 对 List<Map<String, Object>> 去重
     *
     * @param list 原始列表
     * @param key  去重依据的 key
     * @return 去重后的列表（保留首次出现的顺序）
     */
    public static List<Map<String, Object>> distinctByKey(
            List<Map<String, Object>> list, String key) {

        if (list == null || list.isEmpty()) {
            return new ArrayList<>();
        }

        return list.stream()
                .filter(item -> item != null && item.get(key) != null)
                .collect(Collectors.toMap(
                        item -> item.get(key),
                        Function.identity(),
                        (existing, replacement) -> existing
                ))
                .values()
                .stream()
                .collect(Collectors.toList());
    }
    /***
     * @Author 钱豹
     * @Date 0:58 2026/7/2
     * @Param [source, one]
     * @return java.util.List<com.xly.entity.ParamRule>
     * @Description 去重
     **/
    public static List<ParamRule> deduplicateByParamValue(List<ParamRule> source) {
        if (source == null || source.isEmpty()) {
            return new ArrayList<>();
        }
        return source.stream()
                .collect(Collectors.toMap(
                        rule -> Arrays.asList(
                                rule.getSParamValue(),
                                rule.getSDynamicParam(),
                                rule.getSDynamicParamName()
                        ),
                        Function.identity(),
                        (existing, replacement) -> existing  // 保留第一个
                ))
                .values()
                .stream()
                .collect(Collectors.toList());
    }

}