package com.walker.connector.support;

import com.walker.connector.AbstractConnector;
import com.walker.db.DatabaseException;
import com.walker.db.DatabaseExistException;
import com.walker.db.DatabaseType;
import com.walker.db.page.GenericPager;
import com.walker.db.page.ListPageContext;
import com.walker.infrastructure.utils.StringUtils;
import com.walker.jdbc.ds.MyDruidDataSource;
import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.core.BatchPreparedStatementSetter;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;

import javax.sql.DataSource;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;

/**
 * 基于数据库实现的连接器对象，目前仅能查询数据集合
 * @author shikeying
 * @date 2015年12月15日
 *
 */
public abstract class DatabaseConnector extends AbstractConnector {

	public static final String OPTION_USER = "user";
	public static final String OPTION_PASSWORD = "password";
	public static final String OPTION_MAX_ACTIVE = "maxActive";
	public static final String OPTION_MAX_IDLE = "maxIdle";
	public static final String OPTION_INIT_SIZE = "initialSize";

	public static final String SQL_CREATE_DB_PREF = "CREATE DATABASE ";
	public static final String SQL_CREATE_DB_SUF = " DEFAULT CHARSET utf8 COLLATE utf8_general_ci;";

//	private SupportDBTypeDataSource dataSource = null;
	// 2023-05-08 统一使用平台配置数据源，不再创建独立数据源。
//	private DataSource dataSource = null;

	protected JdbcTemplate jdbcTemplate = null;
	protected NamedParameterJdbcTemplate namedJdbcTemplate;

	/* 管理模式：不设置数据库名字，可以创建数据库，应该也可以管理 */
	private boolean manageMode = false;

	private DataSource dataSource = null;

	/**
	 * 没有数据源，只能通过设置参数方式初始化连接器，最后要调用{@link this.initialize()}方法初始化
	 */
	public DatabaseConnector(){}

	/**
	 * 如果从外部传入数据源，则通过构造函数直接创建即可。
	 * @param dataSource
	 */
	public DatabaseConnector(DataSource dataSource){
		if(dataSource == null){
			throw new IllegalArgumentException("dataSource必须设置!");
		}
		this.dataSource = dataSource;
		jdbcTemplate = new JdbcTemplate(dataSource);
		namedJdbcTemplate = new NamedParameterJdbcTemplate(dataSource);
	}

	public DataSource getDataSource() {
//		return (DataSource) JdbcInspector.getInstance().getPrimaryDataSourceMeta();
		return this.dataSource;
	}

	public JdbcTemplate getJdbcTemplate() {
		return jdbcTemplate;
	}

	public NamedParameterJdbcTemplate getNamedJdbcTemplate() {
		return namedJdbcTemplate;
	}

	/**
	 * 返回是否管理模式，管理模式中没有数据库名字，用于处理各种数据库命令
	 * @return
	 */
	public boolean isManageMode() {
		return manageMode;
	}

	/**
	 * 设置为管理模式：没有数据库名字
	 */
	public void setManageMode() {
		this.manageMode = true;
		this.setServiceName(StringUtils.EMPTY_STRING);
	}

	/**
	 * 执行命令：创建数据库
	 * @param databaseName
	 * @throws DatabaseException
	 */
	public void exeCreateDatabase(String databaseName) throws DatabaseException {
		try{
			jdbcTemplate.execute(new StringBuilder()
				.append(SQL_CREATE_DB_PREF)
				.append(databaseName)
				.append(SQL_CREATE_DB_SUF).toString());
		} catch(DataAccessException ex){
			SQLException sqlEx = (SQLException)ex.getRootCause();
			if(sqlEx.getErrorCode() == 1007){
				throw new DatabaseExistException(databaseName);
			} else
				throw new DatabaseException("createDatabase异常", ex);
		}
	}

