package com.yami.trading.common.util;

import cn.hutool.core.util.StrUtil;
import lombok.experimental.UtilityClass;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.BridgeMethodResolver;
import org.springframework.core.DefaultParameterNameDiscoverer;
import org.springframework.core.MethodParameter;
import org.springframework.core.ParameterNameDiscoverer;
import org.springframework.core.annotation.AnnotatedElementUtils;
import org.springframework.core.annotation.SynthesizingMethodParameter;

import java.io.File;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.net.URL;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.Date;
import java.util.Enumeration;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

/**
 * 类工具类
 *
 * @author L.cm
 */
@UtilityClass
public class CustomeClassUtils extends org.springframework.util.ClassUtils {
	private final static Logger logger = LoggerFactory.getLogger(CustomeClassUtils.class);

	// 缓存起来，提升效率，field：完整类名#属性名
	private final static ConcurrentHashMap<String, Field> cacheMap = new ConcurrentHashMap();

	private final ParameterNameDiscoverer PARAMETERNAMEDISCOVERER = new DefaultParameterNameDiscoverer();

	/**
	 * 获取方法参数信息
	 * @param constructor 构造器
	 * @param parameterIndex 参数序号
	 * @return {MethodParameter}
	 */
	public MethodParameter getMethodParameter(Constructor<?> constructor, int parameterIndex) {
		MethodParameter methodParameter = new SynthesizingMethodParameter(constructor, parameterIndex);
		methodParameter.initParameterNameDiscovery(PARAMETERNAMEDISCOVERER);
		return methodParameter;
	}

	/**
	 * 获取方法参数信息
	 * @param method 方法
	 * @param parameterIndex 参数序号
	 * @return {MethodParameter}
	 */
	public MethodParameter getMethodParameter(Method method, int parameterIndex) {
		MethodParameter methodParameter = new SynthesizingMethodParameter(method, parameterIndex);
		methodParameter.initParameterNameDiscovery(PARAMETERNAMEDISCOVERER);
		return methodParameter;
	}

	/**
	 * 获取Annotation
	 * @param method Method
	 * @param annotationType 注解类
	 * @param <A> 泛型标记
	 * @return {Annotation}
	 */
	public <A extends Annotation> A getAnnotation(Method method, Class<A> annotationType) {
		Class<?> targetClass = method.getDeclaringClass();
		// The method may be on an interface, but we need attributes from the target
		// class.
		// If the target class is null, the method will be unchanged.
		Method specificMethod = CustomeClassUtils.getMostSpecificMethod(method, targetClass);
		// If we are dealing with method with generic parameters, find the original
		// method.
		specificMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);
		// 先找方法，再找方法上的类
		A annotation = AnnotatedElementUtils.findMergedAnnotation(specificMethod, annotationType);

		if (null != annotation) {
			return annotation;
		}
		// 获取类上面的Annotation，可能包含组合注解，故采用spring的工具类
		return AnnotatedElementUtils.findMergedAnnotation(specificMethod.getDeclaringClass(), annotationType);
	}

