package com.shhxzq.fin.lifeapp.biz.utils;

import org.apache.commons.jexl3.JexlContext;
import org.apache.commons.jexl3.JexlEngine;
import org.apache.commons.jexl3.JexlExpression;
import org.apache.commons.jexl3.MapContext;
import org.apache.commons.jexl3.internal.Engine;
import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.Logger;

/** 
 * 表达式语言工具类
 * 依赖commons-jexl3包
 * @author Gxx
 */
public class ExpressLanUtils {
	/**
	 * 日志记录器
	 */
	static Logger logger = BaseUuidLoggerUtils.getBaseUuidLogger();
	/**
	 * 请求参数前缀标示
	 */
	public static final String REQUEST_PREFIX = "{request";
	/**
	 * 请求参数后缀标示
	 */
	public static final String REQUEST_SUFFIX = "}";
	/**
	 * 请求参数前缀标示
	 */
	public static final String RESPONSE_PREFIX = "{response";
	/**
	 * 请求参数后缀标示
	 */
	public static final String RESPONSE_SUFFIX = "}";
	/**
	 * 分隔符
	 */
	public static final String SPLIT_STRING = "\\{\\|\\}";
	
	/**
	 * 判断是否是表达式
	 * @param string
	 * @return
	 */
	public static boolean isExpress(String string) {
		return isRequestExpress(string) || isResponseExpress(string);
	}
	
	/**
	 * 判断是否是[获取请求]表达式
	 * @param string
	 * @return
	 */
	public static boolean isRequestExpress(String string) {
		/**
		 * 判断非空
		 */
		if(StringUtils.isNotBlank(string)) {
			string = StringUtils.trim(string);
			if(string.startsWith(REQUEST_PREFIX) && string.endsWith(REQUEST_SUFFIX)) {
				return true;
			}
		}
		return false;
	}
	
	/**
	 * 判断是否是[获取返回]表达式
	 * @param string
	 * @return
	 */
	public static boolean isResponseExpress(String string) {
		/**
		 * 判断非空
		 */
		if(StringUtils.isNotBlank(string)) {
			string = StringUtils.trim(string);
			if(string.startsWith(RESPONSE_PREFIX) && string.endsWith(RESPONSE_SUFFIX)) {
				return true;
			}
		}
		return false;
	}
	
	/**
	 * 从表达式(按分隔符拆分后)获取对象
	 * 1.非表达式，原样返回
	 * 2.[获取请求]表达式，解析表达式，返回[请求]中的值
	 * 3.[获取返回]表达式，
	 * 3.1.没有异常发生，解析表达式，返回[返回]中的值
	 * 3.2.有异常发生，返回null
	 * @param express 表达式:[获取请求]表达式/[获取返回]表达式
	 * @param request 请求参数数组
	 * @param response 返回参数
	 * @param isException 是否发生异常
	 * @return
	 */
	public static Object getObjectFromExpress(String express, Object[] request, Object response, boolean isException) {
		try {
			/**
			 * 1.非表达式，原样返回
			 */
			boolean isRequestExpress = isRequestExpress(express);
			boolean isResponseExpress = isResponseExpress(express);
			if(!isRequestExpress && !isResponseExpress) {
				return express;
			}
			/**
			 * 2.[获取请求]表达式，解析表达式，返回[请求]中的值
			 * 比如:
			 * {request} : 取第一个request参数
			 * {request[0]} : 取第一个request参数
			 * {request[1]} : 取第二个request参数
			 * {request.custNo} : 取第一个request参数的属性
			 * {request.createdAt.time} : 取第一个request参数的属性的属性
			 * {request[0].custNo} : 取第一个request参数的属性
			 * {request[0].createdAt.time} : 取第一个request参数的属性的属性
			 * {request[1].createdAt.time} : 取第二个request参数的属性的属性
			 */
			if(isRequestExpress) {
				/**
				 * 2.0.判空
				 */
				if(null == request || request.length == 0) {
					return null;
				}
				/**
				 * 2.1.去掉开头:{request
				 */
				express = express.substring(REQUEST_PREFIX.length());
				/**
				 * 2.2.去掉结尾:}
				 */
				express = express.substring(0, express.length() - 1);
				/**
				 * 2.3.判空 {request}
				 */
				if(StringUtils.isBlank(express)) {
					return request[0];
				}
				/**
				 * 2.4.判断.开头
				 */
				Object object = null;
				if(express.startsWith(".")) {
					express = express.substring(1);
					object = request[0];
					return getObjectFromExpress(express, object);
				}
				/**
				 * 2.4.判断[开头
				 */
				if(express.startsWith("[")) {
					express = express.substring(1);
					int index = express.indexOf("]");
					int indexValue = Integer.parseInt(express.substring(0, index));
					object = request[indexValue];
					express = express.substring(index + 1);
					/**
					 * 2.4.1.判断request[*]
					 */
					if(StringUtils.isBlank(express)) {
						return object;
					}
					/**
					 * 2.4.2.判断request[*].custNo
					 */
					if(express.startsWith(".")) {
						express = express.substring(1);
						return getObjectFromExpress(express, object);
					}
				}
				
			}
			/**
			 * 3.[获取返回]表达式，解析表达式，返回[返回]中的值
			 * 比如:
			 * {response} : 取第一个request参数
			 * {response.custNo} : 取第一个request参数的属性
			 * {response.createdAt.time} : 取第一个request参数的属性的属性
			 */
			if(isResponseExpress) {
				/**
				 * 3.0.判空
				 */
				if(null == response) {
					return null;
				}
				/**
				 * 3.1.去掉开头:{response
				 */
				express = express.substring(RESPONSE_PREFIX.length());
				/**
				 * 3.2.去掉结尾:}
				 */
				express = express.substring(0, express.length() - 1);
				/**
				 * 3.3.判空 {response}
				 */
				if(StringUtils.isBlank(express)) {
					return response;
				}
				/**
				 * 3.4.判断.开头
				 */
				if(express.startsWith(".")) {
					express = express.substring(1);
					return getObjectFromExpress(express, response);
				}
			}
			return null;
		} catch (Exception e) {
			logger.error("从表达式获取对象异常发生", e);
			return null;
		}
	}
	
