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

//package com.vci.web.util;

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.vci.ubcs.starter.exception.VciBaseException;
import com.vci.ubcs.starter.web.pagemodel.SessionInfo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.lang.reflect.*;
import java.math.BigDecimal;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 通用工具类
 * @author weidy
 * @date 2021-2-13
 */
@Component
public  class WebUtil extends VciBaseUtil {

	/**
	 * 全部标记，常用语树形展示时
	 */
	public static final String ALL = "${all}";

	/**
	 * 是否持久化
	 */
	private static ThreadLocal<String> needPersistenceInThread = new ThreadLocal<>();
	/**
	 * 日志对象
	 */
	private static Logger logger = LoggerFactory.getLogger(WebUtil.class);

	/**
	 * json字符串转为对象
	 * @param jsonString json的字符串
	 * @param beanClass bean的类
	 * @return bean
	 */
	public static <T> T jsonString2JavaBean(String jsonString,Class<T> beanClass){
		return (T)JSONObject.parseObject(jsonString,  beanClass);
	}

	/**
	 * 从json字符串中获取第一个对象
	 * @param jsonString json的字符串
	 * @param beanClass Bean的类
	 * @return 从列表里获取第一个对象
	 */
	public static <T> T getFirstObjectFromJson(String jsonString,Class<T> beanClass){
		if(!isNull(jsonString)) {
			return JSONObject.parseArray(jsonString, beanClass).get(0);
		} else {
			return null;
		}
	}

	/**
	 * 获取sessionInfo对象
	 * @return 获取当前用户的信息
	 */
	public static SessionInfo getSessionInfo(){
		try{
			return getCurrentUserSessionInfoNotException();
		}catch(Exception e){
			return null;
		}
	}

	/**
	 * 获取当前线程中的用户对象
	 * @return 当前用户信息
	 * @throws VciBaseException 没有登录会抛出异常
	 */
	public static SessionInfo getCurrentUserSessionInfo() throws VciBaseException {
		SessionInfo si= getCurrentUserSessionInfoNotException();
		if(si==null){
			throw new VciBaseException("noLogin",new String[]{"没有当前用户信息"});
		}
		return si;
	}

	/**
	 * 获取当前线程中的用户对象
	 * @return 用户对象，但是不抛出异常
	 */
	public static SessionInfo getCurrentUserSessionInfoNotException() {
		return WebThreadLocalUtil.getCurrentUserSessionInfoInThread().get();
	}

	/**
	 * 设置用户的会话信息对象
	 * @param sessionInfo 会话信息
	 */
	public static synchronized void setSessionInfo(SessionInfo sessionInfo){
		WebThreadLocalUtil.getCurrentUserSessionInfoInThread().set(sessionInfo);
	}

	/**
	 * 是否设置了corba需要使用的上下文信息，只针对webService的
	 */
	private static volatile boolean isSetContext = false;

	/**
	 * 获取IP地址，通过request
	 * @param request 请求的对象
	 * @return ip地址
	 */
	public static String getClientInfo(HttpServletRequest request){
		String ip = request.getHeader("X-Forwarded-For");
		if (StringUtils.isBlank(ip) || "unknown".equalsIgnoreCase(ip)) {
			ip = request.getHeader("Proxy-Client-IP");
		}
		if (StringUtils.isBlank(ip) || "unknown".equalsIgnoreCase(ip)) {
			ip = request.getHeader("WL-Proxy-Client-IP");
		}
		if (StringUtils.isBlank(ip) || "unknown".equalsIgnoreCase(ip)) {
			ip = request.getHeader("HTTP_CLIENT_IP");
		}
		if (StringUtils.isBlank(ip) || "unknown".equalsIgnoreCase(ip)) {
			ip = request.getHeader("HTTP_X_FORWARDED_FOR");
		}
		if (StringUtils.isBlank(ip) || "unknown".equalsIgnoreCase(ip)) {
			ip = request.getRemoteAddr();
		}
		if (StringUtils.isBlank(ip) || ip.indexOf("0:0:0:0:0:0:0:1") >-1) {//0:0:0:0:0:0:0:1是本机在访问
			ip = "127.0.0.1";
		}
		return ip;
	}

