package com.ims.common.utils;

import cn.hutool.core.text.StrBuilder;
import cn.hutool.core.text.StrFormatter;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Collection;
import java.util.Map;
import java.util.UUID;
import java.util.regex.Pattern;

public class StringUtils{
	/** 空字符串 */
	private static final String NULLSTR = "";

	/** 下划线 */
	private static final char SEPARATOR = '_';

	/**
	 * 获取参数不为空值
	 *
	 * @param value defaultValue 要判断的value
	 * @return value 返回值
	 */
	public static <T> T nvl(T value, T defaultValue)
	{
		return value != null ? value : defaultValue;
	}

	/**
	 * * 判断一个Collection是否为空， 包含List，Set，Queue
	 *
	 * @param coll 要判断的Collection
	 * @return true：为空 false：非空
	 */
	public static boolean isEmpty(Collection<?> coll)
	{
		return isNull(coll) || coll.isEmpty();
	}

	/**
	 * * 判断一个Collection是否非空，包含List，Set，Queue
	 *
	 * @param coll 要判断的Collection
	 * @return true：非空 false：空
	 */
	public static boolean isNotEmpty(Collection<?> coll)
	{
		return !isEmpty(coll);
	}

	/**
	 * * 判断一个对象数组是否为空
	 *
	 * @param objects 要判断的对象数组
	 ** @return true：为空 false：非空
	 */
	public static boolean isEmpty(Object[] objects)
	{
		return isNull(objects) || (objects.length == 0);
	}

	/**
	 * * 判断一个对象数组是否非空
	 *
	 * @param objects 要判断的对象数组
	 * @return true：非空 false：空
	 */
	public static boolean isNotEmpty(Object[] objects)
	{
		return !isEmpty(objects);
	}

	/**
	 * * 判断一个Map是否为空
	 *
	 * @param map 要判断的Map
	 * @return true：为空 false：非空
	 */
	public static boolean isEmpty(Map<?, ?> map)
	{
		return isNull(map) || map.isEmpty();
	}

	/**
	 * * 判断一个Map是否为空
	 *
	 * @param map 要判断的Map
	 * @return true：非空 false：空
	 */
	public static boolean isNotEmpty(Map<?, ?> map)
	{
		return !isEmpty(map);
	}

	/**
	 * * 判断一个字符串是否为空串
	 *
	 * @param str String
	 * @return true：为空 false：非空
	 */
	public static boolean isEmpty(String str)
	{
		return isNull(str) || NULLSTR.equals(str.trim());
	}

	/**
	 * * 判断一个字符串是否为非空串
	 *
	 * @param str String
	 * @return true：非空串 false：空串
	 */
	public static boolean isNotEmpty(String str)
	{
		return !isEmpty(str);
	}

	/**
	 * * 判断一个对象是否为空
	 *
	 * @param object Object
	 * @return true：为空 false：非空
	 */
	public static boolean isNull(Object object)
	{
		return object == null;
	}

	/**
	 * * 判断一个对象是否非空
	 *
	 * @param object Object
	 * @return true：非空 false：空
	 */
	public static boolean isNotNull(Object object)
	{
		return !isNull(object);
	}

	/**
	 * * 判断一个对象是否是数组类型（Java基本型别的数组）
	 *
	 * @param object 对象
	 * @return true：是数组 false：不是数组
	 */
	public static boolean isArray(Object object)
	{
		return isNotNull(object) && object.getClass().isArray();
	}

	/**
	 * 去空格
	 */
	public static String trim(String str)
	{
		return (str == null ? "" : str.trim());
	}

	/**
	 * 截取字符串
	 *
	 * @param str 字符串
	 * @param start 开始
	 * @return 结果
	 */
	public static String substring(final String str, int start)
	{
		if (str == null)
		{
			return NULLSTR;
		}

		if (start < 0)
		{
			start = str.length() + start;
		}

		if (start < 0)
		{
			start = 0;
		}
		if (start > str.length())
		{
			return NULLSTR;
		}

		return str.substring(start);
	}

