/**
    * Copyright By Grandsoft Company Limited.  
    * 2012-2-28 上午11:28:45
    */
   package gboat2.base.core.service;
   
   import gboat2.base.core.GBoatClassLoader;
   import gboat2.base.core.annotation.Attach;
   import gboat2.base.core.annotation.Attachs;
  import gboat2.base.core.annotation.Modules;
  import gboat2.base.core.annotation.Operation;
  import gboat2.base.core.annotation.Operations;
  import gboat2.base.core.annotation.Preference;
  import gboat2.base.core.model.Module;
  import gboat2.base.core.model.ModuleAttach;
  import gboat2.base.core.model.Opera;
  import gboat2.base.core.model.PreferenceDefinition;
  import gboat2.base.bridge.util.BundleUtil;
  
  import java.lang.reflect.Method;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  import java.util.Vector;
  import java.util.concurrent.CopyOnWriteArrayList;
  
  import org.apache.commons.lang3.StringUtils;
  import org.osgi.framework.Bundle;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * 
   * @author zhaic
   * @since jdk1.6
   * @date 2012-2-28
   */
  
  public class ModuleService implements IModuleService {
  
  	private static Logger logger = LoggerFactory.getLogger(ModuleService.class);
  
  	private static final List<Module> moduleList = new CopyOnWriteArrayList<Module>();
  
  	private static List<String> toRegistActionPackages = new LinkedList<String>();
  
  	//记录类对应的operations
  	private static Map<String, List<Operation>> operationsInClass = new HashMap<String, List<Operation>>();
  
  	//记录操作间的关联关系,@Operation中invokeAction记录其关联关系
  	//private static Map<String, List<String>> referOperas = new HashMap<String, List<String>>();
  
  	/**
  	 * key: invokeAction.invokeMethod, value : actionClass.operationCode列表
  	 * 一个action中的method可以有多个注解操作.为了解决在方法上的注解，当code与方法名不同时,出现权限出错的问题。
  	 * 将每个方法对应的所有注解挂载到该方法下面，是一对多的关系。
  	 */
  	private static Map<String, List<String>> actionMethod2actionOperaCodesMapping = new HashMap<String, List<String>>();
  
  	/**
  	 * 记录所有首选项定义
  	 */
  	private static List<PreferenceDefinition> preferences = new Vector<PreferenceDefinition>();
  
  	/**
  	 * 记录所有模块附件集定义
  	 */
  	private static List<ModuleAttach> moduleAttachList = new Vector<ModuleAttach>();
  
  	public static List<String> getOperationCodesOf(String actionClass, String method) {
  		return actionMethod2actionOperaCodesMapping.get(actionClass + "." + method);
  	}
  
  	/**
  	 * 解析Oprea对象，将其中的operaCodes挂载到actionMethod下
  	 * @param opera
  	 */
  	private static void mountOpera2actionMethod(Opera opera) {
  		String actionMethod = opera.getInvokeAction() + "." + opera.getInvokeMethod();
  		if (actionMethod2actionOperaCodesMapping.containsKey(actionMethod)) {
  			List<String> operas = actionMethod2actionOperaCodesMapping.get(actionMethod);
  			if (!operas.contains(opera.getCode())) {//避免重复追加
  				operas.add(opera.getCode());
  			}
  		} else {
  			List<String> operaCodes = new LinkedList<String>();
  			operaCodes.add(opera.getCode());
  			actionMethod2actionOperaCodesMapping.put(actionMethod, operaCodes);
  		}
  	}
  
  	@Override
  	public List<Module> getModuleListByBundleName(String bundleName) {
  		List<Module> moduleList = new ArrayList<Module>();
  		if (!StringUtils.isEmpty(bundleName)) {
  			for (Module module : getModuleList()) {
  				if (bundleName.equals(module.getBundleName()) && !moduleList.contains(module)) {
 					moduleList.add(module);
 				}
 			}
 		}
 		return moduleList;
 	}
 
 	@Override
 	public List<Module> getModules() {
 		return getModuleList();
 	}
 
 	@Override
 	public List<Module> getModules(String queryString) {
 		List<Module> moduleList = new ArrayList<Module>();
 		for (Module module : getModuleList()) {
 			if (judgeModule(queryString, module)) {
 				moduleList.add(module);
 			}
 		}
 		return moduleList;
 	}
 
 	@Override
 	public List<Module> getModuleByBundleAddAction(String bundleName, String actionName) {
 		List<Module> moduleList = new ArrayList<Module>();
 		if (!StringUtils.isEmpty(bundleName) && !StringUtils.isEmpty(actionName)) {
 			for (Module module : getModuleList()) {
 				if (bundleName.equals(module.getBundleName())) {
 					moduleList.add(module);
 				}
 			}
 		}
 		return moduleList;
 	}
 
 	public static Module getModuleForMetadata(String bundleName, String actionName) {
 		if (!StringUtils.isEmpty(bundleName) && !StringUtils.isEmpty(actionName)) {
 			for (Module module : getModuleList()) {
 				if (bundleName.equals(module.getBundleName()) && actionName.equals(module.getClassName())) {
 					return module;
 				}
 			}
 		}
 		return null;
 	}
 
 	@Override
 	public List<Opera> getOperaByBundleAddAction(String bundleName, String actionName) {
 		List<Opera> operaList = new ArrayList<Opera>();
 		Module module = getModuleForMetadata(bundleName, actionName);
 		if (module != null) {
 			//将Module中的的operation注解值注册
 			operaList.addAll(module.getOperas());
 		}
 		return operaList;
 	}
 
 	@Override
 	public List<Opera> getOperaByAction(String actionName) {
 		if (actionName.indexOf(".") != -1) {
 			String packageName = actionName.substring(0, actionName.lastIndexOf("."));
 			Bundle bundle = GBoatClassLoader.getInstance().getBundle(packageName);
 			if (null != bundle) {
 				return getOperaByBundleAddAction(bundle.getSymbolicName(), actionName);
 			}
 		}
 		return null;
 	}
 
 	/**
 	 * 获取某个Action的所有操作
 	 * @param bundleName bundle名称
 	 * @param actionName actionName名称
 	 * @return  List<Opera>
 	 */
 	public static List<Opera> getOperaForMetadata(String bundleName, String actionName) {
 		List<Opera> operaList = new ArrayList<Opera>();
 		Module module = getModuleForMetadata(bundleName, actionName);
 		if (module != null) {
 			//将Module中的的operation注解值注册
 			operaList.addAll(module.getOperas());
 		}
 		return operaList;
 	}
 
 	/**
 	 * 判断某个方法是否被Operations或者Operation注解注释
 	 * @param method 方法名称
 	 * @param clazz 当前类
 	 * @return 当前类的当前方法是否有注解
 	 */
 	public static boolean isMethodOperationAnnotationed(Class<?> clazz, Method method, String privilegeMethod) {
 		List<Operation> operations;
 		if (operationsInClass.containsKey(clazz.getName())) {
 			operations = (List<Operation>) operationsInClass.get(clazz.getName());
 		} else {
 			operations = new LinkedList<Operation>();
 			//先判断是不是Action类级别的Operations注解中的方法
 			Operations operAnnotationClass = (Operations) clazz.getAnnotation(Operations.class);
 			if (null != operAnnotationClass) {
 				Operation[] operas = operAnnotationClass.value();
 				for (Operation opera : operas) {
 					operations.add(opera);
 				}
 			}
 			operationsInClass.put(clazz.getName(), operations);
 		}
 		for (Operation opera : operations) {
 			if ((!StringUtils.isEmpty(opera.invokeMethod()) && opera.invokeMethod().equals(privilegeMethod))
 					|| (StringUtils.isEmpty(opera.invokeMethod()) && opera.code().equals(privilegeMethod))) {
 				return true;
 			}
 		}
 		//再判断是不是在方法级别使用Operations或者Operation注解的方法
 		return method.isAnnotationPresent(Operations.class) || method.isAnnotationPresent(Operation.class);
 	}
 
 	//注册某个Bundle里的某个package下的Action的Module
 	public static void registModule(String pkg) {
 		//注册是不解析，在第一次使用时解析，参见getModuleList
 		synchronized (toRegistActionPackages) {
 			toRegistActionPackages.add(pkg);
 		}
 	}
 
 	private static List<Module> getModuleList() {
 		synchronized (toRegistActionPackages) {
 			if (toRegistActionPackages.size() > 0) {
 				Bundle bundle;
 				for (String pkg : toRegistActionPackages) {
 					bundle = GBoatClassLoader.getInstance().getBundle(pkg);
 					if (bundle == null) {
 						logger.error("Can't find bundle for package[" + pkg + "]");
 					}
 					List<String> classList = BundleUtil.getClasses(pkg, bundle);
 					List<Class<?>> actionList = getClassesFromBundle(classList, bundle);
 					for (Class<?> actionClass : actionList) {
 						//处理首选项的注解
 						processPreferenceAnnotation(actionClass, bundle.getSymbolicName());
 
 						processAttachAnnotation(actionClass);
 
 						//处理操作注解
 						List<Opera> operas = processOperationAnnotationsOfAction(actionClass);
 
 						//处理模块注解
 						processModuleAnnotationsOfAction(bundle.getSymbolicName(), actionClass, operas);
 					}
 				}
 				toRegistActionPackages.clear();
 			}
 		}
 		return moduleList;
 	}
 
 	/**
 	 * 处理action class上的所有模块注解
 	 * @param string 
 	 * @param action
 	 * @param operas 
 	 * @return
 	 */
 	private static void processModuleAnnotationsOfAction(String bundle, Class<?> action, List<Opera> operas) {
 		//处理单个注解
 		gboat2.base.core.annotation.Module m = action.getAnnotation(gboat2.base.core.annotation.Module.class);
 		if (null != m) {
 			Module module = new Module(m, bundle, action, operas);
 			if (!moduleList.contains(module)) {
 				moduleList.add(module);
 			}
 		}
 
 		//处理集合注解
 		Modules tmp = action.getAnnotation(Modules.class);
 		if (null != tmp) {
 			gboat2.base.core.annotation.Module[] modules = tmp.value();
 			for (gboat2.base.core.annotation.Module mod : modules) {
 				Module module = new Module(mod, bundle, action, operas);
 				if (!moduleList.contains(module)) {
 					moduleList.add(module);
 				}
 			}
 		}
 	}
 
 	public static void unRegistModule(Bundle bundle) {
 		for (Module module : moduleList) {
 			if (bundle.getSymbolicName().equals(module.getBundleName())) {
 				moduleList.remove(module);
 			}
 		}
 	}
 
 	/**
 	 * 判断一个Operation注解的是否为一个跨action调用的注解
 	 * 如果Opera中的action与invokeAction不相同，则表示跨action
 	 * @param opera
 	 * @return 
 	 */
 	private static boolean isCrossAction(Opera opera) {
 		return !opera.getAction().equals(opera.getInvokeAction());
 	}
 
 	/**
 	 * 根据方法级别上的Operation注解构造Opera操作对象，并将相应的actionOperationCode挂载到actionMethod下
 	 * @param operation
 	 * @param method
 	 * @param action
 	 * @return
 	 */
 	private static Opera constructMethodLevelOpera(Operation operation, Method method, Class<?> action) {
 		Opera opera = new Opera(operation, method, action);
 
 		//opera构造完毕后需要挂载到actionMethod下
 		mountOpera2actionMethod(opera);
 
 		//opera构造完毕后需要判断是否跨Action，如果跨action，则需要为该方法也挂载一个相同的actionOperationCode
 		if (isCrossAction(opera)) {
 			//需要多构造一个非跨action的opera，挂载到actionMethod, 但这个opera不添加到module的opera list中
 			Opera tmp = new Opera("", operation.code(), action.getClass().getName(), action.getClass().getName(), method.getName(), "");
 			mountOpera2actionMethod(tmp);//执行挂载
 		}
 		return opera;
 	}
 
 	/**
 	 * 根据类法级别上的Operation注解构造Opera操作对象，并将相应的actionOperationCode挂载到actionMethod下
 	 * @param operation
 	 * @param action
 	 * @return
 	 */
 	private static Opera constructClassLevelOpera(Operation operation, Class<?> action) {
 		Opera opera = new Opera(operation, action);
 		//opera构造完毕后需要挂载到actionMethod下
 		mountOpera2actionMethod(opera);
 		return opera;
 	}
 
 	/**
 	 * 处理ationClass类上所有的Operation注解。
 	 * 如果已经添加了方法级别的Operation注解，则类级别的重复的Operation注解自动失效
 	 * @param action
 	 * @return ationClass的所有操作
 	 */
 	private static List<Opera> processOperationAnnotationsOfAction(Class<?> action) {
 		List<Opera> operas = new ArrayList<Opera>();
 
 		//处理所有方法级别的注解
 		List<Method> methods = getMethodsOfOperationAnnotationed(action);
 		Operations operations;
 		Operation operation;
 		if (null != methods) {
 			for (Method method : methods) {
 				operations = method.getAnnotation(Operations.class);
 				if (null != operations) {
 					Operation[] opers = operations.value();
 					for (Operation tmp : opers) {
 						operas.add(constructMethodLevelOpera(tmp, method, action));
 					}
 				}
 				operation = method.getAnnotation(Operation.class);
 				if (null != operation) {
 					operas.add(constructMethodLevelOpera(operation, method, action));
 				}
 			}
 		}
 
 		//处理类级别的注解
 		operations = action.getAnnotation(Operations.class);
 		if (null != operations) {
 			Operation[] opers = operations.value();
 			for (Operation tmp : opers) {
 				//如果已经添加了方法级别的Operation注解，则类级别的重复的Operation注解自动失效，不再添加
 				if (null == getOperaByClassAndcode(operas, tmp.code())) {
 					operas.add(constructClassLevelOpera(tmp, action));
 				}
 			}
 		}
 		operation = action.getAnnotation(Operation.class);
 		if (null != operation) {
 			//如果已经添加了方法级别的Operation注解，则类级别的重复的Operation注解自动失效，不再添加
 			if (null == getOperaByClassAndcode(operas, operation.code())) {
 				operas.add(constructClassLevelOpera(operation, action));
 			}
 		}
 
 		return operas;
 	}
 
 	//将传入的Method对象提取注解，解析为Opera对象
 	//	private static List<Opera> getOperasMethodByMethodList(Class actionClass, List<Method> methodList) {
 	//		List<Opera> operaList = new ArrayList<Opera>();
 	//		for (Method method : methodList) {
 	//			Operations operations = method.getAnnotation(Operations.class);
 	//			if (null != operations) {
 	//				//获取其子注解
 	//				Operation[] opers = ((Operations) operations).value();
 	//				for (Operation tempOper : opers) {
 	//					Opera tempOpera = new Opera();
 	//					tempOpera.setName(tempOper.name());
 	//					tempOpera.setDesc(tempOper.desc());
 	//					tempOpera.setAction(actionClass.getName());
 	//					tempOpera.setInvokeMethod(method.getName());
 	//					tempOpera.setCode(tempOper.code());
 	//					operaList.add(tempOpera);
 	//					checkReferAtAnnotation(tempOper, actionClass, method.getName());
 	//				}
 	//			}
 	//			Operation operation = method.getAnnotation(Operation.class);
 	//			if (null != operation) {
 	//				Opera tempOpera = new Opera();
 	//				tempOpera.setName(operation.name());
 	//				tempOpera.setDesc(operation.desc());
 	//				tempOpera.setAction(actionClass.getName());
 	//				tempOpera.setInvokeMethod(method.getName());
 	//				tempOpera.setCode(operation.code());
 	//				operaList.add(tempOpera);
 	//				checkReferAtAnnotation(operation, actionClass, method.getName());
 	//			}
 	//		}
 	//		return operaList;
 	//	}
 
 	//	private static void checkReferAtAnnotation(Operation tempOper, Class actionClass, String methodName) {
 	//		//如果注解包含了invokeAction，记录关联关系
 	//		if (!StringUtils.isEmpty(tempOper.invokeAction())) {
 	//			String key = tempOper.invokeAction() + "." + tempOper.invokeMethod();
 	//			String referedName = actionClass.getName() + "." + tempOper.code();
 	//			if (referOperas.containsKey(key)) {
 	//				List<String> refers = referOperas.get(key);
 	//				if (!refers.contains(referedName)) {
 	//					refers.add(referedName);
 	//				}
 	//			} else {
 	//				List<String> refers = new LinkedList();
 	//				refers.add(referedName);
 	//				referOperas.put(key, refers);
 	//			}
 	//		}
 	//	}
 
 	//解析某个类上的@Operations注解
 	//	private static List<Opera> getOperasByClass(Class<?> clazz, List<Opera> opera) {
 	//		List<Opera> operaList = new ArrayList<Opera>();
 	//		if (null != clazz) {
 	//			Operations operations = clazz.getAnnotation(Operations.class);
 	//			if (null != operations) {
 	//				//获取其子注解
 	//				Operation[] opers = ((Operations) operations).value();
 	//				String methodName;
 	//				for (Operation tempOper : opers) {
 	//					//已经在Action的方法上添加了注解，则Action类上的注解自动失效，不再添加
 	//					if (null == getOperaByClassAndcode(opera, tempOper.code())) {
 	//						Opera tempOpera = new Opera();
 	//						tempOpera.setName(tempOper.name());
 	//						tempOpera.setDesc(tempOper.desc());
 	//						tempOpera.setAction(clazz.getName());
 	//						//如果不是注解在方法上就默认和code保持一致
 	//						methodName = StringUtils.isEmpty(tempOper.invokeMethod()) ? tempOper.code() : tempOper
 	//						        .invokeMethod();
 	//						tempOpera.setInvokeMethod(methodName);
 	//						tempOpera.setCode(tempOper.code());
 	//						operaList.add(tempOpera);
 	//						checkReferAtAnnotation(tempOper, clazz, methodName);
 	//					}
 	//				}
 	//			}
 	//		}
 	//		return operaList;
 	//	}
 
 	//获取某个类中被某个注解注释了的所有方法
 	private static List<Method> getMethodsOfOperationAnnotationed(Class<?> clazz) {
 		List<Method> methodList = new ArrayList<Method>();
 		Method[] methodArray = clazz.getMethods();
 		for (Method method : methodArray) {
 			if (method.isAnnotationPresent(Operations.class) || method.isAnnotationPresent(Operation.class)) {
 				methodList.add(method);
 			}
 		}
 		return methodList;
 	}
 
 	//判断是否符合查询条件
 	private boolean judgeModule(String queryStr, Module module) {
 		if (!StringUtils.isEmpty(queryStr)) {
 			//如果Bundle名、类名、Bundle描述、节点名中包含要查询的字符串，则返回true
 			if (module.getBundleName().indexOf(queryStr) != -1) {
 				return true;
 			}
 			if (module.getClassName().indexOf(queryStr) != -1) {
 				return true;
 			}
 			if (module.getModuleDesc().indexOf(queryStr) != -1) {
 				return true;
 			}
 			if (module.getModuleName().indexOf(queryStr) != -1) {
 				return true;
 			}
 		}
 		return false;
 	}
 
 	//获取某个Bundle中某个包下的所有类
 	private static List<Class<?>> getClassesFromBundle(List<String> classNames, Bundle bundle) {
 		List<Class<?>> classes = new ArrayList<Class<?>>();
 		for (String className : classNames) {
 			try {
 				Class<?> clazz = bundle.loadClass(className);
 				if (null != clazz) {
 					classes.add(clazz);
 				}
 			} catch (ClassNotFoundException e) {
 				e.printStackTrace();
 			}
 		}
 		return classes;
 	}
 
 	/** 
 	 * 根据Action名和Opera的code属性，获取符合等于该两个属性的Opera
 	 * @param className 该Opera所在的类
 	 * @param operaCode 该Opera的code
 	 * @return Opera对象
 	 */
 	private static Opera getOperaByClassAndcode(List<Opera> opera, String operaCode) {
 		if (!StringUtils.isEmpty(operaCode)) {
 			for (Opera tempOpera : opera) {
 				if (operaCode.equals(tempOpera.getCode())) {
 					return tempOpera;
 				}
 			}
 		}
 		return null;
 	}
 
 	//	public static List<String> getReferActions(String opera) {
 	//		return referOperas.get(opera);
 	//	}
 
 	@Override
 	public List<PreferenceDefinition> getPreferences() {
 		return preferences;
 	}
 
 	@Override
 	public List<ModuleAttach> getModuleAttachList() {
 		return moduleAttachList;
 	}
 
 	//action上处理首选项注解Preference
 	private static void processPreferenceAnnotation(Class<?> actionClass, String bundle) {
 		Preference pre = actionClass.getAnnotation(Preference.class);//解析类上的Preference注解
 		PreferenceDefinition preDef;
 		if (null != pre) {
 			preDef = new PreferenceDefinition();
 			preDef.setBundle(bundle);
 			preDef.setActionClass(actionClass.getName());
 			preDef.setFullname(pre.value());
 			preferences.add(preDef);
 		}
 
 		Method[] methods = actionClass.getMethods();
 		if (null != methods) {
 			for (Method method : methods) {//解析每个方法上的Preference注解
 				pre = method.getAnnotation(Preference.class);
 				if (null != pre) {
 					preDef = new PreferenceDefinition();
 					preDef.setBundle(bundle);
 					preDef.setActionClass(actionClass.getName());
 					preDef.setFullname(pre.value());
 					preDef.setMethod(method.getName());
 					preferences.add(preDef);
 				}
 			}
 		}
 	}
 
 	//action上处理首选项注解Preference
 	private static void processAttachAnnotation(Class<?> actionClass) {
 
 		ModuleAttach moduleAttach;
 		//处理单个Attach注解
 		Attach attach = actionClass.getAnnotation(Attach.class);
 
 		if (null != attach) {
 			moduleAttach = new ModuleAttach();
 			if (StringUtils.isEmpty(attach.targetName())) {
 				gboat2.base.core.annotation.Module module = actionClass.getAnnotation(gboat2.base.core.annotation.Module.class);
 				if (null != module) {
 					moduleAttach.setModuleName(module.name());
 				}
 			} else {
 				moduleAttach.setModuleName(attach.targetName());
 			}
 			moduleAttach.setAttachCode(attach.code());
 			moduleAttachList.add(moduleAttach);
 		}
 
 		//处理集合注解(Attachs)
 		Attachs attachs = actionClass.getAnnotation(Attachs.class);
 		if (null != attachs) {
 			Attach[] attachArray = attachs.value();
 			for (Attach att : attachArray) {
 				moduleAttach = new ModuleAttach();
 				moduleAttach.setAttachCode(att.targetCode());
 				moduleAttach.setModuleName(att.targetName());
 				if (!moduleAttachList.contains(moduleAttach)) {
 					moduleAttachList.add(moduleAttach);
 				}
 			}
 		}
 
 	}
 
 }