package com.walker.jdbc.dao;

import com.walker.db.DatabaseType;
import com.walker.db.page.GenericPager;
import com.walker.db.page.ListPageContext;
import com.walker.db.page.PageSearch;
import com.walker.infrastructure.utils.StringUtils;
import org.springframework.jdbc.core.BatchPreparedStatementSetter;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;

import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class SqlDaoSupport extends JdbcDaoImpl{

    @Override
    public void update(String sql){
        assert(StringUtils.isNotEmpty(sql));
        this.getJdbcTemplate().update(sql);
    }

    @Override
    public int update(String sql, Object[] args){
        assert(StringUtils.isNotEmpty(sql));
        return this.getJdbcTemplate().update(sql, args);
    }

    @Override
    public <T> List<T> sqlQuery(String sql, RowMapper<T> rowMapper){
        return sqlQuery(sql, null, rowMapper);
    }
    @Override
    public <T> List<T> sqlQuery(String sql, Object[] args, RowMapper<T> rowMapper){
        assert (StringUtils.isNotEmpty(sql));
        assert (rowMapper != null);
        return this.getJdbcTemplate().query(sql, rowMapper, args);
    }

    /**
     * 返回map集合记录，不再依赖hibernate
     * @param sql
     * @param args
     * @return
     */
    @Override
    public List<Map<String, Object>> sqlQueryListMap(String sql, Object[] args){
        return this.getJdbcTemplate().queryForList(sql, args);
    }

    /**
     * 通过动态泛型的形式，给定返回对象类型。这样就可以在每个DAO中随时使用。
     * @param sql
     * @param args
     * @param rowMapper
     * @return
     */
    @Override
    public <E> GenericPager<E> sqlGeneralQueryPager(String sql, Object[] args, RowMapper<E> rowMapper){
        // 2023-04-01 前后端界面使用:PageSearch分页参数，如果存在优先使用。
        PageSearch pageSearch = ListPageContext.getPageSearch();
        if(pageSearch != null){
            return sqlGeneralQueryPager(sql, args, rowMapper
                    , pageSearch.getPageIndex()
                    , pageSearch.getPageSize());
        } else {
            return sqlGeneralQueryPager(sql, args, rowMapper
                    , ListPageContext.getCurrentPageIndex()
                    , ListPageContext.getCurrentPageSize());
        }
//        return sqlGeneralQueryPager(sql, args, rowMapper
//                , ListPageContext.getCurrentPageIndex()
//                , ListPageContext.getCurrentPageSize());
    }

    @Override
    public <E> GenericPager<E> sqlGeneralQueryPager(String sql, Object[] args, RowMapper<E> rowMapper
            , int pageIndex){
        // 2023-04-01 前后端界面使用:PageSearch分页参数，如果存在优先使用。
        PageSearch pageSearch = ListPageContext.getPageSearch();
        if(pageSearch != null){
            return this.sqlGeneralQueryPager(sql, args, rowMapper, pageIndex, pageSearch.getPageSize());
        } else {
            return this.sqlGeneralQueryPager(sql, args, rowMapper, pageIndex, ListPageContext.getCurrentPageSize());
        }
//        return sqlGeneralQueryPager(sql, args, rowMapper, pageIndex, ListPageContext.getCurrentPageSize());
    }

    /**
     * 以动态给定的泛型类型来分页返回数据集合。这样就可以在每个DAO中随时使用。
     * @param sql
     * @param args
     * @param rowMapper
     * @param pageIndex 当前页
     * @param pageSize 分页大小
     * @return
     */
    @Override
    public <T> GenericPager<T> sqlGeneralQueryPager(String sql
            , Object[] args, RowMapper<T> rowMapper, int pageIndex, int pageSize){
//        Assert.hasText(sql);
//        Assert.notNull(rowMapper);
//		int count = jdbcTemplate.queryForInt(getHibernateCountQuery(sql, false), args);
        int count = 0;
        Integer countObj = this.getJdbcTemplate().queryForObject(getJdbcCountQuery(sql, this.getPaginationHelper().getType()), Integer.class, args);
        if(countObj != null){
            count = countObj.intValue();
        }
        GenericPager<T> pager = ListPageContext.createGenericPager(pageIndex, pageSize, count);
//        String querySql = getSqlPagingQuery(sql, (int)pager.getFirstRowIndexInPage(), pageSize);
        String querySql = this.getPaginationHelper().getSqlPagingQuery(sql, null);
        logger.debug("......jdbc分页sql: " + querySql);
        /* 设置分页参数 */
        // 对于sqlserver，分页参数设置修改：第一个和最后一个
        List<T> datas = this.getJdbcTemplate().query(querySql, rowMapper, getSqlPageArgs(args, (int)pager.getFirstRowIndexInPage(), pageSize, this.getPaginationHelper().getType()));
        return pager.setDatas(datas);
    }

    /**
     * 给定统计公式，返回单个统计值。
     * @param sql
     * @param args
     * @param clazz
     * @return
     */
    @Override
    public <T> T sqlMathQuery(String sql, Object[] args, Class<T> clazz){
        return this.getJdbcTemplate().queryForObject(sql, clazz, args);
    }

    /**
     * 查询自定义rowMapper对象，该方法主要使用<code>namedJdbcTemplate</code>来查询。<br>
     * 因为对于有些类似：where in (:ids)的查询必须使用命名参数，使用<code>jdbcTemplate</code>则无法查询
     * @param sql
     * @param rowMapper
     * @param paramSource
     * @return
     */
    @Override
    public <T> List<T> sqlListObjectWhereIn(String sql, RowMapper<T> rowMapper, SqlParameterSource paramSource){
        return this.getNamedParameterJdbcTemplate().query(sql, paramSource, rowMapper);
    }

    /**
     * 该方法主要使用<code>namedJdbcTemplate</code>来查询。<br>
     * @param sql
     * @param paramSource
     * @date 2023-02-05
     */
    public List<Map<String, Object>> queryListObjectWhereIn(String sql, SqlParameterSource paramSource){
        return this.getNamedParameterJdbcTemplate().queryForList(sql, paramSource);
    }

    /**
     * 组装并返回分页需要的参数数组
     * @param args
     * @param firstRowIndex
     * @param pageSize
     * @return
     */
    protected Object[] getSqlPageArgs(Object[] args, int firstRowIndex, int pageSize, String type){
        Object[] params = null;
        int j = 0;

        // sqlserver单独处理吧，就他很扯淡，而且分页参数是拼写死的，所以这里不需要添加分页参数
        if(type.equals(DatabaseType.NAME_SQLSERVER)){
            if(firstRowIndex == 0){
                // sqlserver在offset=0时，hibernate不需要设置该参数！
                if(args == null || args.length == 0){
//					params = new Object[1];
//					params[0] = pageSize;
                } else {
//					params = new Object[args.length+1];
//					params[j] = pageSize;
//					j++;
//					for(; j<args.length+1; j++){
//						params[j] = args[j-1];
//					}
                    params = args;
                }
            } else {
                if(args == null || args.length == 0){
                    params = new Object[2];
                    params[0] = firstRowIndex;
                    params[1] = firstRowIndex + pageSize;
                } else {
                    params = new Object[args.length+2];
//					params[j] = pageSize;
//					j++;
                    for(; j<args.length+1; j++){
                        params[j] = args[j-1];
                    }
//					logger.debug("j = " + j);
//					params[j] = firstRowIndex;
                    params[j] = firstRowIndex;
                    params[j+1] = firstRowIndex + pageSize;
                }
            }
        } else {
            // 其他数据库
            if(args == null || args.length == 0){
                params = new Object[2];
            } else {
                params = new Object[args.length+2];
                for(; j<args.length; j++)
                    params[j] = args[j];
            }
        }

        if(type.equals(DatabaseType.NAME_MYSQL) || type.equals(DatabaseType.NAME_DERBY)){
            params[j] = firstRowIndex;
            params[j+1] = pageSize;
        } else if(type.equals(DatabaseType.NAME_ORACLE)){
            params[j] = firstRowIndex + pageSize;
            params[j+1] = firstRowIndex;
        } else if(type.equals(DatabaseType.NAME_POSTGRES)){
            params[j] = pageSize;
            params[j+1] = firstRowIndex;
        } else if(type.equals(DatabaseType.NAME_SQLSERVER)){
            // 前面已经处理，这里不需要了
//    		throw new UnsupportedOperationException("not implements setPageParameters for sqlserver.");
        }
        return params;
    }

    protected static final String SELECT_COUNT = "select count(*) as dby_num ";
    protected static final String SELECT_COUNT_1 = "from (";
    protected static final String SELECT_COUNT_2 = ") as dby_temp";
    protected static final String SELECT_COUNT_3 = ")";
    protected static final String SQL_FROM = " from";
    public static final String SQL_ORDERBY = "order by";

    /**
     * 返回记录总数
     * @param sql 原始SQL语句
     * @return
     */
    protected String getJdbcCountQuery(String sql, String type){
        if(StringUtils.isEmpty(sql)){
            throw new RuntimeException("sql is required!");
        }

        StringBuilder sb = new StringBuilder();
        sb.append(SELECT_COUNT)
                .append(SELECT_COUNT_1);
        if(type.equals(DatabaseType.NAME_SQLSERVER)){
            // 因为sqlserver字句中不能存在order by，要去掉
            int index = sql.toLowerCase().indexOf(SQL_ORDERBY);
            if(index > 0){
                sb.append(sql.substring(0, index));
            } else {
                sb.append(sql);
            }
        } else {
            sb.append(sql);
        }

        if(type.equals(DatabaseType.NAME_ORACLE) || type.equals(DatabaseType.NAME_DAMENG)){
            // 如果是oracle数据库，那么select count(*) from(...) as dby_num 会报错
            // 需要去掉 as dby_num
            sb.append(SELECT_COUNT_3);
        } else {
            sb.append(SELECT_COUNT_2);
        }
        return sb.toString();
    }

    /**
     * 批量更新数据，不带任何参数
     * @param sql 给定的SQL语句
     */
    public void batchUpdate(String sql){
        batchUpdate(sql, null);
    }

    /**
     * 批量更新数据
     * @param sql 给定的SQL语句
     * @param parameters 参数集合，集合中每个参数都是数组，每次更新使用一个参数
     */
    public void batchUpdate(String sql, final List<Object[]> parameters){
        this.getJdbcTemplate().batchUpdate(sql, new BatchPreparedStatementSetter() {

            @Override
            public void setValues(PreparedStatement ps, int i) throws SQLException {
                if(parameters == null) return;
                Object[] param = parameters.get(i);
                if(param == null || param.length == 0){
                    return;
                }

                int _psize = param.length;
                Object _p = null;
                Class<?> _pc = null;
                for(int j=1; j<_psize+1; j++){
                    _p = param[j-1];
                    if(_p == null){
                        throw new IllegalArgumentException("parameter in arrays can't be null!");
                    }
                    _pc = _p.getClass();

                    if(_pc.isPrimitive()){
                        if(_pc == int.class){
                            ps.setInt(j, ((Integer)_p).intValue());
                        } else if(_pc == float.class){
                            ps.setFloat(j, ((Float)_p).floatValue());
                        } else if(_pc == boolean.class){
                            ps.setBoolean(j, ((Boolean)_p).booleanValue());
                        } else if(_pc == long.class){
                            ps.setLong(j, ((Long)_p).longValue());
                        } else if(_pc == double.class){
                            ps.setDouble(j, ((Double)_p).doubleValue());
                        }
                    } else if(_pc == String.class){
                        ps.setString(j, _p.toString());
                    } else if(_pc == Integer.class){
                        ps.setInt(j, ((Integer)_p).intValue());
                    } else if(_pc == Float.class){
                        ps.setFloat(j, ((Float)_p).floatValue());
                    } else if(_pc == Boolean.class){
                        ps.setBoolean(j, ((Boolean)_p).booleanValue());
                    } else if(_pc == Long.class){
                        ps.setLong(j, ((Long)_p).longValue());
                    } else if(_pc == Double.class){
                        ps.setDouble(j, ((Double)_p).doubleValue());
                    } else {
                        ps.setObject(j, _p);
                    }
                }
            }

            @Override
            public int getBatchSize() {
                if(parameters == null) return 0;
                return parameters.size();
            }
        });
    }

    /**
     * 获取动态拼接SQL的查询条件对象
     * @param temp 业务传入的条件数组
     * @return
     */
    protected Object[] getSearchConditionParams(Object[] temp){
        if(temp == null || temp.length == 0) return null;
        // 加入参数
        List<Object> params = new ArrayList<Object>(temp.length);
        for(Object _p : temp){
            if(_p != null){
                params.add(_p);
            }
        }
        if(params.size() > 0){
            temp = params.toArray();
        } else
            temp = null;
        return temp;
    }
}