package org.sxkj.common.query;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.enums.SqlKeyword;

import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.Collection;

public class QueryUtils<T> {
	/**
	 * 解析实体类字段的注解，动态构建查询条件
	 */
	public static <T> QueryWrapper<T> buildQueryConditions(QueryWrapper<T> queryWrapper, Object paramObj) {
		Class<?> clazz = paramObj.getClass();
		for (Field field : clazz.getDeclaredFields()) {
			QueryCondition queryCondition = field.getAnnotation(QueryCondition.class);
			if (queryCondition == null) {
				continue;
			}
			field.setAccessible(true);
			try {
				SqlKeyword sqlKeyWord = queryCondition.type();
				Object value = field.get(paramObj);
				if (queryCondition.ignore() ||
					(value == null
						&& !Arrays.asList(SqlKeyword.IS_NULL, SqlKeyword.IS_NOT_NULL,
							SqlKeyword.EXISTS, SqlKeyword.NOT_EXISTS)
						.contains(sqlKeyWord))) {
					continue;
				}
				String column = queryCondition.column().isEmpty() ? field.getName().replaceAll("([a-z])([A-Z])", "$1_$2").toLowerCase()
					: queryCondition.column();

				applyCondition(queryWrapper, column, value, sqlKeyWord);

			} catch (IllegalAccessException e) {
				throw new RuntimeException("Failed to apply query condition for field: " + field.getName(), e);
			}
		}
		return queryWrapper;
	}

	/**
	 * 应用查询条件，完全适配SqlKeyword枚举类型
	 */
	private static <T> void applyCondition(QueryWrapper<T> queryWrapper, String column,
										   Object value, SqlKeyword conditionType) {
		switch (conditionType) {
			// 等于
			case EQ:
				queryWrapper.eq(column, value);
				break;
			// 不等于
			case NE:
				queryWrapper.ne(column, value);
				break;
			// 大于
			case GT:
				queryWrapper.gt(column, value);
				break;
			// 小于
			case LT:
				queryWrapper.lt(column, value);
				break;
			// 大于等于
			case GE:
				queryWrapper.ge(column, value);
				break;
			// 小于等于
			case LE:
				queryWrapper.le(column, value);
				break;
			// 全模糊匹配
			case LIKE:
				queryWrapper.like(column, value);
				break;

			// 不匹配
			case NOT_LIKE:
				queryWrapper.notLike(column, value);
				break;
			// IN查询
			case IN:
				if (value instanceof Collection && !((Collection<?>) value).isEmpty()) {
					queryWrapper.in(column, (Collection<?>) value);
				}
				break;
			// NOT IN查询
			case NOT_IN:
				if (value instanceof Collection && !((Collection<?>) value).isEmpty()) {
					queryWrapper.notIn(column, (Collection<?>) value);
				}
				break;
			// BETWEEN查询
			case BETWEEN:
				if (value instanceof Collection && ((Collection<?>) value).size() == 2) {
					Object[] betweenValues = ((Collection<?>) value).toArray();
					if (betweenValues[0] != null && betweenValues[1] != null) {
						queryWrapper.between(column, betweenValues[0], betweenValues[1]);
					}
				}
				break;
			// NOT BETWEEN查询
			case NOT_BETWEEN:
				if (value instanceof Collection && ((Collection<?>) value).size() == 2) {
					Object[] betweenValues = ((Collection<?>) value).toArray();
					if (betweenValues[0] != null && betweenValues[1] != null) {
						queryWrapper.notBetween(column, betweenValues[0], betweenValues[1]);
					}
				}
				break;
			// IS NULL
			case IS_NULL:
				queryWrapper.isNull(column);
				break;
			// IS NOT NULL
			case IS_NOT_NULL:
				queryWrapper.isNotNull(column);
				break;
			// EXISTS (需要特殊处理，value应为子查询)
			case EXISTS:
				if (value instanceof String) {
					queryWrapper.exists((String) value);
				}
				break;
			// NOT EXISTS (需要特殊处理，value应为子查询)
			case NOT_EXISTS:
				if (value instanceof String) {
					queryWrapper.notExists((String) value);
				}
				break;
			// 默认等于条件
			default:
				queryWrapper.eq(column, value);
		}
	}

}