	/**
	 * 根据SQL语句创建表结构
	 * @param sql
	 * @throws DatabaseException
	 */
	public void exeCreateTable(String sql) throws DatabaseException{
		try{
			jdbcTemplate.execute(sql);
			logger.debug("执行创建表SQL = " + sql);
		} catch(DataAccessException ex){
//			SQLException sqlEx = (SQLException)ex.getRootCause();
//			if(sqlEx.getErrorCode() == 1007){
//				throw new DatabaseExistException("ddddddd");
//			} else
				throw new DatabaseException("createTable异常", ex);
		}
	}

	/**
	 * 批量写入数据库记录
	 * @param sql
	 * @param spsArray
	 * @transaction 注意：方法名前缀为"exec"的会走事务处理，不过需要在DatabaseStore中设置参数
	 */
	public int execBatchInsert(String sql, MapSqlParameterSource[] spsArray){
		int[] res = namedJdbcTemplate.batchUpdate(sql, spsArray);
		return res[0];
	}

	/**
	 * 使用<code>JdbcTemplate</code>实现批量更新。</p>
	 * 通过?替换变量数据即可。
	 * @param sql
	 * @param batchArgs
	 */
	public void execBatchUpdateForJdbc(String sql, List<Object[]> batchArgs){
		jdbcTemplate.batchUpdate(sql, batchArgs);
	}

	public void execute(String sql) throws DatabaseException{
		try{
			jdbcTemplate.execute(sql);
		} catch(DataAccessException ex){
			throw new DatabaseException("execute(sql)异常", ex);
		}
	}

//	/**
//	 * 返回指定的数据库存在表数量
//	 * @param schema
//	 * @return
//	 */
//	public int queryTableSize(String schema){
//		return 0;
//	}

	/**
	 * 根据sql语句，检索列表数据，返回的一条记录是一个map对象。
	 * @param sql
	 * @param args
	 * @return
	 */
	public List<Map<String, Object>> queryForList(String sql, Object[] args){
		return getJdbcTemplate().queryForList(sql, args);
	}

	public <T> List<T> queryForRowMapper(String sql, Object[] args, RowMapper<T> rowMapper){
		return getJdbcTemplate().query(sql, args, rowMapper);
	}

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

	/**
	 * 根据sql语句查询一个整数值，如：总数等
	 * @param sql
	 * @param args
	 * @return
	 */
	public int queryForInt(String sql, Object[] args){
//		logger.debug("+++++++++++++++ jdbcTemplate = " + this.jdbcTemplate);
		Integer maxValue = this.getJdbcTemplate().queryForObject(sql, Integer.class, args);
		if(maxValue == null){
			return 0;
		}
		return maxValue;
	}

	public long queryForLong(String sql, Object[] args){
		Long maxValue = this.getJdbcTemplate().queryForObject(sql, Long.class, args);
		if(maxValue == null){
			return 0;
		}
		return maxValue;
	}

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

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

	/**
	 * 实现简单的分页数据返回，需要提供对象转换接口，使用了Spring框架的<code>RowMapper</code>.</br>
	 * @param sql
	 * @param args
	 * @param rowMapper
//	 * @param pageIndex 当前页（如：第五页则值为5）
//	 * @param pageSize
	 * @param pageSql 分页的sql语句，不同数据库不一样。如：mysql为" select * from table [limit ? offset ?]"
	 * @return
	 */
	public <E> GenericPager<E> sqlSimpleQueryPager(String sql, Object[] args, RowMapper<E> rowMapper
//			, int pageIndex, int pageSize
			, String pageSql){
		StringBuilder sqlCount = new StringBuilder();
		sqlCount.append("select count(*) cnt from (");
		sqlCount.append(sql);
		sqlCount.append(") t");
		int count = jdbcTemplate.queryForObject(sqlCount.toString(), Integer.class, args);
		int pageIndex = ListPageContext.getCurrentPageIndex();
		int pageSize = ListPageContext.getCurrentPageSize();
		GenericPager<E> pager = ListPageContext.createGenericPager(pageIndex, pageSize, count);
//		logger.debug("...........page count = " + count);
//		logger.debug("..........."+sqlCount.toString());
//		if(args != null){
//			for(Object obj : args){
//				logger.debug("参数：" + obj);
//			}
//		}

		/* 设置分页参数 */
		List<E> datas = jdbcTemplate.query(pageSql, rowMapper, getSqlPageArgs(args, (int)pager.getFirstRowIndexInPage(), pageSize));
//		logger.debug("记录索引值：" + pager.getFirstRowIndexInPage() + ", " + pager.getPageIndex());
		logger.debug(pageSql);
//		logger.debug(datas);
		return pager.setDatas(datas);
	}

