package com.chinaztt.mes.common.wrapper;

import cn.hutool.core.collection.CollectionUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import lombok.AllArgsConstructor;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;


/**
 * @Author: zhangxy
 * @Date: 2020-09-12 10:25
 */
@Component
@AllArgsConstructor
public class QueryWrapperUtil {

	private static final String ASC = "asc";
	private static final String DIRECTION = "direction";

	private static final DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

	private static final List<Class> EQ_CLAZZ = Arrays.asList(Long.class, Integer.class, Boolean.class, BigDecimal.class, Double.class);

	private static final List<Class> LIKE_CLAZZ = Arrays.asList(String.class);


	private ResultMapHelper resultMapHelper;

	private static ResultMapHelper staticResultMapHelper;

	/**
	 * 生成mybatis-plus查询条件
	 *
	 * @param entity
	 * @param <T>
	 * @return
	 */
	public static <T> QueryWrapper<T> gen(T entity) {
		QueryWrapper qw = Wrappers.<T>query();
		try {
			Class cls = entity.getClass();
			Field[] fields = getAllFields(entity);
			for (Field field : fields) {
				field.setAccessible(true);
				String name = field.getName();
				if (Modifier.isStatic(field.getModifiers())) {
					continue;
				}
				Object value = field.get(entity);
				if (value != null && StringUtils.isNotEmpty(value.toString())) {
					if ("criteria".equals(name)) {
						JSONObject criteriaJo = (JSONObject) JSON.parse(value.toString());
						if (criteriaJo.isEmpty()) {
							continue;
						}
						Iterator<String> it = criteriaJo.keySet().iterator();
						while (it.hasNext()) {
							String key = it.next();
							if ("dateTimeFilters".equals(key)) {
								dateTimeWrapper(qw, criteriaJo.get(key), cls);
							} else if ("multiSearchFilter".equals(key)) {
								multiSearchWrapper(qw, criteriaJo.get(key), cls);
							} else if ("orderBy".equals(key)) {
								orderByWrapper(qw, criteriaJo.get(key), cls);
							}
						}
					} else {
						customWrapper(qw, field, value, name, cls);
					}
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}

		/**
		 * 解决mybatis-plus bug ：只有排序条件时，isEmptyOfWhere = true
		 */
		if (qw.isEmptyOfWhere() && StringUtils.isNotEmpty(qw.getSqlSegment())) {
			qw.eq("1", 1);
		}
		return qw;
	}


	/**
	 * descColumn倒序排列
	 *
	 * @param entity
	 * @param descColumn
	 * @param <T>
	 * @return
	 */
	public static <T> QueryWrapper<T> gen(T entity, String descColumn) {
		return gen(entity).orderByDesc(descColumn);
	}


	/**
	 * 排序
	 *
	 * @param qw
	 * @param value
	 * @param cls
	 */
	private static void orderByWrapper(QueryWrapper qw, Object value, Class cls) {
		JSONObject obj = (JSONObject) JSON.parse(value.toString());
		if (obj.isEmpty()) {
			return;
		}
		String column = getColumnName(obj.getString("column"), cls);
		if (StringUtils.isEmpty(column)) {
			throw new RuntimeException("排序字段不存在，请检查拼写");
		}
		if (ASC.equals(obj.getString(DIRECTION))) {
			qw.orderByAsc(column);
		} else {
			qw.orderByDesc(column);
		}
	}


	/**
	 * 普通搜索
	 *
	 * @param qw
	 * @param field
	 * @param value
	 * @param fieldName
	 */
	private static void customWrapper(QueryWrapper qw, Field field, Object value, String fieldName, Class cls) {
		String columnName = getColumnName(fieldName, cls);
		Class type = field.getType();
		if (EQ_CLAZZ.contains(type)) {
			qw.eq(columnName, value);
		} else if (LIKE_CLAZZ.contains(type)) {
			qw.like(columnName, value);
		}
	}

	/**
	 * 时间搜索
	 *
	 * @param qw
	 * @param value
	 * @param cls
	 */
	private static void dateTimeWrapper(QueryWrapper qw, Object value, Class cls) {
		JSONObject obj = (JSONObject) JSON.parse(value.toString());
		Set<String> keys = obj.keySet();
		if (CollectionUtil.isNotEmpty(keys)) {
			for (String key : keys) {
				String columnName = getColumnName(key, cls);
				JSONArray timeRange = (JSONArray) obj.get(key);
				if (timeRange.get(0) != null) {
					qw.ge(columnName, LocalDateTime.parse((CharSequence) timeRange.get(0), FORMATTER));
				}
				if (timeRange.get(1) != null) {
					qw.lt(columnName, LocalDateTime.parse((CharSequence) timeRange.get(1), FORMATTER));
				}
			}
		}
	}


	/**
	 * 高级搜索
	 *
	 * @param qw
	 * @param multiSearchFilter
	 * @param cls
	 * @param <T>
	 */
	public static <T> void multiSearchWrapper(QueryWrapper<T> qw, Object multiSearchFilter, Class cls) {
		JSONObject filter = JSON.parseObject(multiSearchFilter.toString());
		if (filter == null || filter.size() == 0) {
			return;
		}
		FilterOperator groupOperator = FilterOperator.valueOf(filter.getString("groupOp"));
		JSONArray rules = filter.getJSONArray("rules");
		if (rules == null || rules.size() == 0) {
			return;
		}
		Iterator it = rules.iterator();

		qw.and(multiQw -> {
			while (it.hasNext()) {
				iterateCondition(cls, groupOperator, it, multiQw);
			}
		});

	}

	private static <T> void iterateCondition(Class cls, FilterOperator groupOperator, Iterator it, QueryWrapper<T> multiQw) {
		JSONObject rule = JSON.parseObject(it.next().toString());
		String column = getColumnName(rule.getString("name"), cls);
		FilterOperator operator = FilterOperator.valueOf(rule.getString("op"));
		Object value = rule.get("value");

		switch (operator) {
			case EQ:
				multiQw.eq(column, value);
				break;
			case NE:
				multiQw.ne(column, value);
				break;
			case LE:
				multiQw.le(column, value);
				break;
			case LT:
				multiQw.lt(column, value);
				break;
			case GE:
				multiQw.ge(column, value);
				break;
			case GT:
				multiQw.gt(column, value);
				break;
			case CN:
				multiQw.like(column, value);
				break;
			case BW:
				multiQw.likeRight(column, value);
				break;
			case EW:
				multiQw.likeLeft(column, value);
				break;
			case IN:
				multiQw.inSql(column, value.toString());
				break;
			case ISNULL:
				multiQw.isNull(column);
				break;
			case NOTNULL:
				multiQw.isNotNull(column);
				break;
			default:
				throw new IllegalStateException("Unknown filter operator=" + operator);
		}
		if (it.hasNext() && groupOperator.equals(FilterOperator.OR)) {
			multiQw.or();
		}
	}

	public static String getColumnName(String fieldName, Class clazz) {
		Map<Class, Map<String, String>> map = staticResultMapHelper.getColumnMaps();
		Map<String, String> fieldMaps = map.get(clazz);
		if (fieldMaps == null) {
			throw new RuntimeException("没有找到对应的mapper映射，请检查！");
		}
		return fieldMaps.get(fieldName);
	}


	private static <T> Field[] getAllFields(T object) {
		Class clazz = object.getClass();
		List<Field> fieldList = new ArrayList<>();
		while (clazz != null) {
			fieldList.addAll(new ArrayList<>(Arrays.asList(clazz.getDeclaredFields())));
			clazz = clazz.getSuperclass();
		}
		Field[] fields = new Field[fieldList.size()];
		fieldList.toArray(fields);
		return fields;
	}

	@PostConstruct
	public void init() {
		QueryWrapperUtil.staticResultMapHelper = resultMapHelper;
	}

}