package com.sckw.core.utils;

import com.sckw.core.model.constant.Global;

import java.util.*;

/**
 * @author lfdc
 * @description listUtils
 * @date 2023-08-08 11:08:11
 */
public class ListUtils {

    /**
     * 比较两个List集合是否相等
     * <p>注：1. 如果一个List的引用为<code>null</code>，或者其包含的元素个数为0，那么该List在本逻辑处理中都算作空；
     * <p>2. 泛型参数E涉及到对象，所以需要确保正确实现了对应对象的<code>equal()</code>方法。
     *
     * @param list1
     * @param list2
     * @return
     */
    public static <E> boolean isListEqual(List<E> list1, List<E> list2) {
        // 两个list引用相同（包括两者都为空指针的情况）
        if (list1 == list2) {
            return true;
        }

        // 两个list都为空（包括空指针、元素个数为0）
        if ((list1 == null && list2 != null && list2.size() == 0)
                || (list2 == null && list1 != null && list1.size() == 0)) {
            return true;
        }

        // 两个list元素个数不相同
        if (list1.size() != list2.size()) {
            return false;
        }

        // 两个list元素个数已经相同，再比较两者内容
        // 采用这种可以忽略list中的元素的顺序
        // 涉及到对象的比较是否相同时，确保实现了equals()方法
        if (!list1.containsAll(list2) && !list2.containsAll(list1)) {
            return false;
        }

        return true;
    }

    public static void main(String[] args) {
        // desc-倒叙  asc-正序
        String sortTyp = "asc";
        // 组装测试数据
        List<Map<String, Object>> list = initMapList();

        // 单个map排序
        Map<String, Object> map = list.get(0);
        Map<String, Object> sortMap = sortMap(map, sortTyp);
        // Map<String, Object> sortMap = sortByKey(map, false);
        for (Map.Entry<String, Object> entry : sortMap.entrySet()) {
            System.out.println("单个map排序" + sortTyp);
            System.out.println(entry.getKey());
        }

        // List<map>根据某个字段排序
        sortMapListByFeild(list, "age", sortTyp);
        System.out.println("按年纪取最大的一条数据，其姓名是：" + list.get(0).get("name"));
    }

    /**
     * List<Map>根据map字段排序
     *
     * @param list
     * @param feild   排序字段
     * @param sortTyp 排序方式 desc-倒序 asc-正序
     * @return
     */
    public static List<Map<String, Object>> sortMapListByFeild(List<Map<String, Object>> list, String feild, String sortTyp) {
        if (CollectionUtils.isNotEmpty(list)) {
            // 方法1
            list.sort((m1, m2) -> {
                if ("desc".equals(sortTyp)) {
                    return String.valueOf(m2.get(feild)).compareTo(String.valueOf(m1.get(feild)));
                } else {
                    return String.valueOf(m1.get(feild)).compareTo(String.valueOf(m2.get(feild)));
                }
            });

            // 方法2 也ok噢
            /*if (StringUtils.equals(sortTyp, "desc")) {
                Collections.sort(list, (m1, m2)-> String.valueOf(m2.get(feild)).compareTo(String.valueOf(m1.get(feild)))); // lamuda排序
            } else {
                Collections.sort(list, (m1, m2)-> String.valueOf(m1.get(feild)).compareTo(String.valueOf(m2.get(feild)))); // lamuda排序
            }*/
        }

        return list;
    }

    /**
     * map排序
     *
     * @param map
     * @return
     */
    public static Map<String, Object> sortMap(Map<String, Object> map, String sortTyp) {
        try {
            if ("desc".equals(sortTyp)) {
                // 定义个倒叙的set
                Set<String> sortSet = new TreeSet<>(Comparator.reverseOrder());
                // 获取全部key，添加后就自然倒序了
                sortSet.addAll(map.keySet());

                Map<String, Object> resp = new LinkedHashMap<>();
                for (String key : sortSet) {
                    // 按顺序放入新map
                    resp.put(key, map.get(key));
                }

                return resp;
            } else {
                // TreeMap 本身就是正序的
                return new TreeMap<>(map);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return map;
    }

    /**
     * 根据map的key排序
     *
     * @param map    待排序的map
     * @param isDesc 是否降序，true：降序，false：升序
     * @param <K>
     * @param <V>
     * @return
     */
    public static <K extends Comparable<? super K>, V> Map<K, V> sortByKey(Map<K, V> map, boolean isDesc) {
        Map<K, V> result = new LinkedHashMap<>();
        if (isDesc) {
            map.entrySet().stream().sorted(Map.Entry.<K, V>comparingByKey().reversed())
                    .forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
        } else {
            map.entrySet().stream().sorted(Map.Entry.<K, V>comparingByKey())
                    .forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
        }
        return result;
    }

    private static List<Map<String, Object>> initMapList() {
        List<Map<String, Object>> lists = new ArrayList<>();

        Map<String, Object> map = new HashMap<>(Global.NUMERICAL_SIXTEEN);
        map.put("name", "王五");
        map.put("age", 55);
        map.put("mobile", "15900001112");
        lists.add(map);

        Map<String, Object> map1 = new HashMap<>(Global.NUMERICAL_SIXTEEN);
        map1.put("name", "李四");
        map1.put("age", 18);
        map1.put("mobile", "15900001111");
        lists.add(map1);

        Map<String, Object> map2 = new HashMap<>(Global.NUMERICAL_SIXTEEN);
        map2.put("name", "赵六");
        map2.put("age", 58);
        map2.put("mobile", "13700001111");
        lists.add(map2);

        return lists;
    }
}
