package com.vci.ubcs.starter.web.util;

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

import cn.hutool.core.lang.Snowflake;
import cn.hutool.core.util.IdUtil;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.vci.ubcs.starter.exception.VciBaseException;
import com.vci.ubcs.starter.web.enumpck.BooleanEnum;
import com.vci.ubcs.starter.web.enumpck.UserSecretEnum;
import com.vci.ubcs.starter.web.pagemodel.SessionInfo;
import com.vci.ubcs.starter.web.toolmodel.DateConverter;
import com.vci.ubcs.starter.web.wrapper.VciQueryWrapperForDO;
import com.vci.ubcs.system.cache.NacosConfigCache;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springblade.core.secure.utils.AuthUtil;
import org.springblade.core.tool.utils.Func;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ResourceUtils;

import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.io.File;
import java.io.IOException;
import java.lang.Character.UnicodeBlock;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

public class VciBaseUtil {

	private static Logger log = LoggerFactory.getLogger(VciBaseUtil.class);
	public static final String NOTIN = "not in";
	private static String localIp = null;

	public VciBaseUtil() {
	}

	/**
	 * 检查是否为配置的超管租户和用户
	 * @return false不是超管，true是超管
	 */
	public static Boolean checkAdminTenant(){
		return NacosConfigCache.getAdminUserInfo().getTenantId().equals(AuthUtil.getTenantId())
			&& NacosConfigCache.getAdminUserInfo().getUserName().equals(AuthUtil.getUserName());
	}

	public static String getPk() {
		return String.valueOf(getPKLong(1,1));
	}

	public static  Long getPKLong(long workerId,long dataCenterId){
		Snowflake snowflake = IdUtil.getSnowflake(workerId,dataCenterId);
		return snowflake.nextId();
	}

	public static int getIntForBoolean(boolean b) {
		return b ? 1 : 0;
	}

	public static int getIntFromHibernateResult(Object obj) {
		if (obj == null) {
			return 0;
		} else if (obj instanceof BigDecimal) {
			return ((BigDecimal)obj).intValue();
		} else if (obj instanceof BigInteger) {
			return ((BigInteger)obj).intValue();
		} else if (obj instanceof Double) {
			return ((Double)obj).intValue();
		} else if (obj instanceof Long) {
			return ((Long)obj).intValue();
		} else if (obj instanceof Short) {
			return ((Short)obj).intValue();
		} else if (obj instanceof Float) {
			return ((Float)obj).intValue();
		} else if (obj instanceof String) {
			try {
				return Integer.valueOf(obj.toString());
			} catch (Exception var2) {
				return 0;
			}
		} else {
			return 0;
		}
	}
	public static SessionInfo getCurrentUserSessionInfo() throws VciBaseException {
		SessionInfo si = getCurrentUserSessionInfoNotException();
		if (si == null) {
			throw new VciBaseException("noLogin", new String[]{"没有当前用户信息"});
		} else {
			return si;
		}
	}
	/**
	 * 设置当前线程中的用户对象
	 * @param sessionInfo 用户对象
	 */
	public static void setCurrentUserSessionInfo(SessionInfo sessionInfo){
		WebThreadLocalUtil.getCurrentUserSessionInfoInThread().set(sessionInfo);
	}
	public static long getLong(String s) {
		long l = 0L;
		if (s == null) {
			return 0L;
		} else {
			try {
				l = Long.parseLong(s);
				return l;
			} catch (Exception var4) {
				return 0L;
			}
		}
	}

	public static Integer getCurrentUserSecret() {
		SessionInfo currentUserSession = getCurrentUserSessionInfoNotException();
		return currentUserSession != null ? getInt(currentUserSession.getUserSecret()) : UserSecretEnum.NONE.getValue();
	}

	public static float getFloat(String s) {
		float f = 0.0F;
		if (s == null) {
			return 0.0F;
		} else {
			try {
				f = Float.parseFloat(s);
				return f;
			} catch (Exception var3) {
				return 0.0F;
			}
		}
	}

	public static int getInt(String string) {
		//int i = false;
		if (string != null && !"".equals(string.trim())) {
			if (string.contains(".")) {
				string = string.substring(0, string.indexOf("."));
			}

			try {
				int i = Integer.parseInt(string);
				return i;
			} catch (Exception var3) {
				return 0;
			}
		} else {
			return 0;
		}
	}

	public static double getDouble(String s) {
		double d = 0.0D;
		if (isNull(s)) {
			return 0.0D;
		} else {
			try {
				d = Double.parseDouble(s);
				return d;
			} catch (Exception var4) {
				return 0.0D;
			}
		}
	}


	public static boolean getBoolean(String s) {
		return BooleanEnum.TRUE.getValue().equals(s);
	}

	public static String removeComma(String s) {
		if (s != null && s.trim().length() != 0) {
			if (s.startsWith(",")) {
				s = s.substring(1, s.length());
			}

			if (s.endsWith(",")) {
				s = s.substring(0, s.length() - 1);
			}

			return s;
		} else {
			return s;
		}
	}

	public static String toInSql(String s) {
		s = removeComma(s);
		if (s != null && s.trim().length() != 0) {
			String[] temp = s.split(",");
			return toInSql(temp);
		} else {
			return "";
		}
	}