	/**
	 * 设置是否持久化
	 * @param isPersistence 是否持久化
	 */
	public static void setPersistence(boolean isPersistence){
		if(!isPersistence){
			needPersistenceInThread.set("false");
		}else{
			needPersistenceInThread.set("");
		}
	}


	/**
	 * 将对象转换为字符串出来
	 * @return json字符串
	 */
	public static String getJSONStringWithDateFormat(Object obj){
		return JSONObject.toJSONStringWithDateFormat(obj, VciDateUtil.DateTimeMillFormat, SerializerFeature.WriteDateUseDateFormat);
	}

	/**
	 * 最新转换为map
	 * @param o 对象
	 * @return map
	 */
	public static Map<String,Object> objectToMap(Object o){
		Map<String,Object> map = new HashMap<String,Object>();
		if(o!=null) {
			String jsonString = JSONObject.toJSONStringWithDateFormat(o, VciDateUtil.DateTimeMillFormat, SerializerFeature.WriteDateUseDateFormat);
			if(StringUtils.isNotBlank(jsonString)) {
				JSONObject jsonObject = JSONObject.parseObject(jsonString);
				if(jsonObject!=null){
					for(String key : jsonObject.keySet()){
						map.put(key,jsonObject.get(key));
					}
				}
			}
		}
		return map;
	}

	/**
	 * 对象转换为map
	 * @param o 对象
	 * @return map
	 */
	public static Map<String,String> objectToMapString(Object o){
		Map<String,String> map = new HashMap<String,String>();
		if(o!=null) {
			String jsonString = JSONObject.toJSONStringWithDateFormat(o, VciDateUtil.DateTimeMillFormat, SerializerFeature.WriteDateUseDateFormat);
			if(StringUtils.isNotBlank(jsonString)) {
				JSONObject jsonObject = JSONObject.parseObject(jsonString);
				if(jsonObject!=null){
					for(String key : jsonObject.keySet()){
						map.put(key,jsonObject.getString(key));
					}
				}
			}
		}
		return map;
	}

	/**
	 * 判断某个属性是否为空
	 * @param obj 对象
	 * @param f 字段
	 * @return true是不空
	 */
	public static boolean isNotNullForField(Object obj,Field f){
		if(!"serialVersionUID".equalsIgnoreCase(f.getName()) &&!"DEFAULT_INITIAL_CAPACITY".equalsIgnoreCase(f.getName())&&null!=obj && !WebUtil.isNullOrNullString(obj.toString())) {
			return true;
		} else {
			return false;
		}
	}

	/**
	 * 数组转换为字符串
	 * @param array 数组
	 * @return 字符串
	 */
	public static String array2String(String[] array) {
		if(null == array || array.length == 0) {
			return "";
		}else{
			return Arrays.stream(array).collect(Collectors.joining(","));
		}
	}

	/**
	 * 对象转换为字符串
	 * @param obj 对象
	 * @return 字符串
	 */
	public static String getString(Object obj){
		if(obj == null) {
			return "";
		}
		if(obj instanceof Date) {
			return VciDateUtil.date2Str((Date) obj, VciDateUtil.DateTimeFormat);
		}
		return String.valueOf(obj);
	}

	/**
	 * 拷贝map里的值
	 * @param source 源
	 * @param target 目标
	 * @param copyField 拷贝的属性
	 */
	public static void copyValueForMap(Map source,Map target,String[] copyField){
		Map<String,String> copyFieldMap = new HashMap<String,String>();
		for(String field : copyField) {
			copyFieldMap.put(field, field);
		}
		copyValueForMap(source,target,copyFieldMap);
	}
	/**
	 * 为map拷贝值
	 * @param source 源
	 * @param target 目标
	 * @param copyField key为目标对象里的字段，
	 */
	public static void copyValueForMap(Map source,Map target,Map<String,String> copyField){
		try{
			Iterator<String> it = copyField.keySet().iterator();
			while(it.hasNext()){
				String field = it.next();
				target.put(field, source.get(copyField.get(field)));
			}
		}catch(Exception e){
			if(logger.isErrorEnabled()){
				logger.error("拷贝值到map",e);
			}
		}
	}