	/**
	 * 从表达式(jexl)获取对象
	 * @param express
	 * @param object
	 * @return
	 */
	public static Object getObjectFromExpress(String express, Object object) {
		try {
			/**
			 * 判空
			 */
			if(null == object) {
				return null;
			}
			JexlEngine JEXL = new Engine();
			JexlExpression e = JEXL.createExpression("object." + express);
	        JexlContext jc = new MapContext();
	        jc.set("object", object);
	        return e.evaluate(jc);
		} catch (Exception e) {
			logger.error("从表达式获取对象异常发生", e);
			return null;
		}
	}
	
	/**
	 * 从表达式(按分隔符拆分后)获取对象并转成string
	 * @param express
	 * @param request
	 * @param response
	 * @param isException
	 * @return
	 */
	public static String getObjectFromExpressToString(String express, Object[] request, Object response, boolean isException) {
		/**
		 * 从表达式获取对象
		 */
		Object result = getObjectFromExpress(express, request, response, isException);
		if(null == result) {
			return null;
		} else {
			return result.toString();
		}
	}
	
	/**
	 * 从表达式(按分隔符拆分前)获取对象并转成string
	 * @param express
	 * @param request
	 * @param response
	 * @param isException
	 * @return
	 */
	public static Object getObjectFromExpressexToString(String express, Object[] request, Object response, boolean isException) {
		try {
			/**
			 * 1.非表达式，原样返回
			 * NORMAL_STRING
			 * NORMAL_STRING{|}{response.*}{|}{request[*].*}
			 * {request.*}
			 * {request[*].*}
			 * {response.*}
			 * {request.*}{|}{request[*].*}
			 * {request[*].*}{|}{response.*}
			 * {response.*}{|}{response.*}{|}{request[*].*}
			 */
			if(StringUtils.isBlank(express)) {
				return express;
			}
			String result = StringUtils.EMPTY;
			String[] expressArray = express.split(SPLIT_STRING);
			for(int i=0;i<expressArray.length;i++) {
				if(i > 0) {
					result += "|";
				}
				/**
				 * 从表达式获取对象
				 */
				Object temp = getObjectFromExpressToString(expressArray[i], request, response, isException);
				/**
				 * 空则略过
				 */
				if(null != temp) {
					result += temp.toString();
				}
			}
			return result;
		} catch (Exception e) {
			logger.error("从表达式(按分隔符拆分前)获取对象并转成string异常发生！", e);
			return express;
		}
	}
}