	public static String toInSql(String[] s) {
		if (s != null && s.length > 0) {
			StringBuilder sb = new StringBuilder();
			if (s != null && s.length > 0) {
				for(int i = 0; i < s.length; ++i) {
					if (s[i] != null && s[i].trim().length() > 0 && !s[i].startsWith("'")) {
						sb.append("'").append(s[i]).append("',");
					}
				}
			}

			return removeComma(sb.toString());
		} else {
			return "";
		}
	}

	public static String toInSql(String field, String s) {
		return !StringUtils.isBlank(field) && !StringUtils.isBlank(s) ? toInSql(field, removeComma(s).split(","), "") : "";
	}

	public static String toInSql(String field, String[] s) {
		return toInSql(field, s, "in");
	}

	public static String toInSql(String field, String[] s, String operation) {
		if (!StringUtils.isBlank(field) && s != null && s.length != 0) {
			StringBuilder sb = new StringBuilder();
			if (s != null && s.length > 0) {
				String andOr = "or";
				if (operation.trim().toLowerCase().equals("not in")) {
					andOr = "and";
				}

				for(int i = 0; i < s.length; ++i) {
					if (s[i] != null && s[i].trim().length() > 0 && !s[i].startsWith("'")) {
						if (i == 0) {
							sb.append(field).append(" ").append(operation).append(" (");
						}

						if (i % 500 == 0 && i != 0) {
							sb.append(" ").append(andOr).append(" ").append(field).append(" ").append(operation).append(" (");
						}

						sb.append("'").append(s[i]).append("'");
						if (i % 500 != 499 && i != s.length - 1) {
							sb.append(",");
						}

						if (i % 500 == 499 || i == s.length - 1) {
							sb.append(") ");
						}
					}
				}
			}

			return sb.toString();
		} else {
			return "";
		}
	}

	/** @deprecated */
	@Deprecated
	public static String arrayToString(String[] array) {
		if (array != null && array.length > 0) {
			StringBuilder sb = new StringBuilder();

			for(int i = 0; i < array.length; ++i) {
				String record = array[i];
				if (StringUtils.isNotBlank(record)) {
					sb.append(record).append(",");
				}
			}

			return removeComma(sb.toString());
		} else {
			return "";
		}
	}

	public static String collectionToString(Collection collection) {
		if (CollectionUtils.isEmpty(collection)) {
			return "";
		} else {
			StringBuilder sb = new StringBuilder();
			Iterator it = collection.iterator();

			while(true) {
				Object record;
				do {
					do {
						if (!it.hasNext()) {
							return removeComma(sb.toString());
						}

						record = it.next();
					} while(record == null);
				} while(record instanceof String && !StringUtils.isNotBlank((String)record));

				sb.append(record.toString()).append(",");
			}
		}
	}

	public static String toUpForFirst(String s) {
		if (s != null && s.trim().length() != 0) {
			String temp = s.substring(0, 1);
			temp = temp.toUpperCase();
			return temp + s.substring(1, s.length());
		} else {
			return "";
		}
	}

	public static String toLowForFirst(String s) {
		if (s != null && s.trim().length() != 0) {
			String temp = s.substring(0, 1);
			temp = temp.toLowerCase();
			return temp + s.substring(1, s.length());
		} else {
			return "";
		}
	}

	public static int countOfString(String s, char findC) {
		Map<String, Integer> charMap = new HashMap();
		char[] cs = s.toCharArray();
		char[] var4 = cs;
		int var5 = cs.length;

		for(int var6 = 0; var6 < var5; ++var6) {
			char c = var4[var6];
			charMap.put(String.valueOf(c), !charMap.containsKey(String.valueOf(c)) ? 1 : (Integer)charMap.get(String.valueOf(c)) + 1);
		}

		return (Integer)charMap.get(String.valueOf(findC));
	}

	public static List<String> str2List(String s) {
		if (isNull(s)) {
			return null;
		} else {
			List<String> l = new ArrayList();
			Collections.addAll(l, removeComma(s).split(","));
			return l;
		}
	}

	public static String list2String(List<String> ls) {
		return ls != null && ls.size() != 0 ? (String)ls.stream().collect(Collectors.joining(",")) : "";
	}

	public static boolean isNull(String o) {
		return StringUtils.isEmpty(o);
	}

	public static boolean isNotNull(String o) {
		return !isNull(o);
	}

	public static boolean isNullOrNullString(String o) {
		return StringUtils.isBlank(o);
	}

	public static boolean inArray(String[] arr, String s) {
		if (arr != null && s != null) {
			String[] var2 = arr;
			int var3 = arr.length;

			for(int var4 = 0; var4 < var3; ++var4) {
				String a = var2[var4];
				if (s.trim().equalsIgnoreCase(a)) {
					return true;
				}
			}
		}

		return false;
	}

	public static boolean inArray(Object[] arr, Object o) {
		if (arr != null && o != null) {
			Object[] var2 = arr;
			int var3 = arr.length;

			for(int var4 = 0; var4 < var3; ++var4) {
				Object a = var2[var4];
				if (a.equals(o)) {
					return true;
				}
			}
		}

		return false;
	}

	public static double round(double value, int scale, int roundingMode) {
		BigDecimal bd = new BigDecimal(value);
		bd = bd.setScale(scale, roundingMode);
		double d = bd.doubleValue();
		bd = null;
		return d;
	}

	public static double round(double value, int scale) {
		return round(value, scale, 4);
	}

	public static boolean isEmail(String string) {
		if (StringUtils.isBlank(string)) {
			return false;
		} else {
			String regEx1 = "^([a-z0-9A-Z]+[-|\\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\.)+[a-zA-Z]{2,}$";
			Pattern p = Pattern.compile(regEx1);
			Matcher m = p.matcher(string);
			return m.matches();
		}
	}

