package org.springside.core.commons;

import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.criterion.CriteriaSpecification;
import org.springframework.util.Assert;
import org.springframework.util.CollectionUtils;
import org.springside.core.commons.support.CriteriaSetup;
import org.springside.core.commons.support.page.CriteriaPage;
import org.springside.core.commons.support.page.HqlPage;
import org.springside.core.commons.support.page.Page;

import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * SpringSide Hibernate Entity Dao基类.
 * 带SpringSide扩展的分页函数,具体的分页代码在Page类中.
 *
 * @author calvin
 * @author ajax
 * @see AbstractHibernateDao
 * @see HqlPage
 * @see CriteriaPage
 */
abstract public class BaseHibernateDao<T> extends AbstractHibernateDao<T> {

    public static int COUNT_MODE = 1;
    public static int SCROLL_MODE = 2;
    public static int LIST_MODE = 3;

    /**
     * 根据Map中过滤条件和分页参数进行分页查询.
     *
     * @param filterMap 过滤条件.
     * @param pageNo    当前页码
     * @param pageSize  每页显示记录数.
     */
    public Page findBy(Map filterMap, int pageNo, int pageSize) {
        return findBy(filterMap, null, pageNo, pageSize);
    }

    /**
     * 根据Map中过滤条件,排序条件和分页参数进行分页查询.
     *
     * @param filterMap 过滤条件.
     * @param orderMap  排序条件.
     * @param pageNo    当前页码
     * @param pageSize  每页显示记录数.
     */
    public Page findBy(Map filterMap, Map orderMap, int pageNo, int pageSize, CriteriaSetup criteriaSetup) {
        Criteria criteria = getSession().createCriteria(getEntityClass());

        if (!CollectionUtils.isEmpty(filterMap)) {
            try {
                criteriaSetup.setup(criteria, filterMap);
            } catch (Exception e) {
            }
        }

        if (!CollectionUtils.isEmpty(orderMap))
            sortCriteria(criteria, orderMap, null);

        criteria.setResultTransformer(CriteriaSpecification.ROOT_ENTITY);

        return pagedQuery(criteria, pageNo, pageSize);
    }

    public Page findBy(Map filterMap, Map orderMap, int pageNo, int pageSize) {
        return findBy(filterMap, orderMap, pageNo, pageSize, getDefaultCriteriaSetup());
    }

    /**
     * Criteria分页查询，默认count模式
     */
    public Page pagedQuery(Criteria criteria, int pageNo, int pageSize) {
        return pagedQuery(criteria, pageNo, pageSize, COUNT_MODE);
    }

    /**
     * Criteria分页查询，可以指定jdbc是否支持scroll
     */
    public Page pagedQuery(Criteria criteria, int pageNo, int pageSize, int mode) {
        return CriteriaPage.getPageInstance(criteria, pageNo, pageSize, mode);
    }

    /**
     * HQL分页查询，默认count的方式
     */
    public Page pagedQuery(String hql, int pageNo, int pageSize, Object... args) {
        return pagedQuery(hql, pageNo, pageSize, COUNT_MODE, args);
    }

    /**
     * HQL分页查询,可以指定具体的模式,
     * 如果是Count方式,须在此层完成hsql的转换与查询。
     */
    public Page pagedQuery(String hql, int pageNo, int pageSize, int mode, Object... args) {
        Assert.hasText(hql);
        Query query = getSession().createQuery(hql);
        for (int i = 0; i < args.length; i++) {
            query.setParameter(i, args[i]);
        }
        if (mode == COUNT_MODE) {
            String countQueryString = " select count (*) " + removeSelect(removeOrders(hql));
            List countlist = getHibernateTemplate().find(countQueryString, args);
            int totalCount = (Integer) countlist.get(0);
            return HqlPage.getPageInstanceByCount(query, pageNo, pageSize, totalCount);
        } else
            return HqlPage.getPageInstance(query, pageNo, pageSize, mode);
    }

    /**
     * 去除select 子句，未考虑union的情况
     */
    private static String removeSelect(String hql) {
        Assert.hasText(hql);
        int beginPos = hql.toLowerCase().indexOf("from");
        Assert.isTrue(beginPos != -1, " hql : " + hql + " must has a keyword 'from'");
        return hql.substring(beginPos);
    }

    /**
     * 去除orderby 子句
     */
    private 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();
    }

}