package io.github.pnoker.gateway.config;

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import io.github.pnoker.gateway.dbdao.DBMgrProxy;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import javax.annotation.PostConstruct;
import javax.sql.DataSource;

@Configuration
@MapperScan(basePackages = {"io.github.pnoker.gateway.dbdao.mapper",
"io.github.pnoker.gateway.dbdao.tangyinSource.mapper"}, sqlSessionTemplateRef = "mainSqlSessionTemplate")
public class MainSourceConfiguration {
    @Value("${spring.datasource.driver-class-name:}")
    private String driveClass = "org.postgresql.Driver";

    @Value("${spring.datasource.jdbc-url:}")
    private String url = "";

    @Value("${spring.datasource.username:}")
    private String username = "";

    @Value("${spring.datasource.password:}")
    private String password = "";

    @Value("${spring.datasource.data.maximum-pool-size:200}")
    private Integer maxPoolSize;

    @Value("${spring.datasource.data.minimum-idle:1}")
    private Integer minIdle;

    @Value("${spring.datasource.data.connection-test-query:}")
    private String connectionTestQuery;

    @Value("${spring.datasource.data.max-lifetime:120000}")
    private Long maxLifetime;

    @Value("${spring.datasource.data.idle-timeout:30000}")
    private Long idleTimeout;

    @Value("${spring.datasource.data.connection-timeout:30000}")
    private Long connectionTimeout;

    @Value("${spring.datasource.data.validation-timeout:30000}")
    private Long validTimeout;

    @Bean(name = "mainDatasource")
    //@ConfigurationProperties(prefix = "spring.datasource.data")
    public DataSource mainDataSource() {
        return new HikariDataSource(getConfig());
        //return DataSourceBuilder.create().build();
        //Spring Boot 2.x默认使用HikariCP
    }

    private HikariConfig getConfig() {
        HikariConfig hikariConfig = new HikariConfig();
        hikariConfig.setDriverClassName(driveClass);
        hikariConfig.setJdbcUrl(url);
        hikariConfig.setUsername(username);
        hikariConfig.setPassword(password);

        hikariConfig.setMaximumPoolSize(maxPoolSize);
        hikariConfig.setMinimumIdle(minIdle);
        hikariConfig.setConnectionTestQuery(connectionTestQuery);
        hikariConfig.setMaxLifetime(maxLifetime);
        hikariConfig.setIdleTimeout(idleTimeout);
        hikariConfig.setConnectionTimeout(connectionTimeout);
        hikariConfig.setValidationTimeout(validTimeout);
        return hikariConfig;
    }

