package com.xhly.manageapp.utils;


import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 * @Description 公用工具类
 * @Author WN
 * @Date 2023/7/24 11:27:10
 **/

public class ToolUtils {

    /**
     * @Description 字符串是否不为空
     * @Param [obj]
     * @Author WN
     * @Return boolean
     */
    public static boolean isNotEmpty(Object obj) {
        return null != obj && !"".equals(obj.toString().trim());
    }

    /**
     * @Description 字符串是否为空
     * @Param [obj]
     * @Author WN
     * @Return boolean
     */
    public static boolean isEmpty(Object obj) {
        return null == obj || "".equals(obj.toString().trim()) || "null".equals(obj.toString().trim());
    }

    /**
     * json字符串是否不为空
     * @Return boolean
     * @Param [jsonStr]
     * @Author ywx
     * @Date 2020/5/13 16:06
     **/
    public static boolean isJsonStrNotEmpty(String jsonStr) {
        return isNotEmpty(jsonStr) && !jsonStr.equals("[]");
    }


    /**
     * 功能描述  integer 是否是有效的类型
     * @Param obj
     * @Return boolean
     * @Author WN
     * @Date 2019/7/15
     */
    public static boolean isTrueInteger(Integer obj) {
        return null != obj && obj > 0;
    }

    /**
     * 去除字符串中前后的全、半角空格
     * @Return java.lang.String
     * @Param [str]
     * @Author ywx
     * @Date 2020/4/1 9:57
     **/
    public static String strTrim(String str) {
        str = str.trim();// 去除字符串前后的半角空格
        while (str.startsWith("　")) {// 去除字符串前的全角空格
            str = str.substring(1).trim();
        }
        while (str.endsWith("　")) {// 去除字符串后的全角空格
            str = str.substring(0, str.length() - 1).trim();
        }
        return str;
    }


    /**

    /**
     * @Return boolean
     * @Description list不为空
     * @Author ywx
     * @Date 2023/8/10 15:01
     **/
    public static boolean isListNotEmpty(List list) {
        return null != list && list.size() > 0;
    }

    /**
     * @Return boolean
     * @Description list为空
     * @Author ywx
     * @Date 2023/8/10 15:01
     **/
    public static boolean isListEmpty(List list) {
        return null == list || list.size() <= 0;
    }

