package com.casic.PgInterface.core.hibernate;

import com.casic.PgInterface.core.util.BeanUtils;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.criterion.*;
import org.hibernate.internal.CriteriaImpl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.Assert;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Locale;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * hibernate utils.
 * 
 * @author Lingo
 */
public class HibernateUtils {
    /** logger. */
    private static Logger logger = LoggerFactory
            .getLogger(HibernateUtils.class);

    /** protected constructor. */
    protected HibernateUtils() {
    }

    /**
     * get number for count.
     * 
     * @param result
     *            Object
     * @return Integer
     */
    public static Integer getNumber(Object result) {
        if (result == null) {
            return 0;
        } else {
            return ((Number) result).intValue();
        }
    }

    /**
     * 去除hql的select 子句，未考虑union的情况,用于pagedQuery.
     * 
     * @param hql
     *            HQL字符串
     * @return 删除select语句后的字符串
     * @see HibernatePagingDao#pagedQuery(String,int,int,Object[])
     */
    public static String removeSelect(String hql) {
        Assert.hasText(hql);

        if (hql.toLowerCase(Locale.ENGLISH).indexOf("distinct") != -1) {
            logger.warn(
                    "there is a distinct in paged query hql : [{}], this maybe cause an unexpected result",
                    hql);
        }

        int beginPos = hql.toLowerCase(Locale.CHINA).indexOf("from");
        Assert.isTrue(beginPos != -1, " hql : " + hql
                + " must has a keyword 'from'");

        return hql.substring(beginPos);
    }

    /**
     * 去除hql的order by 子句，用于pagedQuery.
     * 
     * @param hql
     *            HQL字符串
     * @return 删除排序语句后的字符串
     * @see HibernatePagingDao#pagedQuery(String,int,int,Object[])
     */
    public static String removeOrders(String hql) {
        Assert.hasText(hql);

        Pattern p = Pattern.compile("order\\s*by[\\w|\\W|\\s|\\S]*",
                Pattern.CASE_INSENSITIVE);
        Matcher m = p.matcher(hql);
        StringBuffer sb = new StringBuffer();

        while (m.find()) {
            m.appendReplacement(sb, "");
        }

        m.appendTail(sb);

        return sb.toString();
    }

    /**
     * distinct.
     * 
     * @param query
     *            Query
     * @return Query
     */
    public static Query distinct(Query query) {
        query.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);

        return query;
    }

    /**
     * distinct.
     * 
     * @param criteria
     *            Criteria
     * @return Criteria
     */
    public static Criteria distinct(Criteria criteria) {
        criteria.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);

        return criteria;
    }

    /**
     * find projection from criteria.
     * 
     * @param criteria
     *            Criteria
     * @return Projection
     */
    public static Projection findProjection(Criteria criteria) {
        if (criteria instanceof CriteriaImpl) {
            return ((CriteriaImpl) criteria).getProjection();
        } else {
            throw new IllegalArgumentException(criteria
                    + " is not a CriteriaImpl");
        }
    }

    /**
     * find order entries.
     * 
     * @param criteria
     *            Criteria
     * @return List
     */
    public static List findOrderEntries(Criteria criteria) {
        return (List) BeanUtils.safeGetFieldValue(criteria, "orderEntries");
    }

    /**
     * set order entries.
     * 
     * @param criteria
     *            Criteria
     * @param orderEntries
     *            List
     */
    public static void setOrderEntries(Criteria criteria, List orderEntries) {
        BeanUtils.safeSetFieldValue(criteria, "orderEntries", orderEntries);
    }

    /**
     * 按属性条件参数创建Criterion,辅助函数.
     * 
     * @param propertyName
     *            String
     * @param propertyValue
     *            Object
     * @param matchType
     *            MatchType
     * @return Criterion
     */
    public static Criterion buildCriterion(String propertyName,
            Object propertyValue, MatchType matchType) {
        Assert.hasText(propertyName, "propertyName不能为空");

        Criterion criterion = null;

        // 根据MatchType构造criterion
        switch (matchType) {
        case EQ:
            criterion = Restrictions.eq(propertyName, propertyValue);

            break;

        case LIKE:
            criterion = Restrictions.like(propertyName, (String) propertyValue,
                    MatchMode.ANYWHERE);

            break;

        case LE:
            criterion = Restrictions.le(propertyName, propertyValue);

            break;

        case LT:
            criterion = Restrictions.lt(propertyName, propertyValue);

            break;

        case GE:
            criterion = Restrictions.ge(propertyName, propertyValue);

            break;

        case GT:
            criterion = Restrictions.gt(propertyName, propertyValue);

            break;

        case IN:
            criterion = Restrictions.in(propertyName,
                    (Collection) propertyValue);

            break;

        default:
            criterion = Restrictions.eq(propertyName, propertyValue);

            break;
        }

        return criterion;
    }

    /**
     * 按属性条件列表创建Criterion数组,辅助函数.
     * 
     * @param filters
     *            List
     * @return Criterion[]
     */
    public static Criterion[] buildCriterion(List<PropertyFilter> filters) {
        List<Criterion> criterionList = new ArrayList<Criterion>();

        for (PropertyFilter filter : filters) {
            // 只有一个属性需要比较的情况.
            if (!filter.hasMultiProperties()) {
                Criterion criterion = buildCriterion(filter.getPropertyName(),
                        filter.getMatchValue(), filter.getMatchType());
                criterionList.add(criterion);
            } else {
                // 包含多个属性需要比较的情况,进行or处理.
                Disjunction disjunction = Restrictions.disjunction();

                for (String param : filter.getPropertyNames()) {
                    Criterion criterion = buildCriterion(param,
                            filter.getMatchValue(), filter.getMatchType());
                    disjunction.add(criterion);
                }

                criterionList.add(disjunction);
            }
        }

        return criterionList.toArray(new Criterion[criterionList.size()]);
    }

    public static void buildQuery(StringBuilder buff,
            PropertyFilter propertyFilter) {
        if (buff.toString().toLowerCase().indexOf("where") == -1) {
            buff.append(" where ");
        } else {
            buff.append(" and ");
        }

        buff.append(propertyFilter.getPropertyName());

        switch (propertyFilter.getMatchType()) {
        case EQ:
            buff.append(" =:");

            break;

        case LIKE:
            buff.append(" like:");

            break;

        case LE:
            buff.append(" <=:");

            break;

        case LT:
            buff.append(" <:");

            break;

        case GE:
            buff.append(" >=:");

            break;

        case GT:
            buff.append(" >:");

            break;

        case IN:
            buff.append(" in :");

            break;

        default:
            buff.append(" =:");

            break;
        }

        buff.append(propertyFilter.getPropertyName().replaceAll("\\.", "_"));
    }
}