	/**
	 * 截取字符串
	 *
	 * @param str 字符串
	 * @param start 开始
	 * @param end 结束
	 * @return 结果
	 */
	public static String substring(final String str, int start, int end)
	{
		if (str == null)
		{
			return NULLSTR;
		}

		if (end < 0)
		{
			end = str.length() + end;
		}
		if (start < 0)
		{
			start = str.length() + start;
		}

		if (end > str.length())
		{
			end = str.length();
		}

		if (start > end)
		{
			return NULLSTR;
		}

		if (start < 0)
		{
			start = 0;
		}
		if (end < 0)
		{
			end = 0;
		}

		return str.substring(start, end);
	}

	/**
	 * 格式化文本, {} 表示占位符<br>
	 * 此方法只是简单将占位符 {} 按照顺序替换为参数<br>
	 * 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br>
	 * 例：<br>
	 * 通常使用：format("this is {} for {}", "a", "b") -> this is a for b<br>
	 * 转义{}： format("this is \\{} for {}", "a", "b") -> this is \{} for a<br>
	 * 转义\： format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>
	 *
	 * @param template 文本模板，被替换的部分用 {} 表示
	 * @param params 参数值
	 * @return 格式化后的文本
	 */
	public static String format(String template, Object... params)
	{
		if (isEmpty(params) || isEmpty(template))
		{
			return template;
		}
		return StrFormatter.format(template, params);
	}

	/**
	 * 驼峰首字符小写 NameVc>>nameVc
	 */
	public static String uncapitalize(String str)
	{
		int strLen;
		if (str == null || (strLen = str.length()) == 0)
		{
			return str;
		}
		return new StrBuilder(strLen).append(Character.toLowerCase(str.charAt(0))).append(str.substring(1)).toString();
	}


	/**
	 * 下划线转驼峰命名 nameVc>>name_vc
	 */
	public static String toUnderScoreCase(String s)
	{
		if (s == null)
		{
			return null;
		}
		StringBuilder sb = new StringBuilder();
		boolean upperCase = false;
		for (int i = 0; i < s.length(); i++)
		{
			char c = s.charAt(i);

			boolean nextUpperCase = true;

			if (i < (s.length() - 1))
			{
				nextUpperCase = Character.isUpperCase(s.charAt(i + 1));
			}

			if ((i > 0) && Character.isUpperCase(c))
			{
				if (!upperCase || !nextUpperCase)
				{
					sb.append(SEPARATOR);
				}
				upperCase = true;
			}
			else
			{
				upperCase = false;
			}

			sb.append(Character.toLowerCase(c));
		}

		return sb.toString();
	}

	/**
	 * 是否包含字符串
	 *
	 * @param str 验证字符串
	 * @param strs 字符串组
	 * @return 包含返回true
	 */
	public static boolean inStringIgnoreCase(String str, String... strs)
	{
		if (str != null && strs != null)
		{
			for (String s : strs)
			{
				if (str.equalsIgnoreCase(trim(s)))
				{
					return true;
				}
			}
		}
		return false;
	}

	/**
	 * 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。 例如：HELLO_WORLD->HelloWorld
	 *
	 * @param name 转换前的下划线大写方式命名的字符串
	 * @return 转换后的驼峰式命名的字符串
	 */
	public static String convertToCamelCase(String name)
	{
		StringBuilder result = new StringBuilder();
		// 快速检查
		if (name == null || name.isEmpty())
		{
			// 没必要转换
			return "";
		}
		else if (!name.contains("_"))
		{
			// 不含下划线，仅将首字母大写
			return name.substring(0, 1).toUpperCase() + name.substring(1);
		}
		// 用下划线将原始字符串分割
		String[] camels = name.split("_");
		for (String camel : camels)
		{
			// 跳过原始字符串中开头、结尾的下换线或双重下划线
			if (camel.isEmpty())
			{
				continue;
			}
			// 首字母大写
			result.append(camel.substring(0, 1).toUpperCase());
			result.append(camel.substring(1).toLowerCase());
		}
		return result.toString();
	}
	/**
	 * 首字母大写
	 *
	 * @param name
	 * @return
	 */
	public static String firstUpperCase(String name) {
		name = name.substring(0, 1).toUpperCase() + name.substring(1);
		return name;
	}
	/**
	 * 首字母小写
	 *
	 * @param name
	 * @return
	 */
	public static String firstLowerCase(String name) {
		name = name.substring(0, 1).toLowerCase() + name.substring(1);
		return name;

	}