	public static boolean isNumber(String s) {
		return StringUtils.isNotBlank(s) && s.matches("\\d+\\.?\\d*");
	}

	public static Field getFieldForObject(String fieldName, List<Field> fieldsList) {
		if (StringUtils.isBlank(fieldName)) {
			return null;
		} else {
			if (fieldsList != null && fieldsList.size() > 0) {
				Iterator var2 = fieldsList.iterator();

				while(var2.hasNext()) {
					Field field = (Field)var2.next();
					if (field.getName().toLowerCase().equals(fieldName.toLowerCase())) {
						return field;
					}
				}
			}

			return null;
		}
	}

	public static Method getSetmethod(Class c, String fieldName) {
		if (c != null && StringUtils.isNotBlank(fieldName)) {
			try {
				PropertyDescriptor pd = new PropertyDescriptor(fieldName, c);
				return pd.getWriteMethod();
			} catch (SecurityException var3) {
				if (log.isErrorEnabled()) {
					log.error("获取getter出错", var3);
				}
			} catch (IntrospectionException var4) {
				if (log.isErrorEnabled()) {
					log.error("获取getter出错", var4);
				}
			}
		}

		return null;
	}

	public static Method getGetmethod(Class c, String fieldName) {
		if (c != null && StringUtils.isNotBlank(fieldName)) {
			try {
				PropertyDescriptor pd = new PropertyDescriptor(fieldName, c);
				return pd.getReadMethod();
			} catch (SecurityException var3) {
				if (log.isErrorEnabled()) {
					log.error("获取getter出错", var3);
				}
			} catch (IntrospectionException var4) {
				if (log.isErrorEnabled()) {
					log.error("获取getter出错", var4);
				}
			}
		}

		return null;
	}

	public static String getColumnAnnotaionNameValue(Annotation[] fieldAnnotaions) {
		return getAnnotationValue("com.vci.starter.web.annotation.Column,javax.persistence.Column", "name", fieldAnnotaions);
	}

	public static String getAnnotationValue(String annotationName, String methodName, Annotation[] fieldAnnotaions) {
		String[] annotaionNameArray = annotationName.split(",");
		Annotation[] var4 = fieldAnnotaions;
		int var5 = fieldAnnotaions.length;

		for(int var6 = 0; var6 < var5; ++var6) {
			Annotation annotation = var4[var6];
			String anname = annotation.annotationType().getName();
			if (inArray(annotaionNameArray, anname)) {
				String name = null;

				try {
					name = (String)annotation.getClass().getMethod(methodName).invoke(annotation);
				} catch (IllegalAccessException var11) {
					var11.printStackTrace();
				} catch (InvocationTargetException var12) {
					var12.printStackTrace();
				} catch (NoSuchMethodException var13) {
					var13.printStackTrace();
				}

				return name;
			}
		}

		return null;
	}

	public static Object getValueFromField(String fieldName, Object sourceObject) {
		if (StringUtils.isNotBlank(fieldName)) {
			try {
				Method getMethod = getGetmethod(sourceObject.getClass(), fieldName);
				if (getMethod != null) {
					return getMethod.invoke(sourceObject);
				}

				Field field = getFieldForObject(fieldName, sourceObject);
				if (field != null) {
					field.setAccessible(true);
					return field.get(sourceObject);
				}
			} catch (SecurityException var4) {
				if (log.isErrorEnabled()) {
					log.error("从属性上获取值", var4);
				}
			} catch (IllegalAccessException var5) {
				if (log.isErrorEnabled()) {
					log.error("从属性上获取值", var5);
				}
			} catch (IllegalArgumentException var6) {
				if (log.isErrorEnabled()) {
					log.error("从属性上获取值", var6);
				}
			} catch (InvocationTargetException var7) {
				if (log.isErrorEnabled()) {
					log.error("从属性上获取值", var7);
				}
			}
		}

		return null;
	}

	public static void setValueForMethod(Field field, Object obj, Object value) {
		try {
			if (field != null) {
				field.setAccessible(true);
				Method setMethod = getSetmethod(field.getDeclaringClass(), field.getName());
				setMethod.invoke(obj, value);
			}
		} catch (Exception var4) {
			log.error("反射调用方法出现了错误,", var4);
		}

	}

	public static void alertNotNull(Object... s) throws VciBaseException {
		if (s != null && s.length > 0) {
			for(int i = 0; i < s.length; ++i) {
				Object obj = s[i];
				String param = "";

				try {
					++i;
					param = s[i].toString();
				} catch (Exception var5) {
				}

				if (obj == null) {
					throw new VciBaseException("参数[{0}]不能为空", new String[]{param});
				}

				if (obj instanceof Collection) {
					if (CollectionUtils.isEmpty((Collection)obj)) {
						throw new VciBaseException("参数[{0}]不能为空", new String[]{param});
					}
				} else if (StringUtils.isBlank(obj.toString())) {
					throw new VciBaseException("参数[{0}]不能为空", new String[]{param});
				}
			}
		}

	}

	/** @deprecated */
	@Deprecated
	public static void alertCollectionNotNull(String param, Collection collections) throws VciBaseException {
		if (CollectionUtils.isEmpty(collections)) {
			throw new VciBaseException("参数{0}不能为空", new String[]{param});
		}
	}

