package com.mvc.utils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.mvc.iot.aep.model.AepResponseRootModel;
import org.apache.commons.lang3.StringUtils;

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

public class StringUtil {
    /**
     * 正则表达式检测
     *
     * @param data
     * @param pattern
     * @return
     */
    public static boolean regularCheck(String data, String pattern) {
        if (io.netty.util.internal.StringUtil.isNullOrEmpty(data)) {
            return true;
        }
        Pattern p = Pattern.compile(pattern);
        Matcher m = p.matcher(data);
        return m.matches();
    }

    /**
     * 补齐字符串
     *
     * @param data
     * @param size
     * @return
     */
    public static String leftPad(String data, int size) {
        String result = data;
        if (io.netty.util.internal.StringUtil.isNullOrEmpty(result)) {
            result = "";
        }
        return StringUtils.leftPad(result, size);
    }

    /**
     * 补齐字符串
     *
     * @param data
     * @param size
     * @return
     */
    public static String leftPad(String data, int size, char padChar) {
        String result = data;
        if (io.netty.util.internal.StringUtil.isNullOrEmpty(result)) {
            result = "";
        }
        return StringUtils.leftPad(result, size, '0');
    }


    public static String getUuid() {
        UUID uuid = UUID.randomUUID();
        String res = uuid.toString().replace("-", "");
        return res;
    }

    /**
     * byte数组转ascii字符串
     *
     * @param bytes
     * @return
     */
    public static String getStringByBytes(byte[] bytes) {
        try {
            return new String(bytes, "ascii");
        } catch (Exception e) {
            return "";
        }
    }

    //随机生成字母数字
    public static String getCharAndNumr(int length) {
        String val = "";
        Random random = new Random();
        for (int i = 0; i < length; i++) {
            // 输出字母还是数字
            String charOrNum = random.nextInt(2) % 2 == 0 ? "char" : "num";
            // 字符串
            if ("char".equalsIgnoreCase(charOrNum)) {
                // 取得大写字母还是小写字母
                int choice = random.nextInt(2) % 2 == 0 ? 65 : 97;
                val += (char) (choice + random.nextInt(26));
            } else if ("num".equalsIgnoreCase(charOrNum)) { // 数字
                val += String.valueOf(random.nextInt(10));
            }
        }
        return val;
    }

    //获取带-的大写GUID
    public static String getUuid2() {
        UUID uuid = UUID.randomUUID();
        return uuid.toString().toUpperCase();
    }

    /**
     * 判断是否为整数
     *
     * @param str 传入字符串
     * @return 是整数返回true，否则返回false
     */
    public static boolean isInteger(String str) {
        Pattern pattern = Pattern.compile("^[-\\+]?[\\d]*$");
        return pattern.matcher(str).matches();
    }

    /**
     * 是否IP:Port格式
     *
     * @param str
     * @return
     */
    public static boolean isIPAndPort(String str) {
        String rex = "^(\\d{1,2}|1\\d\\d|2[0-4]\\d|25[0-5])\\.(\\d{1,2}|1\\d\\d|2[0-4]\\d|25[0-5])\\.(\\d{1,2}|1\\d\\d|2[0-4]\\d|25[0-5])\\.(\\d{1,2}|1\\d\\d|2[0-4]\\d|25[0-5])\\:([0-9]|[1-9]\\d{1,3}|[1-5]\\d{4}|6[0-5]{2}[0-3][0-5])$";
        Pattern pattern = Pattern.compile(rex);
        return pattern.matcher(str).matches();
    }

    /**
     * 判断是否是字母
     *
     * @param str 传入字符串
     * @return 是字母返回true，否则返回false
     */
    public static boolean is_alpha(String str) {
        if (str == null) return false;
        return str.matches("[a-zA-Z]+");
    }

    /**
     * 判断是否是字母或者数字
     *
     * @param str 传入字符串
     * @return 是字母返回true，否则返回false
     */
    public static boolean isLetterDigit(String str) {
        String regex = "^[a-z0-9A-Z]+$";
        return str.matches(regex);
    }

    /**
     * 格式化配置中标志类值(解析配置回执使用,防止设备中数据错乱,导致无法入库)
     *
     * @param str
     * @return
     */
    public static String formatConfigFlag(String str) {
        if (isInteger(str)) {
            Integer value = Integer.valueOf(str);
            if (value == 0 || value == 1) {
                return value.toString();
            }
        }
        return "";
    }

    // 去除字符串末尾的零
    public static String removeTrailingZeros(String input) {
        return input.replaceAll("0*$", "").replaceAll("\\.$", "");
    }

    /**
     * 返回 %value%
     *
     * @param value
     * @return
     */
    public static String getLikeFormat(String value) {
        return "%" + value + "%";
    }

    public static String debugInfoToString(Integer[][] array) {
        StringBuilder sb = new StringBuilder();
        for (Integer[] row : array) {
            // 对于每一行，遍历每个元素并用逗号分隔
            for (int i = 0; i < row.length; i++) {
                sb.append(row[i]);
                if (i < row.length - 1) {
                    sb.append(","); // 除了最后一个元素外，每个元素后都加逗号
                }
            }
            // 如果不是最后一行，添加一个分号作为行分隔符
            sb.append(";");
        }
        return sb.toString();
    }

