package com.uas.platform.b2b.manage.page.criteria;

import org.hibernate.criterion.MatchMode;
import org.springframework.util.StringUtils;

import javax.persistence.criteria.Path;
import java.util.Collection;

/**
 * 条件构造器 用于创建条件表达式
 * 
 */
public class PredicateUtils {

	/**
	 * 等于
	 * 
	 * @param param
	 * @param value 注意和modul对应字段的数据类型对应
	 * @param ignoreNull
	 * @return
	 */
	public static SimpleExpression eq(String param, Object value, boolean ignoreNull) {
		if (StringUtils.isEmpty(value)) {
            return null;
        }
		return new SimpleExpression(param, value, CriterionExpression.Operator.EQ);
	}

	/**
	 * 不等于
	 * 
	 * @param param
	 * @param value 注意和modul对应字段的数据类型对应
	 * @param ignoreNull
	 * @return
	 */
	public static SimpleExpression ne(String param, Object value, boolean ignoreNull) {
		if (ignoreNull && StringUtils.isEmpty(value)) {
            return null;
        }
		return new SimpleExpression(param, value, CriterionExpression.Operator.NE);
	}

	/**
	 * 模糊匹配
	 * 
	 * @param param
	 * @param value
	 * @param ignoreNull
	 * @return
	 */
	public static SimpleExpression like(String param, String value, boolean ignoreNull) {
		if (ignoreNull && StringUtils.isEmpty(value)) {
            return null;
        }
		return new SimpleExpression(param, value, CriterionExpression.Operator.LIKE);
	}
	
	/**
	 * 模糊匹配
	 * 
	 * @param param
	 * @param value
	 * @param ignoreNull
	 * @return
	 */
	public static SimpleExpression like(String param, String value, boolean ignoreNull, boolean ignoreCase) {
		if (ignoreNull && StringUtils.isEmpty(value)) {
            return null;
        }
		return new SimpleExpression(param, value, CriterionExpression.Operator.LIKE, ignoreCase);
	}

	/**
	 * 
	 * @param param
	 * @param value 注意和modul对应字段的数据类型对应
	 * @param matchMode
	 * @param ignoreNull
	 * @return
	 */
	public static SimpleExpression like(String param, String value, MatchMode matchMode, boolean ignoreNull) {
		if (ignoreNull && StringUtils.isEmpty(value)) {
            return null;
        }
		return new SimpleExpression(param, value, CriterionExpression.Operator.LIKE);
	}

	/**
	 * 大于
	 * 
	 * @param param
	 * @param value 注意和modul对应字段的数据类型对应
	 * @param ignoreNull
	 * @return
	 */
	public static SimpleExpression gt(String param, Object value, boolean ignoreNull) {
		if (ignoreNull && StringUtils.isEmpty(value)) {
            return null;
        }
		return new SimpleExpression(param, value, CriterionExpression.Operator.GT);
	}

	/**
	 * 小于
	 * 
	 * @param param
	 * @param value 注意和modul对应字段的数据类型对应
	 * @param ignoreNull
	 * @return
	 */
	public static SimpleExpression lt(String param, Object value, boolean ignoreNull) {
		if (ignoreNull && StringUtils.isEmpty(value)) {
            return null;
        }
		return new SimpleExpression(param, value, CriterionExpression.Operator.LT);
	}

	/**
	 * 大于等于
	 * 
	 * @param param
	 * @param value 注意和modul对应字段的数据类型对应
	 * @param ignoreNull
	 * @return
	 */
	public static SimpleExpression gte(String param, Object value, boolean ignoreNull) {
		if (ignoreNull && StringUtils.isEmpty(value)) {
            return null;
        }
		return new SimpleExpression(param, value, CriterionExpression.Operator.GTE);
	}

	/**
	 * 小于等于
	 * 
	 * @param param
	 * @param value 注意和modul对应字段的数据类型对应
	 * @param ignoreNull
	 * @return
	 */
	public static SimpleExpression lte(String param, Object value, boolean ignoreNull) {
		if (ignoreNull && StringUtils.isEmpty(value)) {
            return null;
        }
		return new SimpleExpression(param, value, CriterionExpression.Operator.LTE);
	}

	/**
	 * 为空
	 * 
	 * @param param
	 * @return
	 */
	public static SimpleExpression isNull(String param) {
		return new SimpleExpression(param, CriterionExpression.Operator.IS_NULL);
	}

	/**
	 * 不为空
	 * 
	 * @param param
	 * @return
	 */
	public static SimpleExpression isNotNull(String param) {
		return new SimpleExpression(param, CriterionExpression.Operator.IS_NOT_NULL);
	}

	/**
	 * 并且
	 * 
	 * @param expressions
	 * @return
	 */
	public static LogicalExpression and(CriterionExpression... expressions) {
		return new LogicalExpression(expressions, CriterionExpression.Operator.AND);
	}

	/**
	 * 或者
	 * 
	 * @param expressions
	 * @return
	 */
	public static LogicalExpression or(CriterionExpression... expressions) {
		return new LogicalExpression(expressions, CriterionExpression.Operator.OR);
	}

	/**
	 * 包含于
	 * 
	 * @param param
	 * @param value
	 * @return
	 */
	@SuppressWarnings("rawtypes")
	public static LogicalExpression in(String param, Collection value, boolean ignoreNull) {
		if (ignoreNull && (value == null || value.isEmpty())) {
			return null;
		}
		SimpleExpression[] ses = new SimpleExpression[value.size()];
		int i = 0;
		for (Object obj : value) {
			ses[i] = new SimpleExpression(param, obj, CriterionExpression.Operator.EQ);
			i++;
		}
		return new LogicalExpression(ses, CriterionExpression.Operator.OR);
	}

	/**
	 * 包含于
	 * 
	 * @param param
	 * @param values
	 * @return
	 */
	public static LogicalExpression in(String param, Object[] values, boolean ignoreNull) {
		if (ignoreNull && (values == null || values.length == 0)) {
			return null;
		}
		SimpleExpression[] ses = new SimpleExpression[values.length];
		int i = 0;
		for (Object obj : values) {
			ses[i] = new SimpleExpression(param, obj, CriterionExpression.Operator.EQ);
			i++;
		}
		return new LogicalExpression(ses, CriterionExpression.Operator.OR);
	}

	@SuppressWarnings("unchecked")
	public static <T, R> Path<R> getPath(Path<T> root, String path, Class<R> resultType) {
		String[] pathElements = path.split("\\.");
		Path<?> retVal = root;
		for (String pathEl : pathElements) {
			retVal = (Path<R>) retVal.get(pathEl);
		}
		return (Path<R>) retVal;
	}
}