	public static <T> Set<Set<T>> switchSetForOracleIn(Set<T> set) {
		Set<Set<T>> listHasList = new HashSet();
		if (set == null) {
			return listHasList;
		} else {
			int muti = 1;
			if (set.size() > 500) {
				int balance = set.size() % 500;
				muti = (set.size() - balance) / 500 + (balance == 0 ? 0 : 1);
			}

			List list = new ArrayList();
			Iterator it = set.iterator();

			while(it.hasNext()) {
				list.add(it.next());
			}

			for(int i = 0; i < muti; ++i) {
				int start = i * 500;
				int end = start + 500;
				if (i == muti - 1 || end > set.size()) {
					end = set.size();
				}

				List subList = list.subList(start, end);
				Set subSet = new HashSet();
				Iterator var10 = subList.iterator();

				while(var10.hasNext()) {
					Object obj = var10.next();
					subSet.add(obj);
				}

				listHasList.add(subSet);
			}

			return listHasList;
		}
	}

	public static <T> Vector<Vector<T>> switchVectorForOracleIn(Vector<T> vector) {
		Vector<Vector<T>> listHasList = new Vector();
		if (vector == null) {
			return listHasList;
		} else {
			int muti = 1;
			if (vector.size() > 500) {
				int balance = vector.size() % 500;
				muti = (vector.size() - balance) / 500 + (balance == 0 ? 0 : 1);
			}

			List list = new ArrayList();
			Iterator it = vector.iterator();

			while(it.hasNext()) {
				list.add(it.next());
			}

			for(int i = 0; i < muti; ++i) {
				int start = i * 500;
				int end = start + 500;
				if (i == muti - 1 || end > vector.size()) {
					end = vector.size();
				}

				List subList = list.subList(start, end);
				Vector subSet = new Vector();
				Iterator var10 = subList.iterator();

				while(var10.hasNext()) {
					Object obj = var10.next();
					subSet.add(obj);
				}

				listHasList.add(subSet);
			}

			return listHasList;
		}
	}

	public static <T> T jsonString2JavaBean(String jsonString, Class<T> beanClass) {
		return JSONObject.parseObject(jsonString, beanClass);
	}

	public static void ifNullSetDefautl(String str, String defaultValue) {
		if (isNull(str)) {
			;
		}

	}

	public static <T> T getFristObjectFromJson(String jsonString, Class<T> beanClass) {
		return !isNull(jsonString) ? JSONObject.parseArray(jsonString, beanClass).get(0) : null;
	}

	public static String getJSONStringWithDateFormat(Object obj) {
		return JSONObject.toJSONStringWithDateFormat(obj, "yyyy-MM-dd HH:mm:ss.SSS", new SerializerFeature[]{SerializerFeature.WriteDateUseDateFormat});
	}

	public static Map<String, Object> objectToMap(Object o) {
		Map<String, Object> map = new HashMap();
		if (o != null) {
			String jsonString = JSONObject.toJSONStringWithDateFormat(o, "yyyy-MM-dd HH:mm:ss.SSS", new SerializerFeature[]{SerializerFeature.WriteDateUseDateFormat});
			if (StringUtils.isNotBlank(jsonString)) {
				JSONObject jsonObject = JSONObject.parseObject(jsonString);
				if (jsonObject != null) {
					Iterator var4 = jsonObject.keySet().iterator();

					while(var4.hasNext()) {
						String key = (String)var4.next();
						map.put(key, jsonObject.get(key));
					}
				}
			}
		}

		return map;
	}

	public static Map<String, String> objectToMapString(Object o) {
		Map<String, String> map = new HashMap();
		if (o != null) {
			String jsonString = JSONObject.toJSONStringWithDateFormat(o, "yyyy-MM-dd HH:mm:ss.SSS", new SerializerFeature[]{SerializerFeature.WriteDateUseDateFormat});
			if (StringUtils.isNotBlank(jsonString)) {
				JSONObject jsonObject = JSONObject.parseObject(jsonString);
				if (jsonObject != null) {
					Iterator var4 = jsonObject.keySet().iterator();

					while(var4.hasNext()) {
						String key = (String)var4.next();
						map.put(key, jsonObject.getString(key));
					}
				}
			}
		}

		return map;
	}

	public static boolean isNotNullForField(Object obj, Field f) {
		return !"serialVersionUID".equalsIgnoreCase(f.getName()) && !"DEFAULT_INITIAL_CAPACITY".equalsIgnoreCase(f.getName()) && null != obj && !isNullOrNullString(obj.toString());
	}

	public static String array2String(String[] array) {
		if (null != array && array.length != 0) {
			String ss = "";
			String[] var2 = array;
			int var3 = array.length;

			for(int var4 = 0; var4 < var3; ++var4) {
				String s = var2[var4];
				ss = ss + s + ",";
			}

			return removeComma(ss);
		} else {
			return "";
		}
	}

	public static void copyValueForMap(Map source, Map target, String[] copyField) {
		Map<String, String> copyFieldMap = new HashMap();
		String[] var4 = copyField;
		int var5 = copyField.length;

		for(int var6 = 0; var6 < var5; ++var6) {
			String field = var4[var6];
			copyFieldMap.put(field, field);
		}

		copyValueForMap(source, target, (Map)copyFieldMap);
	}

	public static void copyValueForMap(Map source, Map target, Map<String, String> copyField) {
		try {
			Iterator it = copyField.keySet().iterator();

			while(it.hasNext()) {
				String field = (String)it.next();
				target.put(field, source.get(copyField.get(field)));
			}
		} catch (Exception var5) {
		}

	}