	/**
	 * 从Map里获取double类型
	 * @param field 字段名称
	 * @param record map
	 * @return 属性
	 */
	public static Double getDoubleFromMap(String field,
										  Map<String, Object> record) {
		if(WebUtil.isNullOrNullString(field) || record == null || !record.containsKey(field)) {
			return null;
		}else{
			Object v = record.get(field);
			if(v instanceof BigDecimal){
				return ((BigDecimal)v).doubleValue();
			}else if(v instanceof Double){
				return ((Double)v).doubleValue();
			}else{
				return WebUtil.getDouble((String)v);
			}
		}
	}

	/**
	 * 获取不是空值的映射，且key是小写
	 * @param map 映射
	 * @return 去除空值的
	 */
	public static Map getNotNullMap(Map map){
		if(map == null){
			return new HashMap();
		}
		Iterator it = map.keySet().iterator();
		Map unNullMap = new HashMap();
		while(it.hasNext()){
			Object key = it.next();
			String newKey = key.toString().toLowerCase();
			Object value = map.get(key);
			if(value !=null){
				if(value instanceof String && WebUtil.isNotNull(value.toString())){
					unNullMap.put(newKey, value);
				}else if(!(value instanceof String)){
					unNullMap.put(newKey, value);
				}
			}
		}
		return unNullMap;
	}

	/**
	 * 获取集合的元素类型
	 * @param field 属性
	 * @return 元素类型, 不是集合的时候返回Null
	 */
	public static Class getCollectionElementClass(Field field) throws VciBaseException{
		Class fieldClass = null;
		if(field == null){
			return null;
		}
		if(field.getType().isAssignableFrom(List.class) ||
			field.getType().isAssignableFrom(Set.class) ||
			field.getType().isAssignableFrom(Vector.class)){
			Type fc = field.getGenericType();
			if(fc instanceof ParameterizedType){
				ParameterizedType pt = (ParameterizedType)fc;
				fieldClass= (Class)pt.getActualTypeArguments()[0];
			}
		}
		return fieldClass;
	}

	/**
	 * 获取对象中的所有属性，包括其继承的属性
	 * @param c 对象
	 * @return 所有的属性
	 */
	public static List<Field> getAllFieldForObj(Class c){
		List<Field> allField = new ArrayList<Field>();
		for(Class<?> classz = c ; classz != Object.class ; classz = classz.getSuperclass() ){
			Field[] thisClassField = classz.getDeclaredFields();
			for(Field field : thisClassField){
				if(!field.getName().equals("serialVersionUID")){
					if(!allField.contains(field)){
						allField.add(field);
					}
				}
			}
		}
		return allField;
	}

	/**
	 * 获取ts的字段
	 * @param c 对象所属的类
	 * @return 时间戳的对象
	 */
	public static Field getTsField(Class c){
		List<Field> allField = getAllFieldForObj(c);
		if(allField!=null&&allField.size()>0){
			for(Field field : allField){
				if(field.getName().equals("ts")){
					return  field;
				}
			}
		}
		return null;
	}

	/**
	 * 根据名称获取字段
	 * @param field 字段的名称
	 * @param obj 对象
	 * @return 字段对象
	 */
	public static Field getFieldForObject(String field,Object obj){
		if(obj == null){
			return null;
		}
		return getFieldForObject(field,obj.getClass());
	}

	/**
	 * 根据名称获取字段
	 * @param fieldName 字段的名称
	 * @param c 对象类型
	 * @return 字段对象
	 */
	public static Field getFieldForObject(String fieldName,Class c){
		List<Field> allField = getAllFieldForObj(c);
		if(allField!=null&&allField.size()>0){
			for(Field field : allField){
				if(field.getName().toLowerCase().equalsIgnoreCase(fieldName.toLowerCase())){
					return  field;
				}
			}
		}
		return null;
	}