	/**
	 * 组装并返回分页需要的参数数组
	 * @param args
	 * @param firstRowIndex
	 * @param pageSize
	 * @return
	 */
	protected Object[] getSqlPageArgs(Object[] args, int firstRowIndex, int pageSize){
		Object[] params = null;
		int j = 0;
		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];
		}

		DatabaseType type = this.getDatabaseType();
		if(type == DatabaseType.MYSQL || type == DatabaseType.DERBY){
//			params[j] = firstRowIndex;
//			params[j+1] = pageSize;
			// 使用hibernate的dialect传入的分页参数，与直接使用sql拼写有区别，所以要调换下。
			params[j] = pageSize;
			params[j+1] = firstRowIndex;
    	} else if(type == DatabaseType.ORACLE || type == DatabaseType.DAMENG){
    		params[j] = firstRowIndex + pageSize;
    		params[j+1] = firstRowIndex;
    	} else if(type == DatabaseType.POSTGRES){
    		params[j] = pageSize;
    		params[j+1] = firstRowIndex;
    	} else if(type == DatabaseType.SQLSERVER){
    		throw new UnsupportedOperationException("not implements setPageParameters for sqlserver.");
    	}
		if(logger.isDebugEnabled()){
			for(Object obj : params){
				logger.debug("pager param =" + obj);
			}
		}
		return params;
	}

	/**
	 * 批量更新数据，不带任何参数
	 * @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.jdbcTemplate.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();
			}
		});
	}

	@Override
	public Object invoke(Object... param) throws Exception {
		int s = param.length;
		if(s < 2){
			throw new IllegalArgumentException("数据库查询参数缺失，至少2个：sql, args, rowMapper(option)");
		}
		if(s == 3){
			return jdbcTemplate.query((String)param[0], (RowMapper<?>)param[2], (Object[])param[1]);
		} else {
			return jdbcTemplate.queryForList((String)param[0], (Object[])param[1]);
		}
	}

	@Override
	public void initialize() {
		super.initialize();
		if(!this.manageMode && StringUtils.isEmpty(getServiceName())){
			throw new IllegalArgumentException("未提供数据库名称：serviceName");
		}

		Map<String, String> params = getParameters();
		if(params.size() <= 0){
			throw new IllegalArgumentException("未找到数据库连接参数");
		}
		if(params.get(OPTION_USER) == null || params.get(OPTION_PASSWORD) == null){
			throw new IllegalArgumentException("未找到数据库连接参数:用户名或密码");
		}

/*		DefaultDataSource dataSource = new DefaultDataSource();

		DefaultDataSource ds = (DefaultDataSource)dataSource;
		ds.setDatabaseType(this.getDatabaseType().getTypeIndex());
		ds.setIp(getUrl());
		ds.setPort(getPort());
		ds.setDatabaseName(getServiceName());
		ds.setUsername(params.get(OPTION_USER));
		ds.setPassword(params.get(OPTION_PASSWORD));

		// 设置连接池参数
//		dataSource.setMaxWait(10000);
//		dataSource.setRemoveAbandoned(true);
//		dataSource.setRemoveAbandonedTimeout(300);
//		dataSource.setTimeBetweenEvictionRunsMillis(60000);
//		dataSource.setNumTestsPerEvictionRun(10);
//		dataSource.setMinEvictableIdleTimeMillis(10000);
//		dataSource.setTestWhileIdle(true);
//		if(params.get(OPTION_MAX_ACTIVE) != null){
//			dataSource.setMaxActive(Integer.parseInt(params.get(OPTION_MAX_ACTIVE)));
//		} else {
//			dataSource.setMaxActive(10);
//		}
//		if(params.get(OPTION_MAX_IDLE) != null){
//			dataSource.setMaxIdle(Integer.parseInt(params.get(OPTION_MAX_IDLE)));
//		} else {
//			dataSource.setMaxIdle(5);
//		}
//		if(params.get(OPTION_INIT_SIZE) != null){
//			dataSource.setInitialSize(Integer.parseInt(params.get(OPTION_INIT_SIZE)));
//		} else {
//			dataSource.setInitialSize(2);
//		}

		// 连接池
		if(params.get(OPTION_MAX_ACTIVE) != null){
			ds.setMaximumPoolSize(Integer.parseInt(params.get(OPTION_MAX_ACTIVE)));
		} else {
			ds.setMaximumPoolSize(10);
		}
		if(params.get(OPTION_INIT_SIZE) != null){
			ds.setMinimumIdle(Integer.parseInt(params.get(OPTION_INIT_SIZE)));
		} else {
			ds.setMinimumIdle(2);
		}
		ds.setIdleTimeout(300);
		ds.setConnectionTimeout(12000);*/

		// 2023-05-08 使用平台数据源。