    /**
     * 从输入字符串中提取所有字母。
     *
     * @param input 待处理的字符串，可以包含字母和其他字符。
     * @return 仅包含输入字符串中字母的新字符串，忽略大小写。
     */
    public static String extractLetters(String input) {
        StringBuilder sb = new StringBuilder();

        // 遍历输入字符串的每个字符，只保留字母
        for (char c : input.toCharArray()) {
            if (Character.isLetter(c)) {
                sb.append(c);
            }
        }
        return sb.toString();
    }

    /**
     * 从输入字符串中提取所有数字。
     *
     * @param input 待处理的字符串，可以包含数字和其他字符。
     * @return 仅包含输入字符串中数字的新字符串。
     */
    public static String extractDigits(String input) {
        StringBuilder sb = new StringBuilder();

        // 遍历输入字符串的每个字符，只保留数字
        for (char c : input.toCharArray()) {
            if (Character.isDigit(c)) {
                sb.append(c);
            }
        }
        return sb.toString();
    }

    /**
     * 将字符串数组转换为整数数组。
     *
     * @param strArray 待转换的字符串数组，每个元素都是整数的字符串。
     * @return 转换后的整数数组。
     */
    public static Integer[] stringArrayToIntArray(String[] strArray) {
        try {
            Integer[] intArray = new Integer[strArray.length];
            for (int i = 0; i < strArray.length; i++) {
                intArray[i] = Integer.valueOf(strArray[i]);
            }
            return intArray;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 验证给定的字符串中的手机号是否有效。
     * 手机号应该符合中国大陆手机号的标准格式。
     * 多个手机号之间可以用分号分隔。
     *
     * @param phoneNumberStr 包含手机号的字符串
     * @return 如果所有手机号都有效返回true，否则返回false
     */
    public static boolean isValidPhoneNumber(String phoneNumberStr) {
        // 定义中国大陆手机号的正则表达式
        String regex = "^(13[0-9]|14[5-9]|15[0-3,5-9]|16[2,5,6,7]|17[0-8]|18[0-9]|19[0-3,5-9])\\d{8}$";
        Pattern pattern = Pattern.compile(regex);

        // 将输入的字符串按照分号分割成多个手机号
        String[] phoneNumbers = phoneNumberStr.split(";");

        // 检查每个手机号是否都符合正则表达式
        for (String phoneNumber : phoneNumbers) {
            if (!pattern.matcher(phoneNumber.trim()).matches()) {
                return false;
            }
        }
        return true;
    }

    /**
     * 验证给定的字符串中的电子邮件地址是否有效。
     * 多个电子邮件地址之间可以用分号分隔。
     *
     * @param emailStr 包含电子邮件地址的字符串
     * @return 如果所有电子邮件地址都有效返回true，否则返回false
     */
    public static boolean isValidEmail(String emailStr) {
        // 定义电子邮件地址的正则表达式
        String regex = "^[\\w!#$%&'*+/=?`{|}~^-]+(?:\\.[\\w!#$%&'*+/=?`{|}~^-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,6}$";
        Pattern pattern = Pattern.compile(regex);

        // 将输入的字符串按照分号分割成多个电子邮件地址
        String[] emails = emailStr.split(";");

        // 检查每个电子邮件地址是否都符合正则表达式
        for (String email : emails) {
            if (!pattern.matcher(email.trim()).matches()) {
                return false;
            }
        }
        return true;
    }

    /**
     * 将给定的坐标字符串转换为3位数的格式。
     * 示例：输入 "1,2,3 4,5,6"，输出 "0001,0002,0003 0004,0005,0006"
     * @param input
     * @return
     */
    public static String convertCoordinateString(String input) {
        // 按空格分割输入字符串
        String[] points = input.split(" ");
        StringBuilder result = new StringBuilder();

        for (String point : points) {
            // 按逗号分割每个坐标点
            String[] coordinates = point.split(",");
            for (String coordinate : coordinates) {
                // 将每个坐标转换为4位数，不足的前面补0
                result.append(String.format("%04d", Integer.parseInt(coordinate)));
            }
        }

        return result.toString();
    }

    /**
     * 将4位数的坐标字符串反转为原始的坐标字符串。
     * @param input
     * @return
     */
    public static String reverseConvertCoordinateString(String input) {
        StringBuilder result = new StringBuilder();
        int length = input.length();

        for (int i = 0; i < length; i += 8) {
            // 每6个字符代表一个坐标点 (x,y)
            String x = input.substring(i, i + 4);
            String y = input.substring(i + 4, i + 8);

            // 将坐标点添加到结果字符串中
            if (result.length() > 0) {
                result.append(" ");
            }
            result.append(Integer.valueOf(x)).append(",").append(Integer.valueOf(y));
        }

        return result.toString();
    }

    public static void main(String[] args) {
        try {
            /*String json = "243,34 220,34 218,162 241,162";
            System.out.println(convertCoordinateString(json));*/
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