	/**
	 * 获取字段的setter
	 * @param c 对象类
	 * @param field 字段
	 * @return 方法
	 */
	public static Method getSetmethod(Class c,Field field){
		return getSetmethod(c,field.getName());
	}

	/**
	 * 获取字段的setter
	 * @param c 对象类型
	 * @param fieldName 字段名称
	 * @return 方法
	 */
	public static Method getSetmethod(Class c,String fieldName){
		if(c!=null&&isNotNull(fieldName)){
			try {
				PropertyDescriptor pd = new PropertyDescriptor(fieldName, c);
				return pd.getWriteMethod();
			} catch (SecurityException e) {
			} catch (IntrospectionException e) {
			}
		}
		return null;
	}

	/**
	 * 获取字段的getter
	 * @param c 对象类型
	 * @param fieldName 字段名称
	 * @return 方法
	 */
	public static Method getGetmethod(Class c,String fieldName){
		if(c!=null&&isNotNull(fieldName)){
			try {
				PropertyDescriptor pd = new PropertyDescriptor(fieldName, c);
				return pd.getReadMethod();
			} catch (SecurityException e) {
			} catch (IntrospectionException e) {
			}
		}
		return null;
	}

	/**
	 * 获取字段的getter
	 * @param c 对象类型
	 * @param field 字段
	 * @return 方法
	 */
	public static Method getGetmethod(Class c,Field field){
		return getGetmethod(c,field.getName());
	}