    /**
     * @Description UUID的版本4是通过生成一个包含128位随机数的UUID来实现的。
     * 这些随机数是通过操作系统提供的随机数生成器生成的，保证了UUID的唯一性和随机性。
     * 因此，每次调用UUID.randomUUID()方法都会生成一个不同的UUID值。
     * @Date 2023/8/11 16:39
     * @Author YWX
     * @Param []
     * @Return java.lang.String
     **/
    public static String generateUUIDv4() {
        try {
            String uuid = UUID.randomUUID().toString();
            return uuid.replaceAll("-", "");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    // 构建树
    public static List<Map<String, Object>> buildTree(List<Map<String, Object>> trees
            , String id, String pid, String cname) {
        // 获取grouppid为空的根节点
        List<Map<String, Object>> list = trees.stream().filter(
                item -> ToolUtils.isEmpty(item.get(pid))).collect(Collectors.toList());
        // 根据grouppid进行分组
        Map<String, List<Map<String, Object>>> map = trees.stream().filter(
                m -> ToolUtils.isNotEmpty(m.get(pid))).collect(
                Collectors.groupingBy(m -> m.get(pid).toString(), LinkedHashMap::new, Collectors.toList()));
        recursionTree(list, map, id, cname);
        return list;
    }

    // 递归遍历节点
    public static void recursionTree(List<Map<String, Object>> list, Map<String, List<Map<String, Object>>> map
            , String id, String cname) {
        for (Map<String, Object> treeSelect : list) {
            List<Map<String, Object>> childList = map.get(treeSelect.get(id).toString());
            treeSelect.put(cname, childList);
            if (null != childList && 0 < childList.size()) {
                recursionTree(childList, map, id, cname);
            }
        }
    }

    /**
     * @Description 递归搜索父节点并将其添加到指定列表中
     * @Date 2024/1/3 9:26
     * @Author YWX
     * @Param [list1（到目前为止找到的节点列表）, list2（需要查找父节点的子节点列表）, list（完整节点列表）, id, pid]
     * @Return void
     **/
    public static void searchParents(List<Map<String, Object>> list1, List<Map<String, Object>> list2
            , List<Map<String, Object>> list, String id, String pid) {
        List<Map<String, Object>> parents = new ArrayList<>();
        for (Map<String, Object> t : list2) {
            Object treepid = t.get(pid);
            if (ToolUtils.isEmpty(treepid)) continue;
            Map<String, Object> parent = list.stream().filter(p -> treepid.equals(p.get(id))).findFirst().orElse(null);
            // 如果找到父节点且父节点不在parents列表中，则将其添加到parents列表中
            if (parent != null && !parents.contains(parent)) parents.add(parent);
        }

        // 如果`parents`列表不为空，将其中的父节点添加到`list1`列表中，
        // 并递归调用`searchParents`方法，将`parents`列表作为新的子节点列表传入，继续搜索更高层级的父节点。
        if (ToolUtils.isListNotEmpty(parents)) {
            for (Map<String, Object> parent : parents) {
                // 如果找到的父节点尚未存在于list1中，则将其添加到list1中
                if (!list1.contains(parent)) list1.add(parent);
            }
            // 递归地遍历子节点，并从提供的列表中获取它们的父节点
            searchParents(list1, parents, list, id, pid);
        }
    }

    /**
     * @Description 数字是否包含在集合中的数字集合
     * @Date 2023/11/10 11:43
     * @Author YWX
     * @Param [num, nums]
     * @Return boolean
     **/
    public static boolean numInList(Integer num, List<Integer> nums) {
        return isListNotEmpty(nums) && nums.contains(new Integer(num));
    }

    /**
     * 随机生成4位随机码
     * @Return java.lang.Integer
     * @Param []
     * @Author ywx
     * @Date 2020/5/8 9:29
     **/
    public static Integer messageCode() {
        return (int) ((Math.random() * 9 + 1) * 1000);
    }

    /*
     * @Description 验证手机号
     * @Date 2024/3/12 16:12:34
     * @Author WN
     * @Param [phone]
     * @Return boolean
     **/
    public static boolean checkPhone(String phone){
        String regex="^1[3456789]\\d{9}$";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(phone);

        return matcher.matches();
    }



    /**
     * @Description 性别名称转数字
     * @Date 2024/3/25 14:30
     * @Author YWX
     * @Param [userSex]
     * @Return java.lang.Integer
     **/
    public static Integer getUserSex(String userSex) {
        if (ToolUtils.isEmpty(userSex)) return 0;
        int usersex;
        switch (userSex) {
            case "男":
                usersex = 1;
                break;
            case "女":
                usersex = 2;
                break;
            default:
                usersex = 0;
                break;
        }
        return usersex;
    }

    /**
     * @Description 去除字符串末尾的0，如果最后一个字符是小数点，也一并移除
     * @Date 2024/3/28 14:43
     * @Author YWX
     * @Param [numStr]
     * @Return java.lang.String
     **/
    public static String removeTrailingZeros(String numStr) {
        StringBuilder sb = new StringBuilder(numStr);
        int i = sb.length() - 1;
        while (i >= 0 && sb.charAt(i) == '0') {
            sb.deleteCharAt(i);
            i--;
        }
        if (sb.length() > 0 && sb.charAt(sb.length() - 1) == '.') {
            sb.deleteCharAt(sb.length() - 1); // 如果最后一个字符是小数点，也一并移除
        }
        return sb.toString();
    }


}
