package kernel.rmi;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.util.Arrays;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;

import org.springframework.context.ApplicationContext;

import kernel.web.ApplicationUtil;

/**
 * @author JORGE
 * @description RMI通用接口实现;
 * 本类在RMI架构中缺省为单例实现,即每一个应用类装载器对应一个RMI通用接口实例
 */
@SuppressWarnings({"serial","unused","unchecked"})
public class RmiFacadeImpl extends UnicastRemoteObject implements RmiFacade{
	/**
	 * 常量提示(未实现远程接口)
	 */
	private static final String NOT_IMPLEMENTED_INTERFACE="RMI-Server: %s : Not Implemented Remote Interface: %s";
	
	/**
	 * 常量提示(未实现远程方法)
	 */
	private static final String NOT_IMPLEMENTED_METHOD="RMI-Server: Remote Method Not Implemented For Interface: %s";
	
	/**
	 * BeanMethod映射字典
	 */
	private static final ConcurrentHashMap<String,BeanMethod> beanMethodMap = new ConcurrentHashMap<String,BeanMethod>();
	
	/**
	 * @throws RemoteException
	 */
	public RmiFacadeImpl() throws RemoteException {}
	
	/**
	 * 通用远程接口实现
	 * @param interfaceClass 远程接口类型
	 * @param beanName BEAN名称
	 * @param methodName 方法名
	 * @param rmiEntity RMI实体
	 * @return RMI实体
	 */
	public RmiEntity invoke(String interfaceClass,String beanName,String methodName,RmiEntity rmiEntity) throws Exception {
		String cacheKey=null;
		Object[] methodArgs=rmiEntity.getParams();
		Class<?>[] paramTypes=rmiEntity.paramTypes;
		boolean emptyParams=(null==paramTypes || 0==paramTypes.length);
		String paramTypeStrs=emptyParams?"()":Arrays.stream(paramTypes).map(paramType->paramType.getName()).collect(Collectors.joining(",","(",")"));
		
		BeanMethod beanMethod=beanMethodMap.get(cacheKey=new StringBuilder(interfaceClass).append(".")
		.append(beanName).append(".").append(methodName).append(paramTypeStrs).toString());
		if(null!=beanMethod) return beanMethod.invoke(methodArgs);
		
		ApplicationContext appContext=ApplicationUtil.getApplicationContext();
		Class<?> intetrfaceType=appContext.getClass().getClassLoader().loadClass(interfaceClass);
		Map<String,Object> beanMap=(Map<String,Object>)appContext.getBeansOfType(intetrfaceType);
		
		if(null==beanMap || beanMap.isEmpty()) {
			throw new RuntimeException(String.format(Locale.ENGLISH,NOT_IMPLEMENTED_INTERFACE,ApplicationUtil.getContextPath(),interfaceClass));
		}
		
		Method targetMethod=emptyParams?findMethod(intetrfaceType,methodName):findMethod(intetrfaceType,methodName,paramTypes);
		
		if(null==targetMethod) {
			throw new RuntimeException(String.format(Locale.ENGLISH,NOT_IMPLEMENTED_METHOD,cacheKey));
		}
		
		Object beanImpl=beanMap.values().iterator().next();
		beanMethodMap.put(cacheKey,beanMethod=new BeanMethod(null==beanName?beanImpl:beanMap.getOrDefault(beanName,beanImpl),targetMethod));
		
		return beanMethod.invoke(methodArgs);
	}
	
	/**
	 * 查找本地方法
	 * @param beanClass BEAN类型
	 * @param methodName 方法名
	 * @return 本地方法对象
	 */
	private static final Method findMethod(Class<?> beanClass,String methodName) {
		while (null!=beanClass) {
			Method[] targetMethods = beanClass.getDeclaredMethods();
			for (Method targetMethod : targetMethods) {
				int mod=targetMethod.getModifiers();
				if(!Modifier.isPublic(mod) || Modifier.isStatic(mod)) continue;
				if (!methodName.equals(targetMethod.getName())) continue;
				if(0!=targetMethod.getParameterCount()) continue;
				return targetMethod;
			}
			beanClass = beanClass.getSuperclass();
		}
		return null;
	}
	
	/**
	 * 查找本地方法
	 * @param beanClass BEAN类型
	 * @param methodName 方法名
	 * @param paramTypes 参数类型表
	 * @return 本地方法对象
	 */
	private static final Method findMethod(Class<?> beanClass,String methodName,Class<?>[] paramTypes) {
		while (null!=beanClass) {
			Method[] targetMethods = beanClass.getDeclaredMethods();
			out:for (Method targetMethod : targetMethods) {
				int mod=targetMethod.getModifiers();
				if(!Modifier.isPublic(mod) || Modifier.isStatic(mod)) continue;
				if (!methodName.equals(targetMethod.getName())) continue;
				if(0==targetMethod.getParameterCount()) continue;
				
				Class<?>[] targetMethodArgs=targetMethod.getParameterTypes();
				if(paramTypes.length!=targetMethodArgs.length) continue;
				
				for(int i=0;i<paramTypes.length;i++) {
					if(ApplicationUtil.compatible(targetMethodArgs[i],paramTypes[i])) {
						continue;
					}else {
						continue out;
					}
				}
				
				return targetMethod;
			}
			beanClass = beanClass.getSuperclass();
		}
		return null;
	}
	
	/**
	 * @author JORGE
	 * @description BeanMethod
	 */
	private static class BeanMethod{
		/**
		 * BEAN实现
		 */
		private Object targetBean;
		
		/**
		 * 实现方法
		 */
		private Method targetMethod;
		
		public BeanMethod(Object targetBean,Method targetMethod) {
			this.targetBean=targetBean;
			this.targetMethod=targetMethod;
		}
		
		public RmiEntity invoke(Object[] methodArgs) throws Exception {
			Object result=null;
			try {
				result=targetMethod.invoke(targetBean, methodArgs);
			}catch(InvocationTargetException e) {
				result=e.getCause();
				((Throwable)result).printStackTrace();
			}catch(Throwable e) {
				result=e;
				e.printStackTrace();
			}
			
			return new RmiEntity(result);
		}
	}
}