	/**
	 * 获取对象转换字符串
	 * @param obj 对象
	 * @return 字符串
	 */
	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 String.valueOf(obj);
			}else if(obj instanceof Date){
				return VciDateUtil.date2Str((Date)obj, VciDateUtil.DateTimeMillFormat);
			}else{
				return obj.toString();
			}
		}
	}

	/**
	 * 为对象赋值，不判断类型，属性是什么类型的，value就必须是什么类型
	 * @param fieldName 属性名称
	 * @param targetObject 对象
	 * @param value 属性值
	 */
	public static void setValueToField(String fieldName,Object targetObject,Object value){
		if(isNotNull(fieldName)){
			Method setMethod = getSetmethod(targetObject.getClass(), fieldName);
			try {
				if(setMethod != null){
					setMethod.invoke(targetObject, value);
				}else{
					Field field = getFieldForObject(fieldName, targetObject);
					if(field !=null){
						field.setAccessible(true);
						field.set(targetObject, value);
					}
				}
			} catch (IllegalArgumentException e) {
				if(logger.isErrorEnabled()){
					logger.error("WebUtil.setValueToField",e);
				}
			} catch (IllegalAccessException e) {
				if(logger.isErrorEnabled()){
					logger.error("WebUtil.setValueToField",e);
				}
			} catch (InvocationTargetException e) {
				if(logger.isErrorEnabled()){
					logger.error("WebUtil.setValueToField",e);
				}
			}
		}
	}

	/**
	 * 从对象上获取属性的值
	 * @param fieldName 属性名
	 * @param sourceObject 对象
	 * @return 值
	 */
	public static Object getValueFromField(String fieldName,Object sourceObject){
		if(isNotNull(fieldName)){
			try {
				Method getMethod = getGetmethod(sourceObject.getClass(), fieldName);
				if(getMethod !=null){
					return getMethod.invoke(sourceObject);
				}else{
					//说明没有设置getter，比如BO和LO对象这种
					Field field = getFieldForObject(fieldName, sourceObject);
					if(field !=null){
						field.setAccessible(true);
						return field.get(sourceObject);
					}
				}
			} catch (SecurityException e) {
				if(logger.isErrorEnabled()){
					logger.error("WebUtil.getValueFromField",e);
				}
			} catch (IllegalAccessException e) {
				if(logger.isErrorEnabled()){
					logger.error("WebUtil.getValueFromField",e);
				}
			} catch (IllegalArgumentException e) {
				if(logger.isErrorEnabled()){
					logger.error("WebUtil.getValueFromField",e);
				}
			} catch (InvocationTargetException e) {
				if(logger.isErrorEnabled()){
					logger.error("WebUtil.getValueFromField",e);
				}
			}
		}
		return null;
	}

	/**
	 * 是否为普通的属性
	 * @param attrName 属性的名字
	 * @return true
	 */
	public static boolean isNormalAttr(String attrName){
		attrName = attrName.toLowerCase();
		if(attrName.indexOf(".")<0 && attrName.indexOf("_")<0 && !attrName.equalsIgnoreCase("lcstatustext")){
			return true;
		}else{
			return false;
		}
	}


	/**
	 * 将whereSql里的内容转化到查询map里
	 * @param whereSql sql转换为map
	 * @return map
	 */
	public static Map<String,String>  whereSql2Map(
		String whereSql) {
		Map<String,String> map = new HashMap<String, String>();
		if(isNotNull(whereSql)){
			String[] selects = whereSql.split("and");
			if(selects!=null&&selects.length>0){
				for(String s : selects){
					s = s.trim();
					map.put(s.substring(0,s.indexOf(" ")).trim(), s.substring(s.indexOf(" ") +1).trim());
				}
			}
		}
		return map;
	}

	/**
	 * 本机的ip
	 */
	private static String localIp = null;

	/**
	 * 获取本机地址，不是客户端电脑的ip,是当前服务所在的ip
	 * @return
	 */
	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 e){
				localIp = "127.0.0.1";
			}
		}
		return localIp;
	}

	/**
	 * 从网络接口上获取ip地址
	 * @return ip地址
	 */
	private static InetAddress getLocalHostLANAddress(){
		try {
			InetAddress candidateAddress = null;
			// 遍历所有的网络接口
			for (Enumeration ifaces = NetworkInterface.getNetworkInterfaces(); ifaces.hasMoreElements(); ) {
				NetworkInterface iface = (NetworkInterface) ifaces.nextElement();
				// 在所有的接口下再遍历IP
				for (Enumeration inetAddrs = iface.getInetAddresses(); inetAddrs.hasMoreElements(); ) {
					InetAddress inetAddr = (InetAddress) inetAddrs.nextElement();
					if (!inetAddr.isLoopbackAddress()) {// 排除loopback类型地址
						if (inetAddr.isSiteLocalAddress()) {
							// 如果是site-local地址，就是它了
							return inetAddr;
						} else if (candidateAddress == null) {
							// site-local类型的地址未被发现，先记录候选地址
							candidateAddress = inetAddr;
						}
					}
				}
			}
			if (candidateAddress != null) {
				return candidateAddress;
			}
			// 如果没有发现 non-loopback地址.只能用最次选的方案
			InetAddress jdkSuppliedAddress = InetAddress.getLocalHost();
			return jdkSuppliedAddress;
		} catch (Exception e) {
			if(logger.isErrorEnabled()){
				logger.error("获取本机ip",e);
			}
		}
		return null;
	}

	/**
	 * oracle in 查询不能超过1000，转换一下集合
	 * 由于SQL语句1000个可能很长，超过oracle10g，所以牺牲性能分配为500个数组
	 * @param list 需要转换的列表内容
	 * @return 分组后的list
	 */
	public static <T> Collection<Collection<T>> switchCollectionForOracleIn(Collection<T> list) {
		return switchCollectionForOracleIn(list,500);
	}

	/**
	 * 转换集合的大小，这个用在feign调用的时候，不要在sql查询的时候使用
	 * @param collection 需要转换的列表内容
	 * @param preSize 每个分组的大小
	 * @return 分组后的list
	 */
	public static <T> Collection<Collection<T>> switchCollectionForOracleIn(Collection<T> collection,int preSize) {
		Collection<Collection<T>> listHasList = new ArrayList<Collection<T>>();
		if(collection == null){
			return listHasList;
		}
		List<T> newList = new ArrayList<T>();
		for(Object obj : collection){
			//为了让list还可以添加内容，因为使用sublist后，list不能再Add了
			newList.add((T)obj);
		}
		int muti = 1;
		if(newList.size() >preSize){
			int balance = newList.size()%preSize;
			muti = (newList.size() - balance)/preSize + (balance == 0?0:1);
		}
		for(int 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;
	}

}