	public static Double getDoubleFromMap(String field, Map<String, Object> record) {
		if (!isNullOrNullString(field) && record != null && record.containsKey(field)) {
			Object v = record.get(field);
			if (v instanceof BigDecimal) {
				return ((BigDecimal)v).doubleValue();
			} else {
				return v instanceof Double ? (Double)v : getDouble((String)v);
			}
		} else {
			return null;
		}
	}

	public static String getDataByKey(String key, Map<String, Object> data) {
		String value = "";
		if (data.containsKey(key)) {
			value = (String)data.get(key);
		}

		if (value == null) {
			value = "";
		}

		return value;
	}

	public static Map getNotNullMap(Map map) {
		if (map == null) {
			return new HashMap();
		} else {
			Iterator it = map.keySet().iterator();
			HashMap unNullMap = new HashMap();

			while(true) {
				while(true) {
					String newKey;
					Object value;
					do {
						if (!it.hasNext()) {
							return unNullMap;
						}

						Object key = it.next();
						newKey = key.toString().toLowerCase();
						value = map.get(key);
					} while(value == null);

					if (value instanceof String && isNotNull(value.toString())) {
						unNullMap.put(newKey, value);
					} else if (!(value instanceof String)) {
						unNullMap.put(newKey, value);
					}
				}
			}
		}
	}

	public static List<Field> getAllFieldForObj(Class c) {
		List<Field> allField = new ArrayList();
		Set<String> fieldNameSet = new HashSet();

		for(Class classz = c; classz != Object.class; classz = classz.getSuperclass()) {
			Field[] thisClassField = classz.getDeclaredFields();
			Field[] var5 = thisClassField;
			int var6 = thisClassField.length;

			for(int var7 = 0; var7 < var6; ++var7) {
				Field field = var5[var7];
				if (!field.getName().equals("serialVersionUID")) {
					String fieldLowerName = field.getName().toLowerCase();
					if (!fieldNameSet.contains(fieldLowerName)) {
						fieldNameSet.add(fieldLowerName);
						allField.add(field);
					}
				}
			}
		}

		return allField;
	}

	public static String getTableName(String btmname) {
		return (VciQueryWrapperForDO.USER_TABLE_COMPATIBILITY ? "PLBT_CODE" : "PL_CODE_") + btmname.trim().toLowerCase();
	}

	public static String getTableName(String btmname,Boolean isMdmTable) {
		return (isMdmTable ? "PLBT_CODE_" : "PL_CODE_") + btmname.trim().toUpperCase(Locale.ROOT);
	}

	public static Field getTsField(Class c) {
		List<Field> allField = getAllFieldForObj(c);
		if (allField != null && allField.size() > 0) {
			Iterator var2 = allField.iterator();

			while(var2.hasNext()) {
				Field field = (Field)var2.next();
				if (field.getName().equals("ts")) {
					return field;
				}
			}
		}

		return null;
	}

	public static Field getFieldForObject(String fieldName, Object obj) {
		return obj == null ? null : getFieldForObject(fieldName, obj.getClass());
	}

	public static Field getFieldForObject(String fieldName, Class c) {
		List<Field> allField = getAllFieldForObj(c);
		if (allField != null && allField.size() > 0) {
			Iterator var3 = allField.iterator();

			while(var3.hasNext()) {
				Field field = (Field)var3.next();
				if (field.getName().toLowerCase().equalsIgnoreCase(fieldName.toLowerCase())) {
					return field;
				}
			}
		}

		return null;
	}

	public static Method getSetmethod(Class c, Field field) {
		return getSetmethod(c, field.getName());
	}

	public static Method getGetmethod(Class c, Field field) {
		return getGetmethod(c, field.getName());
	}

	public static Method getMethodByName(Class<?> classObj, String methodName) {
		alertNotNull(classObj, "获取方法的对象所属的类", methodName, "方法的名字");
		Method[] methods = classObj.getMethods();
		List<Method> sameMethods = (List)Arrays.stream(methods).filter((method) -> {
			return method.getName().equalsIgnoreCase(methodName);
		}).collect(Collectors.toList());
		return !CollectionUtils.isEmpty(sameMethods) ? (Method)sameMethods.get(0) : null;
	}

	public static Map<String, String> whereSql2Map(String whereSql) {
		Map<String, String> map = new HashMap();
		if (isNotNull(whereSql)) {
			String[] selects = whereSql.split("and");
			if (selects != null && selects.length > 0) {
				String[] var3 = selects;
				int var4 = selects.length;

				for(int var5 = 0; var5 < var4; ++var5) {
					String s = var3[var5];
					s = s.trim();
					map.put(s.substring(0, s.indexOf(" ")).trim(), s.substring(s.indexOf(" ") + 1).trim());
				}
			}
		}

		return map;
	}

	public static synchronized String getRoundFilename(String prefix) {
		if (prefix == null) {
			prefix = "";
		}

		return prefix + System.currentTimeMillis();
	}

	public static String getLocalIp() {
		if (localIp == null) {
			try {
				InetAddress inetAddress = getLocalHostLANAddress();
				if (inetAddress == null) {
					localIp = "127.0.0.1";
				} else {
					localIp = inetAddress.getHostAddress();
				}
			} catch (Exception var1) {
				localIp = "127.0.0.1";
			}
		}

		return localIp;
	}

