package me.zhengjie.base.plus;


import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.apache.commons.lang3.ArrayUtils;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.util.ObjectUtils;
import org.springframework.util.ReflectionUtils;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import me.zhengjie.dao.mybatis.entity.ContractOrderEntity;

/**
 * @Description 拼接查询条件工具类
 */
public class QueryWrapperUtil {
	/**
	 * 得到父类的对象
	 * 
	 * @param <T>   查询的泛型
	 * @param clazz
	 * @return
	 */
	public static <T> List<Field> reflectForField(Class<T> clazz) {
		Class<?> tmpClazz = clazz;
		List<Field> fieldList = new ArrayList<>();
		while (tmpClazz != null) {
			fieldList.addAll(Arrays.asList(tmpClazz.getDeclaredFields()));
			tmpClazz = tmpClazz.getSuperclass();
		}
		return fieldList;
	}

	/**
	 * 拼接查询条件
	 *
	 * @param obj 数据实体
	 * @return void 返回参数说明
	 * @exception/throws
	 */
	public static <T> QueryWrapper<T> convertQuery(Object obj, JSONObject... jsonObj) {
		JSONObject param = new JSONObject();
		if (ArrayUtils.isNotEmpty(jsonObj)) {
			param = jsonObj[0];
		}
		QueryWrapper<T> queryWrapper = new QueryWrapper<>();
		Class<?> clazz = obj.getClass();
		try {
			// TODO 这里应该通过共有方法来进行反射
			for (Field field : reflectForField(clazz)) {

				// 抑制Java对修饰符的检查
//				field.setAccessible(true);
				// 获取属性值
//				Object fieldValue = field.get(obj);
//            String fieldValue = getFieldValue(obj ,field.getName()).toString();
				TableField tableField = AnnotationUtils.getAnnotation(field, TableField.class);
				// 字段没有TableField这个注解和有这个主机上false的
				if (ObjectUtils.isEmpty(tableField) || !tableField.exist()) {
					continue;
				}
				// String methodName = "set" + filedName.substring(0, 1).toUpperCase() +
				// filedName.substring(1);
				// 获取属性名
				String name = field.getName();
				// 声明属性描述对象
//				PropertyDescriptor propertyDescriptor = new PropertyDescriptor(name, clazz);
//				Method method = clazz.getDeclaredMethod(propertyName);
				// 获取getter方法
//				Method method = propertyDescriptor.getReadMethod();
				String getMethod = getMethod(name);
				Method method = ReflectionUtils.findMethod(clazz, getMethod);
				Object fieldValue = method.invoke(obj);
				String fieldName = tableField.value();
				// 默认是相等
				QueryWapper queryWapperAnnotation = AnnotationUtils.getAnnotation(field, QueryWapper.class);

				if (ObjectUtils.isEmpty(queryWapperAnnotation)) {
					queryWrapper.eq(!ObjectUtils.isEmpty(fieldValue), fieldName, fieldValue);
				} else {
					// 获取枚举
					QueryKeyword[] queryWapperEnums = queryWapperAnnotation.value();
					for (QueryKeyword queryWapperEnum : queryWapperEnums) {
						// 拼接查询条件
						switch (queryWapperEnum) {
						case NE:
							queryWrapper.ne(!ObjectUtils.isEmpty(fieldValue), fieldName, fieldValue);
							break;
						// 这里需要，修改为集合
						case IN:
							if (fieldValue != null && fieldValue.toString().contains(",")) {
								List<String> result = Arrays.asList(fieldValue.toString().split(","));
								queryWrapper.in(!ObjectUtils.isEmpty(fieldValue), fieldName, result);
							}
							break;
						case GT:
							queryWrapper.gt(!ObjectUtils.isEmpty(fieldValue), fieldName, fieldValue);
							break;
						case GE:
							queryWrapper.ge(!ObjectUtils.isEmpty(fieldValue), fieldName, fieldValue);
							break;
						case LT:
							queryWrapper.lt(!ObjectUtils.isEmpty(fieldValue), fieldName, fieldValue);
							break;
						case LE:
							queryWrapper.le(!ObjectUtils.isEmpty(fieldValue), fieldName, fieldValue);
							break;
						case LIKE:
							queryWrapper.like(!ObjectUtils.isEmpty(fieldValue), fieldName, fieldValue);
							break;
						case NOT_LIKE:
							queryWrapper.notLike(!ObjectUtils.isEmpty(fieldValue), fieldName, fieldValue);
							break;
						case LIKE_LEFT:
							queryWrapper.likeLeft(!ObjectUtils.isEmpty(fieldValue), fieldName, fieldValue);
							break;
						case LIKE_RIGHT:
							queryWrapper.likeRight(!ObjectUtils.isEmpty(fieldValue), fieldName, fieldValue);
							break;
						case DESC:
							queryWrapper.orderByDesc(fieldName);
							break;
						case ASC:
							queryWrapper.orderByAsc(fieldName);
							break;
						case RANGE:
							// 设置开始的值和结束的值
							String[] attribute = queryWapperAnnotation.attribute();
							String startRange = attribute[0];
							// 声明属性描述对象
							getMethod = getMethod(startRange);
							method = ReflectionUtils.findMethod(clazz, getMethod);
							if (method != null) {
								Object val = method.invoke(obj);
								if (!ObjectUtils.isEmpty(val)) {
									queryWrapper.ge(fieldName, val);
								}
							}
							// 得到开始的属性值，通过反射设置属性值
//							Field startRange = clazz.getDeclaredField(attribute[0]);
//							startRange.setAccessible(true);
//							Object val = startRange.get(obj);
							// 结束的属性值，通过反射设置属性值
							String endRange = attribute[1];
							getMethod = getMethod(endRange);
							// 获取getter方法
							method = ReflectionUtils.findMethod(clazz, getMethod);
							if (method != null) {
								Object val = method.invoke(obj);
								if (!ObjectUtils.isEmpty(val)) {
									queryWrapper.le(fieldName, val);
								}
							}
							// ---属性值查询结束的值----
							// 通过传入的参数查询值
							// 然后通过参数查询
							Object val = param.get(attribute[0]);
							if (!ObjectUtils.isEmpty(val)) {
								queryWrapper.ge(fieldName, val);
							}
							// 然后通过参数查询
							val = param.get(attribute[1]);
							if (!ObjectUtils.isEmpty(val)) {
								queryWrapper.le(fieldName, val);
							}
							break;
						default:
							break;
						}
					}

				}

			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return queryWrapper;

	}

	public static String setMethod(String filedName) {
		String alpha = filedName.substring(0, 1).toUpperCase();
		String methodName = "set" + alpha + filedName.substring(1);
		return methodName;
	}

	public static String getMethod(String filedName) {
		String alpha = filedName.substring(0, 1).toUpperCase();
		String methodName = "get" + alpha + filedName.substring(1);
		return methodName;
	}

	/**
	 * 获取属性名
	 *
	 * @exception/throws
	 */
//	private static String getFieldValue(Object owner, String fieldName) {
//		try {
//			return invokeMethod(owner, fieldName, null).toString();
//		} catch (Exception e) {
//			e.printStackTrace();
//		}
//		return null;
//	}

	public static void main(String[] args) {
		ContractOrderEntity cc = new ContractOrderEntity();
	//	cc.setStartDatea("fdsafdsa");
//		convertQuery(cc);

		Method m = ReflectionUtils.findMethod(ContractOrderEntity.class, "f");
		System.out.println(m);
	}
}