//		DataSource dataSource = (DataSource) JdbcInspector.getInstance().getPrimaryDataSourceMeta();
		DataSource ds = this.acquireDruidDataSource(params);

		jdbcTemplate = new JdbcTemplate(ds);
		namedJdbcTemplate = new NamedParameterJdbcTemplate(ds);
		this.dataSource = ds;
	}

	protected DataSource acquireDruidDataSource(Map<String, String> params){
		MyDruidDataSource druidDataSource = new MyDruidDataSource();
		druidDataSource.setIp(getUrl());
		druidDataSource.setPort(getPort());
		druidDataSource.setDatabaseType(this.getDatabaseType().getTypeIndex());
		druidDataSource.setDatabaseName(getServiceName());
		druidDataSource.setUsername(params.get(OPTION_USER));
		druidDataSource.setPassword(params.get(OPTION_PASSWORD));
		if(params.get(OPTION_MAX_ACTIVE) != null){
			druidDataSource.setMaxActive(Integer.parseInt(params.get(OPTION_MAX_ACTIVE)));
		} else {
			druidDataSource.setMaxActive(20);
		}
		if(params.get(OPTION_INIT_SIZE) != null){
			druidDataSource.setInitialSize(Integer.parseInt(params.get(OPTION_INIT_SIZE)));
		} else {
			druidDataSource.setInitialSize(5);
		}
		druidDataSource.setMinIdle(10);
		druidDataSource.setMaxWait(60000);
		druidDataSource.setTimeBetweenEvictionRunsMillis(60000);
		druidDataSource.setMinEvictableIdleTimeMillis(30000);
		druidDataSource.setMaxEvictableIdleTimeMillis(180000);
		druidDataSource.setValidationQuery("select 1");
		druidDataSource.setTestWhileIdle(true);
		druidDataSource.setTestOnBorrow(false);
		druidDataSource.setTestOnReturn(false);
		druidDataSource.setMaxOpenPreparedStatements(64);
		return druidDataSource;
	}

	@Override
	public void destroy() {
//		if(dataSource != null){
//			try {
//				if(dataSource instanceof DefaultDataSource){
//					((DefaultDataSource)dataSource).close();
//				}
//			} catch (Exception e) {
//				logger.error("销毁 DatabaseConnector 失败:" + ((DefaultDataSource) dataSource).getDatabaseName(), e);
//			}
//		}
	}

	/**
	 * 返回数据库类型，子类实现
	 * @return
	 */
	protected abstract DatabaseType getDatabaseType();
}