	private static InetAddress getLocalHostLANAddress() throws Exception {
		try {
			InetAddress candidateAddress = null;
			Enumeration ifaces = NetworkInterface.getNetworkInterfaces();

			while(ifaces.hasMoreElements()) {
				NetworkInterface iface = (NetworkInterface)ifaces.nextElement();
				Enumeration inetAddrs = iface.getInetAddresses();

				while(inetAddrs.hasMoreElements()) {
					InetAddress inetAddr = (InetAddress)inetAddrs.nextElement();
					if (!inetAddr.isLoopbackAddress()) {
						if (inetAddr.isSiteLocalAddress()) {
							return inetAddr;
						}

						if (candidateAddress == null) {
							candidateAddress = inetAddr;
						}
					}
				}
			}

			if (candidateAddress != null) {
				return candidateAddress;
			} else {
				InetAddress jdkSuppliedAddress = InetAddress.getLocalHost();
				return jdkSuppliedAddress;
			}
		} catch (Exception var5) {
			var5.printStackTrace();
			return null;
		}
	}

	public static String getProjectPath() {
		String path = "";

		try {
			String jarFilePath = ResourceUtils.getURL("classpath:").getPath();
			if (jarFilePath.contains("!")) {
				path = (new File(jarFilePath)).getParentFile().getParentFile().getParent();
			} else {
				path = (new File(jarFilePath)).getParent();
			}
		} catch (IOException var2) {
			throw new VciBaseException("获取当前服务所在的文件夹出现了错误");
		}

		if (path.startsWith("file:\\")) {
			path = path.substring(6);
		}

		return path;
	}

	public static Map<String, String> getParamsByUrl(String url) {
		if (StringUtils.isBlank(url)) {
			return new HashMap();
		} else {
			String[] array = url.split("&");
			Map<String, String> params = new HashMap();
			String[] var3 = array;
			int var4 = array.length;

			for(int var5 = 0; var5 < var4; ++var5) {
				String temp = var3[var5];
				if (temp.contains("=")) {
					String[] keyValues = temp.split("=");
					params.put(keyValues[0], keyValues[1]);
				} else {
					params.put(temp, "");
				}
			}

			return params;
		}
	}

	public static boolean isChinese(char c) {
		UnicodeBlock ub = UnicodeBlock.of(c);
		return ub == UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS || ub == UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS || ub == UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A || ub == UnicodeBlock.GENERAL_PUNCTUATION || ub == UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION || ub == UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS;
	}

	public static boolean containsKeyUnCaseForMap(Map map, String key) {
		if (!CollectionUtils.isEmpty(map)) {
			boolean[] finded = new boolean[]{false};
			map.forEach((k, value) -> {
				if (k instanceof String && k.toString().toLowerCase(Locale.ROOT).equalsIgnoreCase(key)) {
					finded[0] = true;
				}
			});
			return finded[0];
		} else {
			return false;
		}
	}

	public static boolean isChinese(String str) {
		char[] ch = str.toCharArray();
		char[] var2 = ch;
		int var3 = ch.length;

		for(int var4 = 0; var4 < var3; ++var4) {
			char c = var2[var4];
			if (isChinese(c)) {
				return true;
			}
		}

		return false;
	}

	public static String toDBC(String input) {
		if (StringUtils.isBlank(input)) {
			return input;
		} else {
			char[] c = input.toCharArray();

			for(int i = 0; i < c.length; ++i) {
				if (c[i] == 12288) {
					c[i] = ' ';
				} else if (c[i] > '\uff00' && c[i] < '｟') {
					c[i] -= 'ﻠ';
				}
			}

			return new String(c);
		}
	}

	public static String toSBC(String input) {
		if (StringUtils.isBlank(input)) {
			return input;
		} else {
			char[] c = input.toCharArray();

			for(int i = 0; i < c.length; ++i) {
				if (c[i] == 12288) {
					c[i] = ' ';
				} else if (c[i] > '\uff00' && c[i] < '｟') {
					c[i] += 'ﻠ';
				}
			}

			return new String(c);
		}
	}

	public static String getStringValueFromObject(Object obj) {
		if (obj == null) {
			return "";
		} else if (!(obj instanceof Integer) && !(obj instanceof Float) && !(obj instanceof Long) && !(obj instanceof Double)) {
			return obj instanceof Date ? VciDateUtil.date2Str((Date)obj, "yyyy-MM-dd HH:mm:ss.SSS") : obj.toString();
		} else {
			if (obj instanceof Double) {
				Double aDouble = (Double)obj;
				if (aDouble != null && aDouble % 1.0D == 0.0D) {
					return String.valueOf(aDouble.intValue());
				}
			}

			return String.valueOf(obj);
		}
	}

	public static SessionInfo getCurrentUserSessionInfoNotException() {
		return (SessionInfo) WebThreadLocalUtil.getCurrentUserSessionInfoInThread().get();
	}