    @Bean("mainSqlSessionFactory")
    public SqlSessionFactory mainSqlSessionFactoryBean(@Qualifier("mainDatasource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();
        sessionFactoryBean.setDataSource(dataSource);

        org.apache.ibatis.session.Configuration configuration = new org.apache.ibatis.session.Configuration();
        configuration.setCallSettersOnNulls(true);       //数据库中字段值为null时也要求返回
        configuration.setMapUnderscoreToCamelCase(true); //开启驼峰映射
        configuration.setCacheEnabled(false);
        sessionFactoryBean.setConfiguration(configuration);
        return sessionFactoryBean.getObject();
    }

    @Bean("mainSqlSessionTemplate")
    public SqlSessionTemplate mainSqlSessionTemplate(@Qualifier("mainSqlSessionFactory") SqlSessionFactory sessionFactory) {
        return new SqlSessionTemplate(sessionFactory);
    }

    @Bean(name = "mainDbTransactionManager")
    public DataSourceTransactionManager mainDbTransactionManager(@Qualifier("mainDatasource") DataSource dataSource){
        return new DataSourceTransactionManager(dataSource);
    }
    @PostConstruct
    public void init(){
        GlobalData.getInstance().setPostGisValid("org.postgis.DriverWrapper".equals(driveClass));
    }

    //TODO child数据源
    @Value("${spring.datasource.childpg.driver-class-name:}")
    private String driveClass1 = "org.postgresql.Driver";

    @Value("${spring.datasource.childpg.jdbc-url:}")
    private String url1 = "";

    @Value("${spring.datasource.childpg.username:}")
    private String username1 = "";

    @Value("${spring.datasource.childpg.password:}")
    private String password1 = "";

    @Value("${spring.datasource.data.maximum-pool-size:200}")
    private Integer maxPoolSize1;

    @Value("${spring.datasource.data.minimum-idle:1}")
    private Integer minIdle1;

    @Value("${spring.datasource.data.connection-test-query:}")
    private String connectionTestQuery1;

    @Value("${spring.datasource.data.max-lifetime:120000}")
    private Long maxLifetime1;
    @Value("${spring.datasource.data.idle-timeout:30000}")
    private Long idleTimeout1;

    @Value("${spring.datasource.data.connection-timeout:30000}")
    private Long connectionTimeout1;

    @Value("${spring.datasource.data.validation-timeout:30000}")
    private Long validTimeout1;

    @Bean(name = "childDatasource")
    //@ConfigurationProperties(prefix = "spring.datasource.data")
    public DataSource childDatasource() {
//        return new HikariDataSource(getConfig1());
        return DataSourceBuilder.create().build();
        //Spring Boot 2.x默认使用HikariCP
    }

    private HikariConfig getConfig1() {
        HikariConfig hikariConfig = new HikariConfig();
        hikariConfig.setDriverClassName(driveClass1);
        hikariConfig.setJdbcUrl(url1);
        hikariConfig.setUsername(username1);
        hikariConfig.setPassword(password1);

        hikariConfig.setMaximumPoolSize(maxPoolSize1);
        hikariConfig.setMinimumIdle(minIdle1);
        hikariConfig.setConnectionTestQuery(connectionTestQuery1);
        hikariConfig.setMaxLifetime(maxLifetime1);
        hikariConfig.setIdleTimeout(idleTimeout1);
        hikariConfig.setConnectionTimeout(connectionTimeout1);
        hikariConfig.setValidationTimeout(validTimeout1);
        return hikariConfig;
    }

    @Bean("childSqlSessionFactory")
    public SqlSessionFactory childSqlSessionFactoryBean(@Qualifier("childDatasource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();
        sessionFactoryBean.setDataSource(dataSource);

        org.apache.ibatis.session.Configuration configuration = new org.apache.ibatis.session.Configuration();
        configuration.setCallSettersOnNulls(true);       //数据库中字段值为null时也要求返回
        configuration.setMapUnderscoreToCamelCase(true); //开启驼峰映射
        configuration.setCacheEnabled(false);
        sessionFactoryBean.setConfiguration(configuration);
        return sessionFactoryBean.getObject();
    }

    @Bean("childSqlSessionTemplate")
    public SqlSessionTemplate childSqlSessionTemplate(@Qualifier("childSqlSessionFactory") SqlSessionFactory sessionFactory) {
        return new SqlSessionTemplate(sessionFactory);
    }

    @Bean(name = "childDbTransactionManager")
    public DataSourceTransactionManager childDbTransactionManager(@Qualifier("childDatasource") DataSource dataSource){
        return new DataSourceTransactionManager(dataSource);
    }

    //TODO child2数据源
    @Value("${spring.datasource.child2pg.driver-class-name:}")
    private String driveClass2 = "org.postgresql.Driver";

    @Value("${spring.datasource.child2pg.jdbc-url:}")
    private String url2 = "";

    @Value("${spring.datasource.child2pg.username:}")
    private String username2 = "";

    @Value("${spring.datasource.child2pg.password:}")
    private String password2 = "";

    @Value("${spring.datasource.data.maximum-pool-size:200}")
    private Integer maxPoolSize2;

    @Value("${spring.datasource.data.minimum-idle:1}")
    private Integer minIdle2;

    @Value("${spring.datasource.data.connection-test-query:}")
    private String connectionTestQuery2;

    @Value("${spring.datasource.data.max-lifetime:120000}")
    private Long maxLifetime2;

    @Value("${spring.datasource.data.idle-timeout:30000}")
    private Long idleTimeout2;

    @Value("${spring.datasource.data.connection-timeout:30000}")
    private Long connectionTimeout2;

    @Value("${spring.datasource.data.validation-timeout:30000}")
    private Long validTimeout2;

    @Bean(name = "child2Datasource")
    //@ConfigurationProperties(prefix = "spring.datasource.data")
    public DataSource child2Datasource() {
        return new HikariDataSource(getConfig2());
//        return DataSourceBuilder.create().build();
        //Spring Boot 2.x默认使用HikariCP
    }

    private HikariConfig getConfig2() {
        HikariConfig hikariConfig = new HikariConfig();
        hikariConfig.setDriverClassName(driveClass2);
        hikariConfig.setJdbcUrl(url2);
        hikariConfig.setUsername(username2);
        hikariConfig.setPassword(password2);

        hikariConfig.setMaximumPoolSize(maxPoolSize2);
        hikariConfig.setMinimumIdle(minIdle2);
        hikariConfig.setConnectionTestQuery(connectionTestQuery2);
        hikariConfig.setMaxLifetime(maxLifetime2);
        hikariConfig.setIdleTimeout(idleTimeout2);
        hikariConfig.setConnectionTimeout(connectionTimeout2);
        hikariConfig.setValidationTimeout(validTimeout2);
        return hikariConfig;
    }

    @Bean("child2SqlSessionFactory")
    public SqlSessionFactory child2SqlSessionFactoryBean(@Qualifier("child2Datasource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();
        sessionFactoryBean.setDataSource(dataSource);

        org.apache.ibatis.session.Configuration configuration = new org.apache.ibatis.session.Configuration();
        configuration.setCallSettersOnNulls(true);       //数据库中字段值为null时也要求返回
        configuration.setMapUnderscoreToCamelCase(true); //开启驼峰映射
        configuration.setCacheEnabled(false);
        sessionFactoryBean.setConfiguration(configuration);
        return sessionFactoryBean.getObject();
    }

    @Bean("child2SqlSessionTemplate")
    public SqlSessionTemplate child2SqlSessionTemplate(@Qualifier("child2SqlSessionFactory") SqlSessionFactory sessionFactory) {
        return new SqlSessionTemplate(sessionFactory);
    }

    @Bean(name = "child2DbTransactionManager")
    public DataSourceTransactionManager child2DbTransactionManager(@Qualifier("child2Datasource") DataSource dataSource){
        return new DataSourceTransactionManager(dataSource);
    }

    //TODO child3数据源
    @Value("${spring.datasource.child3pg.driver-class-name:}")
    private String driveClass3 = "org.postgresql.Driver";

    @Value("${spring.datasource.child3pg.jdbc-url:}")
    private String url3 = "";

    @Value("${spring.datasource.child3pg.username:}")
    private String username3 = "";

    @Value("${spring.datasource.child3pg.password:}")
    private String password3 = "";

    @Value("${spring.datasource.data.maximum-pool-size:200}")
    private Integer maxPoolSize3;

    @Value("${spring.datasource.data.minimum-idle:1}")
    private Integer minIdle3;

    @Value("${spring.datasource.data.connection-test-query:}")
    private String connectionTestQuery3;

    @Value("${spring.datasource.data.max-lifetime:120000}")
    private Long maxLifetime3;

    @Value("${spring.datasource.data.idle-timeout:30000}")
    private Long idleTimeout3;

    @Value("${spring.datasource.data.connection-timeout:30000}")
    private Long connectionTimeout3;

    @Value("${spring.datasource.data.validation-timeout:30000}")
    private Long validTimeout3;

    @Bean(name = "child3Datasource")
    //@ConfigurationProperties(prefix = "spring.datasource.data")
    public DataSource child3Datasource() {
        return new HikariDataSource(getConfig3());
//        return DataSourceBuilder.create().build();
        //Spring Boot 2.x默认使用HikariCP
    }

    private HikariConfig getConfig3() {
        HikariConfig hikariConfig = new HikariConfig();
        hikariConfig.setDriverClassName(driveClass3);
        hikariConfig.setJdbcUrl(url3);
        hikariConfig.setUsername(username3);
        hikariConfig.setPassword(password3);

        hikariConfig.setMaximumPoolSize(maxPoolSize3);
        hikariConfig.setMinimumIdle(minIdle3);
        hikariConfig.setConnectionTestQuery(connectionTestQuery3);
        hikariConfig.setMaxLifetime(maxLifetime3);
        hikariConfig.setIdleTimeout(idleTimeout3);
        hikariConfig.setConnectionTimeout(connectionTimeout3);
        hikariConfig.setValidationTimeout(validTimeout3);
        return hikariConfig;
    }

    @Bean("child3SqlSessionFactory")
    public SqlSessionFactory child3SqlSessionFactoryBean(@Qualifier("child3Datasource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();
        sessionFactoryBean.setDataSource(dataSource);

        org.apache.ibatis.session.Configuration configuration = new org.apache.ibatis.session.Configuration();
        configuration.setCallSettersOnNulls(true);       //数据库中字段值为null时也要求返回
        configuration.setMapUnderscoreToCamelCase(true); //开启驼峰映射
        configuration.setCacheEnabled(false);
        sessionFactoryBean.setConfiguration(configuration);
        return sessionFactoryBean.getObject();
    }

    @Bean("child3SqlSessionTemplate")
    public SqlSessionTemplate child3SqlSessionTemplate(@Qualifier("child3SqlSessionFactory") SqlSessionFactory sessionFactory) {
        return new SqlSessionTemplate(sessionFactory);
    }

    @Bean(name = "child3DbTransactionManager")
    public DataSourceTransactionManager child3DbTransactionManager(@Qualifier("child3Datasource") DataSource dataSource){
        return new DataSourceTransactionManager(dataSource);
    }

    //TODO child4数据源
    @Value("${spring.datasource.child4pg.driver-class-name:}")
    private String driveClass4 = "org.postgresql.Driver";

    @Value("${spring.datasource.child4pg.jdbc-url:}")
    private String url4 = "";

    @Value("${spring.datasource.child4pg.username:}")
    private String username4 = "";

    @Value("${spring.datasource.child4pg.password:}")
    private String password4 = "";

    @Value("${spring.datasource.data.maximum-pool-size:200}")
    private Integer maxPoolSize4;

    @Value("${spring.datasource.data.minimum-idle:1}")
    private Integer minIdle4;

    @Value("${spring.datasource.data.connection-test-query:}")
    private String connectionTestQuery4;

    @Value("${spring.datasource.data.max-lifetime:120000}")
    private Long maxLifetime4;

    @Value("${spring.datasource.data.idle-timeout:30000}")
    private Long idleTimeout4;

    @Value("${spring.datasource.data.connection-timeout:30000}")
    private Long connectionTimeout4;

    @Value("${spring.datasource.data.validation-timeout:30000}")
    private Long validTimeout4;

    @Bean(name = "child4Datasource")
    //@ConfigurationProperties(prefix = "spring.datasource.data")
    public DataSource child4Datasource() {
//        return new HikariDataSource(getConfig4());
        return DataSourceBuilder.create().build();
        //Spring Boot 2.x默认使用HikariCP
    }

    private HikariConfig getConfig4() {
        HikariConfig hikariConfig = new HikariConfig();
        hikariConfig.setDriverClassName(driveClass4);
        hikariConfig.setJdbcUrl(url4);
        hikariConfig.setUsername(username4);
        hikariConfig.setPassword(password4);

        hikariConfig.setMaximumPoolSize(maxPoolSize4);
        hikariConfig.setMinimumIdle(minIdle4);
        hikariConfig.setConnectionTestQuery(connectionTestQuery4);
        hikariConfig.setMaxLifetime(maxLifetime4);
        hikariConfig.setIdleTimeout(idleTimeout4);
        hikariConfig.setConnectionTimeout(connectionTimeout4);
        hikariConfig.setValidationTimeout(validTimeout4);
        return hikariConfig;
    }

    @Bean("child4SqlSessionFactory")
    public SqlSessionFactory child4SqlSessionFactoryBean(@Qualifier("child4Datasource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();
        sessionFactoryBean.setDataSource(dataSource);

        org.apache.ibatis.session.Configuration configuration = new org.apache.ibatis.session.Configuration();
        configuration.setCallSettersOnNulls(true);       //数据库中字段值为null时也要求返回
        configuration.setMapUnderscoreToCamelCase(true); //开启驼峰映射
        configuration.setCacheEnabled(false);
        sessionFactoryBean.setConfiguration(configuration);
        return sessionFactoryBean.getObject();
    }

    @Bean("child4SqlSessionTemplate")
    public SqlSessionTemplate child4SqlSessionTemplate(@Qualifier("child4SqlSessionFactory") SqlSessionFactory sessionFactory) {
        return new SqlSessionTemplate(sessionFactory);
    }

    @Bean(name = "child4DbTransactionManager")
    public DataSourceTransactionManager child4DbTransactionManager(@Qualifier("child4Datasource") DataSource dataSource){
        return new DataSourceTransactionManager(dataSource);
    }

    @Bean
    public DBMgrProxy startDBMgrProxy(){
        DBMgrProxy.getInstance().init();
        return DBMgrProxy.getInstance();
    }
}