	/**
	 * 将下划线转化为大写
	 *
	 * @param name
	 * @param firstCase 首字母是否大写 true:大写 false;小写
	 * @return
	 */
	public static String upperCase_(String name, boolean firstCase) {
		if(isEmpty(name)){
			return "";
		}
		String[] s = name.split("_");
		StringBuffer stringBuffer = new StringBuffer();
		for (String s1 : s) {
			stringBuffer.append(s1.substring(0, 1).toUpperCase() + s1.substring(1));
		}
		if(!firstCase){
			return firstLowerCase(stringBuffer.toString());
		}
		return stringBuffer.toString();
	}


	public static double round(double num, int digit) {

		return new BigDecimal(num).setScale(digit, RoundingMode.HALF_UP).doubleValue();
	}

	public static String getUUID(){
		String uuid = UUID.randomUUID().toString().trim().replaceAll("-", "");
		return uuid;
	}

	/**
	 * 是否为空串
	 *
	 * @param obj
	 * @return
	 */
	public static boolean empty(Object obj) {
		if (obj == null)
			return true;
		String str;
		if (obj instanceof String) {
			str = (String) obj;
		} else {
			str = obj.toString();
		}
		return str.length() == 0;
	}

	/**
	 * 是否不为空串
	 *
	 * @param obj
	 * @return
	 */
	public static boolean notEmp(Object obj) {
		return !empty(obj);
	}


	/**
	 * 给字符串的左补0或右补0
	 * @param str  要处理的字符串
	 * @param length 补0后字符串总长度
	 * @param type  l-左补0  r-右补0
	 * @return
	 */
	public static String addZeroForStr(String str, int length,String  type) {
		int strLen = str.length();
		if (strLen < length) {
			while (strLen < length) {
				StringBuffer sb = new StringBuffer();
				if("l".equals(type)){
					// 左补0
					sb.append("0").append(str);
				}else if("r".equals(type)){
					//右补0
					sb.append(str).append("0");
				}
				str = sb.toString();
				strLen = str.length();
			}
		}
		return str;
	}


	/**
	 * 删除开头字符串
	 * @param inStr
	 * @param prefix
	 * @return
	 */
	public static String trimstart(String inStr, String prefix) {
		if (inStr.startsWith(prefix)) {
			return (inStr.substring(prefix.length()));
		}
		return inStr;
	}

	/**
	 * 删除末尾字符串
	 * @param inStr
	 * @param suffix
	 * @return
	 */
	public static String trimend(String inStr, String suffix) {
		if (inStr.endsWith(suffix)) {
			return (inStr.substring(0,inStr.length()-suffix.length()));
		}
		return inStr;
	}


	/**
	 * 判断字符串是否为数字
	 * @param str
	 * @return
	 */
	public static boolean  isNumber(String str) {
		Pattern pattern = Pattern.compile("-?[0-9]+.?[0-9]*");
		return pattern.matcher(str).matches();
	}


//	public static void main(String[] args) {
//		String chineseCharacter = "-你好";
//
//		StringBuilder initials = new StringBuilder();
//		for (char c : chineseCharacter.toCharArray()) {
//			String[] pinyinArray = PinyinHelper.toHanyuPinyinStringArray(c);
//			if (pinyinArray != null && pinyinArray.length > 0) {
//				String pinyin = pinyinArray[0];
//				initials.append(pinyin.charAt(0));
//			} else {
//				initials.append(c);
//			}
//		}
//		System.out.println(initials.toString().toUpperCase());
//
//	}


}