	public static <T> Collection<Collection<T>> switchCollectionForOracleIn(Collection<T> list) {
		return switchCollectionForOracleIn(list, 500);
	}
	/**
	 * oracle in 查询不能超过1000，转换一下集合
	 * 由于SQL语句1000个可能很长，超过oracle10g，所以牺牲性能分配为500个数组
	 * @param list 需要转换的列表内容
	 * @return 分组后的list
	 */
	public static <T> List<List<T>> switchListForOracleIn(List<T> list) {
		List<List<T>> listHasList = new ArrayList<List<T>>();
		if(list == null){
			return listHasList;
		}
		List<T> newList = new ArrayList<T>();
		for(Object obj : list){
			//为了让list还可以添加内容，因为使用sublist后，list不能再Add了
			newList.add((T)obj);
		}
		int muti = 1;
		if(newList.size() >500){
			int balance = newList.size()%500;
			muti = (newList.size() - balance)/500 + (balance == 0?0:1);
		}
		for(int i = 0 ; i < muti; i ++){
			int start = i*500;
			int end = start + 500;
			if(i == muti-1 || end >newList.size() ){
				end = newList.size();
			}
			List subList = newList.subList(start,end);
			listHasList.add(subList);
		}
		return listHasList;
	}
	public static <T> Collection<Collection<T>> switchCollectionForOracleIn(Collection<T> collection, int preSize) {
		Collection<Collection<T>> listHasList = new ArrayList();
		if (collection == null) {
			return listHasList;
		} else {
			List<T> newList = new ArrayList();
			Iterator var4 = collection.iterator();

			while(var4.hasNext()) {
				Object obj = var4.next();
				newList.add((T) obj);
			}

			int muti = 1;
			int i;
			if (newList.size() > preSize) {
				i = newList.size() % preSize;
				muti = (newList.size() - i) / preSize + (i == 0 ? 0 : 1);
			}

			for(i = 0; i < muti; ++i) {
				int start = i * preSize;
				int end = start + preSize;
				if (i == muti - 1 || end > newList.size()) {
					end = newList.size();
				}

				List subList = newList.subList(start, end);
				listHasList.add(subList);
			}

			return listHasList;
		}
	}
	public static short getShort(String s) {
//		short i = false;
		if (s == null) {
			return 0;
		} else {
			try {
				short i = Short.parseShort(s);
				return i;
			} catch (Exception var3) {
				return 0;
			}
		}
	}

	public static void setValueForField(Field field, Object obj, String value) {
		try {
			if (field != null && StringUtils.isNotBlank(value)) {
				field.setAccessible(true);
				Method setMethod = getSetmethod(field.getDeclaringClass(), field.getName());
				Class type = field.getType();
				Object valueObj = null;
				if (!type.equals(Integer.TYPE) && !type.equals(Integer.class)) {
					if (!type.equals(Float.TYPE) && !type.equals(Float.class)) {
						if (!type.equals(Long.TYPE) && !type.equals(Long.class)) {
							if (!type.equals(Double.class) && !type.equals(Double.TYPE)) {
								if (type.equals(Date.class)) {
									DateConverter dateConverter = new DateConverter();
									dateConverter.setAsText(value);
									valueObj = dateConverter.getValue();
								} else if (type.equals(String.class)) {
									valueObj = value;
								} else {
									valueObj = value;
									if (log.isErrorEnabled()) {
										log.error("不支持的类型" + type.toString());
									}
								}
							} else {
								valueObj = getDouble(value);
							}
						} else {
							valueObj = getLong(value);
						}
					} else {
						valueObj = getFloat(value);
					}
				} else {
					valueObj = getInt(value);
				}

				if (setMethod != null) {
					setMethod.invoke(obj, valueObj);
				} else {
					field.set(obj, valueObj);
				}
			}
		} catch (Throwable var7) {
			if (log.isErrorEnabled()) {
				log.error("设置属性的值出错了错误", var7);
			}
		}

	}

	public static void setValueForField(String fieldName, Object obj, String value) {
		try {
			Field field = getFieldForObject(fieldName, obj);
			if (field != null) {
				setValueForField(field, obj, value);
			}
		} catch (Exception var4) {
			if (log.isErrorEnabled()) {
				log.error("设置属性的值出错了错误", var4);
			}
		}

	}

	/**
	 * 将 JavaBean对象转化为 Map
	 * @author wyply115
	 * @param bean 要转化的类型
	 * @return Map对象
	 * @version 2016年3月20日 11:03:01
	 */
	public static Map convertBean2Map(Object bean,Set<String> existFild) throws Exception {
		Class type = bean.getClass();
		Map returnMap = new HashMap();
		BeanInfo beanInfo = Introspector.getBeanInfo(type);
		PropertyDescriptor[] propertyDescriptors = beanInfo
			.getPropertyDescriptors();
		Field[] declaredFields = type.getDeclaredFields();
		Map<String, String> fieldMap = new HashMap();
		String existField = "";
		if(existFild == null){
			existFild = new HashSet<>();
		}
		for (Field declaredField : declaredFields) {
			declaredField.setAccessible(true);
			// 获取字段的值
			boolean isTableField = declaredField.isAnnotationPresent(TableField.class);
			if (isTableField) {
				TableField tableField = declaredField.getAnnotation(TableField.class);
				Boolean fieldValue = tableField.exist();
				if(fieldValue == false){
					existField += declaredField.getName().toLowerCase()+",";
				}
				String value = tableField.value();
				if(net.logstash.logback.encoder.org.apache.commons.lang3.StringUtils.isNotBlank(value)){
					fieldMap.put(declaredField.getName(), value);
				}
			}
		}
		Map mapData = new HashMap<>();
		for (int i = 0, n = propertyDescriptors.length; i <n ; i++) {
			PropertyDescriptor descriptor = propertyDescriptors[i];
			String propertyName = descriptor.getName();

			if (!propertyName.equals("class") &&
				((!"".equals(existField) && !existField.contains(propertyName.toLowerCase()+","))||"data".equals(propertyName))) {
				Method readMethod = descriptor.getReadMethod();
				Object result = readMethod.invoke(bean, new Object[0]);

				if (result != null) {
					if ("data".equals(propertyName)){
						mapData = (Map) result;
					}else if(existFild.contains((fieldMap.containsKey(propertyName)?fieldMap.get(propertyName):propertyName).toLowerCase())){
						returnMap.put(fieldMap.containsKey(propertyName)?fieldMap.get(propertyName).toLowerCase():propertyName.toLowerCase(), result);
					}
				} else if(existFild.contains((fieldMap.containsKey(propertyName)?fieldMap.get(propertyName):propertyName).toLowerCase())){
					returnMap.put(fieldMap.containsKey(propertyName)?fieldMap.get(propertyName).toLowerCase():propertyName.toLowerCase(), "");
				}
			}
		}
		//作用主要用于已MAP中的数据为准，bean里面遇到字段相同且map里面数据为空，则使用bean里面的值,
//		Map resulMapChild = (Map) mapData;
		for (Object o : mapData.keySet()) {
			if(existFild == null || existFild.contains(String.valueOf(o).toLowerCase())){
				if((Func.isNotBlank(String.valueOf(returnMap.get(String.valueOf(o).toLowerCase())))
					&& returnMap.get(String.valueOf(o).toLowerCase()) !=null)
					&& Func.isBlank(String.valueOf(mapData.get(o)))){
					continue;
				}
				returnMap.put(String.valueOf(o).toLowerCase(),mapData.get(o));
			}
		}
		return returnMap;
	}