//	/**
//	 * 获取Annotation
//	 * @param handlerMethod HandlerMethod
//	 * @param annotationType 注解类
//	 * @param <A> 泛型标记
//	 * @return {Annotation}
//	 */
//	public <A extends Annotation> A getAnnotation(HandlerMethod handlerMethod, Class<A> annotationType) {
//		// 先找方法，再找方法上的类
//		A annotation = handlerMethod.getMethodAnnotation(annotationType);
//		if (null != annotation) {
//			return annotation;
//		}
//		// 获取类上面的Annotation，可能包含组合注解，故采用spring的工具类
//		Class<?> beanType = handlerMethod.getBeanType();
//		return AnnotatedElementUtils.findMergedAnnotation(beanType, annotationType);
//	}

	/**
	 *
	 * @Description: 判断是否是基础类型
	 *               注意：将枚举类型也当成了基础类型
	 * @time 2022年7月29日 下午4:05:19
	 * @author daydayup
	 * @param clazz
	 * @return
	 * boolean
	 * @throws
	 */
	public static boolean isBaseType(Class<?> clazz) {
		if (clazz.isPrimitive()) {
			return true;
		}

		if (clazz == Integer.class) {
            return true;
        } else if (clazz == Float.class) {
            return true;
        } else if (clazz == Long.class) {
            return true;
        } else if (clazz == Double.class) {
            return true;
        } else if (clazz == Byte.class) {
            return true;
        } else if (clazz == Boolean.class) {
            return true;
        } else if (clazz == String.class) {
            return true;
        }

	    return false;
	}

	public static List<Field> listDateTypeFields(Class clazz) {
		List<Field> dateTypeFieldList = new ArrayList();
		List<Field> allFieldList = getAllFields(clazz);
		for (Field oneField : allFieldList) {
			Class fieldType = oneField.getType();
			if (fieldType == Date.class) {
				dateTypeFieldList.add(oneField);
			}
		}

		return dateTypeFieldList;
	}

	@SuppressWarnings("unchecked")
	public static List<Class> getAllClassByInterface(Class c) {
		List returnClassList = new ArrayList<Class>();
		// 判断是不是接口,不是接口不作处理
		if (c.isInterface()) {
			Package pkg = c.getPackage();
			String packageName = "";
			if (pkg != null) {
				packageName = c.getPackage().getName(); // 获得当前包名
			} else {
				packageName = c.getName().substring(0, c.getName().lastIndexOf(".")); // 获得当前包名
			}
			try {
				List<Class> allClass = getClasses(packageName, c.getClassLoader());// 获得当前包以及子包下的所有类

				// 判断是否是一个接口
				for (int i = 0; i < allClass.size(); i++) {
					if (c.isAssignableFrom(allClass.get(i))) {
						if (!c.equals(allClass.get(i))) {
							returnClassList.add(allClass.get(i));
						}
					}
				}
			} catch (Exception e) {
				RuntimeException ex = new RuntimeException(
						"[ClassUtil getAllClassByInterface] getAllClassByInterface failed.");
				ex.initCause(e);
				throw ex;
			}
		}
		return returnClassList;
	}

	public static List<Class> getClasses(String packageName, ClassLoader classLoader)
			throws ClassNotFoundException, IOException {
		String path = packageName.replace(".", "/");
		Enumeration<URL> resources = classLoader.getResources(path);
		List<File> dirs = new ArrayList<File>();
		while (resources.hasMoreElements()) {
			URL resource = resources.nextElement();
			dirs.add(new File(resource.getFile()));
		}

		ArrayList<Class> classes = new ArrayList<Class>();
		for (File directory : dirs) {
			classes.addAll(findClass(directory, packageName, classLoader));
		}

		return classes;
	}

	private static List<Class> findClass(File directory, String packageName, ClassLoader classLoader)
			throws ClassNotFoundException {
		List<Class> classes = new ArrayList<Class>();
		if (!directory.exists()) {
			return classes;
		}
		File[] files = directory.listFiles();
		for (File file : files) {
			if (file.isDirectory()) {
				assert !file.getName().contains(".");
				classes.addAll(findClass(file, packageName + "." + file.getName(), classLoader));
			} else if (file.getName().endsWith(".class")) {
				classes.add(Class.forName(packageName + "." + file.getName().substring(0, file.getName().length() - 6),
						false, classLoader));
			}
		}
		return classes;
	}

	/**
	 * 判断类是否函数类.<br>
	 * 首先,类不能是抽象的,其次,类必须实现函数接口
	 *
	 * @param c
	 *            类
	 * @return 是否是函数类
	 */
	public static boolean isFunction(Class<?> c, Class<?> interfaceClazz) {
		if (c == null) {
			return false;
		}
		if (c.isInterface()) {
			return false;
		}
		if (Modifier.isAbstract(c.getModifiers())) {
			return false;// 抽象
		}
		// Class<?>[] interfaces = c.getInterfaces();
		// if (interfaces == null || interfaces.length == 0) {
		// return false;
		// }
		// for (Class<?> i : interfaces) {
		// if (i == IFunction.class) {
		// return true;
		// }
		// }
		return interfaceClazz.isAssignableFrom(c);
	}

	public static boolean isAnnotation(Class<? extends Annotation> ann, Class<?> c) {
		if (ann == null) {
			return false;
		}
		if (!c.isInterface()) {
			return false;
		}

		return c.isAnnotationPresent(ann);
	}

	/**
	 * 获取项目的path下所有的文件夹和文件
	 *
	 * @return 文件列表
	 */
	private static List<File> listPaths() {
		List<File> files = new ArrayList<File>();
		String jars = System.getProperty("java.class.path");
		if (jars == null) {
			logger.warn("[ClassUtil listPaths] java.class.path is null!");
			return files;
		} else {
			// web 容器下的类路径可能不同，查找 WEB-INF下的类文件
			logger.info("java.class.path:" + jars);
		}

		URL root = Thread.currentThread().getContextClassLoader().getResource("");// ClassUtil.class.getClassLoader().getResource("");
		if (root == null) {
			logger.error("path root is null!");
			return files;
		}
		String path = null;
		try {
			path = URLDecoder.decode(root.getFile(), "UTF-8");
		} catch (UnsupportedEncodingException e) {
			logger.error("[ClassUtil listPaths] decode the root file error:", e);
			return files;
		}

		File dir = new File(path);
		String[] array = (jars).split(";");
		if (array != null) {
			for (String s : array) {
				if (s == null) {
					continue;
				}
				File f = new File(s);
				if (f.exists()) {
					files.add(f);
				} else {
					// 有些jar就在系统目录下,省略了路径,要加上
					File jar = new File(dir, s);
					if (jar.exists()) {
						files.add(jar);
					}
				}
			}
		}

		return files;
	}

	/**
	 * 根据接口类，查找所有实现了指定接口的类
	 *
	 * @param pkg
	 *            包名,此处只是为了限定,防止漫无目的的查找.不用设置也可以,就要每找到一个类就要加载一次判断了
	 * @return 类列表
	 */
	public static List<Class<?>> getClassesByInterface(String pkg, Class<?> interfaceClazz) {
		List<Class<?>> list = new ArrayList<Class<?>>();
		for (File f : listPaths()) {
			// 如果是以文件的形式保存在服务器上
			if (f.isDirectory()) {
				// 获取包的物理路径
				String path = pkg.replace('.', File.separatorChar);
				dirWalker(interfaceClazz, path, f, list);
			} else {// 尝试是否是jar文件
				// 获取jar
				JarFile jar = null;
				try {
					jar = new JarFile(f);
				} catch (IOException e) {
					// 有可能不是一个jar
				}
				if (jar == null) {
					continue;
				}
				String path = pkg.replace('.', '/');
				// 从此jar包 得到一个枚举类
				Enumeration<JarEntry> entries = jar.entries();
				// 同样的进行循环迭代
				while (entries.hasMoreElements()) {
					// 获取jar里的一个实体 可以是目录 和一些jar包里的其他文件 如META-INF等文件
					JarEntry entry = entries.nextElement();
					String name = entry.getName();
					// 如果是以/开头的
					if (name.charAt(0) == '/') {
						// 获取后面的字符串
						name = name.substring(1);
					}
					// 如果前半部分和定义的包名相同
					if (name.contains(path)) {
						if (name.endsWith(".class") && !entry.isDirectory()) {
							name = name.replace("/", ".").substring(0, name.lastIndexOf("."));
							try {
								Class<?> c = Class.forName(name);
								if (isFunction(c, interfaceClazz)) {
									list.add(c);
								}
							} catch (Exception e) {
								// 找不到无所谓了
							}
						}
					}
				}
			}
		}

		return list;
	}


	/**
	 * 根据接口类，查找所有实现了指定接口的类
	 *
	 * @param pkg
	 *            包名,此处只是为了限定,防止漫无目的的查找.不用设置也可以,就要每找到一个类就要加载一次判断了
	 * @return 类列表
	 */
	public static List<Class<?>> getClassesByAnnotation(String pkg, Class<? extends Annotation> ann) {
		List<Class<?>> list = new ArrayList<Class<?>>();
		for (File f : listPaths()) {
			// 如果是以文件的形式保存在服务器上
			if (f.isDirectory()) {
				// 获取包的物理路径
				String path = pkg.replace('.', File.separatorChar);
				dirWalker2(ann, path, pkg, f, list);
			} else {// 尝试是否是jar文件
				// 获取jar
				JarFile jar = null;
				try {
					jar = new JarFile(f);
				} catch (IOException e) {
					// 有可能不是一个jar
				}
				if (jar == null) {
					continue;
				}
				String path = pkg.replace('.', '/');
				// 从此jar包 得到一个枚举类
				Enumeration<JarEntry> entries = jar.entries();
				// 同样的进行循环迭代
				while (entries.hasMoreElements()) {
					// 获取jar里的一个实体 可以是目录 和一些jar包里的其他文件 如META-INF等文件
					JarEntry entry = entries.nextElement();
					String name = entry.getName();
					// 如果是以/开头的
					if (name.charAt(0) == '/') {
						// 获取后面的字符串
						name = name.substring(1);
					}
					// 如果前半部分和定义的包名相同
					if (name.contains(path)) {
						if (name.endsWith(".class") && !entry.isDirectory()) {
							name = name.replace("/", ".").substring(0, name.lastIndexOf("."));
							try {
								Class<?> c = Class.forName(name);
								if (isAnnotation(ann, c)) {
									list.add(c);
								}
							} catch (Exception e) {
								// 找不到无所谓了
							}
						}
					}
				}
			}
		}

		return list;
	}

	/**
	 * 遍历文件夹下所有的类
	 *
	 * @param path
	 *            包路径
	 * @param file
	 *            文件
	 * @param list
	 *            保存类列表
	 */
	private static void dirWalker(Class<?> interfaceClazz, String path, File file, List<Class<?>> list) {
		if (file.exists()) {
			if (file.isDirectory()) {
				for (File f : file.listFiles()) {
					dirWalker(interfaceClazz, path, f, list);
				}
			} else {
				Class<?> c = loadClassByFile(interfaceClazz, path, file);
				if (c != null) {
					list.add(c);
				}
			}
		}
	}

	private static void dirWalker2(Class<? extends Annotation> ann, String path, String pkg, File file, List<Class<?>> list) {
		if (file.exists()) {
			if (file.isDirectory()) {
				for (File f : file.listFiles()) {
					dirWalker2(ann, path, pkg, f, list);
				}
			} else {
				Class<?> c = loadClassWithAnnotation(ann, path, pkg, file);
				if (c != null) {
					list.add(c);
				}
			}
		}
	}

	/**
	 * 从文件加载类
	 *
	 * @param pkg
	 *            包路径
	 * @param file
	 *            文件
	 * @return 类或者null
	 */
	private static Class<?> loadClassByFile(Class<?> interfaceClazz, String pkg, File file) {
		if (!file.isFile()) {
			return null;
		}
		String name = file.getName();
		if (name.endsWith(".class")) {
			String ap = file.getAbsolutePath();
			if (!ap.contains(pkg)) {
				return null;
			}
			name = ap.substring(ap.indexOf(pkg) + pkg.length());
			if (name.startsWith(File.separator)) {
				name = name.substring(1);
			}
			String path = (pkg + "." + name.substring(0, name.lastIndexOf("."))).replace(File.separatorChar, '.');
			try {
				Class<?> c = Class.forName(path);
				if (isFunction(c, interfaceClazz)) {
					return c;
				}
			} catch (ClassNotFoundException e) {
				// do nothing
			}
		}

		return null;
	}

	private static Class<?> loadClassWithAnnotation(Class<? extends Annotation> ann, String path2, String pkg, File file) {
		if (!file.isFile()) {
			return null;
		}
		String name = file.getName();
		if (name.endsWith(".class")) {
			String ap = file.getAbsolutePath();
			ap = ap.replace(File.separator, ".");
			if (!ap.contains(pkg)) {
				return null;
			}

			name = ap.substring(ap.indexOf(pkg) + pkg.length());
			if (name.startsWith(File.separator)) {
				name = name.substring(1);
			}
			String path = (pkg + "." + name.substring(0, name.lastIndexOf("."))).replace(File.separatorChar, '.');
			try {
				Class<?> c = Class.forName(path);
				if (isAnnotation(ann, c)) {
					return c;
				}
			} catch (ClassNotFoundException e) {
				// do nothing
			}
		}

		return null;
	}

	/**
	 *
	 * @Description: 获得某个类的所有声明的字段，即包括public、private和proteced
	 * @time 2020年8月13日 下午9:38:15
	 * @author daydayup
	 * @param clazz
	 * @return
	 * List<Field>
	 * @throws
	 */
	public static List<Field> getAllFields(Class<?> clazz) {
		List<Field> fieldList = new ArrayList();
		for(; clazz != Object.class ; clazz = clazz.getSuperclass()) {
			try {
				Field[] localFields = clazz.getDeclaredFields();
				for (Field oneField : localFields) {
					fieldList.add(oneField);
				}
			} catch (Exception e) {

			}
		}

		return fieldList;
	}

	public static Field getFieldByName(Class<?> clazz, String propertyName) {
		if (clazz == null || StrUtil.isBlank(propertyName)) {
			return null;
		}

		String key = clazz.getName() + "#" + propertyName;
		Field retField = cacheMap.get(key);
		if (retField != null) {
			return retField;
		}

		List<Field> optionFields = new ArrayList();

		List<Field> allFieldList = getAllFields(clazz);
		for(Field oneField : allFieldList) {
			if (oneField.getName().equals(propertyName)) {
				retField = oneField;
				optionFields.add(oneField);
				break;
			} else if (oneField.getName().equalsIgnoreCase(propertyName)) {
				optionFields.add(oneField);
			}
		}
		if (retField == null) {
			for(Field oneField : allFieldList) {
				if (oneField.getType() == boolean.class) {
					String tmpName = "is" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1);
					if (oneField.getName().equals(tmpName)) {
						retField = oneField;
						optionFields.add(oneField);
						break;
					} else if (oneField.getName().equalsIgnoreCase(tmpName)) {
						optionFields.add(oneField);
					}
				}
			}
		}

		if (retField != null) {
			cacheMap.putIfAbsent(key, retField);
			return retField;
		}
		if (optionFields.size() > 0) {
			logger.warn("未能在类:{} 中找到严格匹配属性名:{} 的字段对象，将返回一个疑似字段:{}", clazz, propertyName, optionFields.get(0).getName());
			cacheMap.putIfAbsent(key, optionFields.get(0));
			return optionFields.get(0);
		}

		return null;
	}

}