	public static <T> List<T> mapToBean(List<Map> maps, Class<T> tClass) {
		List<T> beanList = new ArrayList<>();
		try {
			for (Map map : maps) {
					T t = tClass.newInstance();
					BeanInfo beanInfo = Introspector.getBeanInfo(tClass);
					PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();

					for (PropertyDescriptor property : propertyDescriptors) {

						String key = property.getName();
						if ("class".equals(key)) {
							continue;
						}

//						String sqlField = camelToUnderscore(key);


						if (map.containsKey(key.toUpperCase(Locale.ROOT))||map.containsKey(key.toLowerCase(Locale.ROOT))) {
							try {
								Object value="";
								if (map.containsKey(key.toUpperCase(Locale.ROOT))) {
									value = map.get(key.toUpperCase());
								}else if(map.containsKey(key.toLowerCase(Locale.ROOT))){
									value = map.get(key.toLowerCase());
								}
								// 得到property对应的setter方法
								Method setter = property.getWriteMethod();
								Class<?> type = property.getPropertyType();
								// 强转为字段的类型，不需要时可以去除，依赖commons-beanutilss-beanutils
								//Object convert = ConvertUtils.convert(String.valueOf(value), type);
								//setter.invoke(t, convert);
								setter.invoke(t, value);
							} catch (Exception e) {
								throw new RuntimeException("【赋值异常】", e);
							}
						}

					}
					beanList.add(t);
			}
		} catch (Exception e) {
			throw new RuntimeException("【Map转换实体异常】", e);
		}
		return beanList;
}


	public static String camelToUnderscore(String name) {
		if (name == null && name.length() <= 0) {
			return name;
		}
		StringBuilder sb = new StringBuilder();
		String lowerName = name.toLowerCase();
		for (int i = 0; i < lowerName.length(); i++) {
			String nameChar = name.substring(i, i + 1);
			String lowerChar = lowerName.substring(i, i + 1);
			if (!nameChar.equals(lowerChar)) {
				sb.append("_").append(lowerChar);
			} else {
				sb.append(nameChar);
			}
		}

		return sb.toString();
	}
	public static String convertArabicToRoman(int num) {
		int[] values={1000,900,500,400,100,90,50,40,10,9,5,4,1};
		String[] romans={"M","CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"};
		StringBuilder sb=new StringBuilder();
		for(int i=0;i<values.length;i++){
			while(num>=values[i]){
				num=num-values[i];
				sb.append(romans[i]);
			}
		}
		return sb.toString();
	}
	/**
	 * 把罗马数字转换为阿拉伯数字
	 * @param m
	 * @return
	 */
	public static int convertRomanToArabic(String m) {
		int graph[] = new int[400];
		graph['I'] = 1;
		graph['V'] = 5;
		graph['X'] = 10;
		graph['L'] = 50;
		graph['C'] = 100;
		graph['D'] = 500;
		graph['M'] = 1000;
		char[] num = m.toCharArray();
		int sum = graph[num[0]];
		for (int i = 0; i < num.length - 1; i++) {
			if (graph[num[i]] >= graph[num[i + 1]]) {
				sum += graph[num[i + 1]];
			} else {
				sum = sum + graph[num[i + 1]] - 2 * graph[num[i]];
			}
		}
		return sum;
	}
	/***
	 * 校验是否是罗马数字
	 * @param s
	 * @return
	 */
	public static boolean isRoman(String s) {
		// 检查输入的字符串是否为空
		if (s == null || s.length() == 0) {
			return false;
		}
		// 将输入的字符串转换为大写字母
		s = s.toUpperCase();
		// 返回结果
		Pattern pattern = Pattern.compile("^M{0,3}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$");
		return pattern.matcher(s ).matches();
	}

	public static String intToRomanTwo(int num) {
		String M[] = {"", "M", "MM", "MMM"};
		String C[] = {"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"};
		String X[] = {"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"};
		String I[] = {"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};
		return M[num/1000]+C[(num%1000)/100]+X[(num%100)/10]+I[num%10];
	}
}