package com.sqx.config;

import com.sqx.sharding.MasterSlaveRules;
import com.sqx.sharding.ShardingDataBase;
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.apache.shardingsphere.api.config.masterslave.MasterSlaveRuleConfiguration;
import org.apache.shardingsphere.api.config.sharding.ShardingRuleConfiguration;
import org.apache.shardingsphere.api.config.sharding.TableRuleConfiguration;
import org.apache.shardingsphere.shardingjdbc.api.ShardingDataSourceFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.annotation.PostConstruct;
import javax.sql.DataSource;
import java.sql.SQLException;
import java.util.*;
import java.util.stream.Collectors;


/**
 * sharding-jdbc 配置文件
 */
@Slf4j
@Data
@Configuration
@ConfigurationProperties(prefix = "spring.shardingsphere")
public class ShardingConfig {

    /**
     * 读取数据源信息
     */
    private Map<String, ShardingDataBase> datasource;
    /**
     * 读写分离的配置
     */
    private Map<String, MasterSlaveRules> masterSlaveRules;
    /**
     * 显示sharding-jdbc的sql
     */
    private String showSql;

    /**
     * 中心库的节点
     */
    private String centerTablesDataNode;

    @Value("${center-tables}")
    private String tableNamesAsString;

    /**
     * 中心表,不进行分库操作
     */
//    @Value("${center-tables}")
    private Set<String> centerTables;

    @PostConstruct
    public void init() {
        // 使用换行符进行分割，然后去除空白字符，收集到Set集合中
        centerTables = Arrays.stream(tableNamesAsString.split(","))
                .map(String::trim)
                .collect(Collectors.toSet());
    }


    /**
     * 配置sharding-jdbc数据源
     */
    @Bean
    public DataSource dataSource() throws SQLException {
        ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();

        // 配置数据库主从
        shardingRuleConfig.setMasterSlaveRuleConfigs(masterSlaveRuleConfigs());

        // 配置表的切分策略
        shardingRuleConfig.setTableRuleConfigs(addTableRuleConfigs());

        // 配置是否显示sql
        Properties props = new Properties();
        props.put("sql.show", showSql);

        // 配置数据源
        Map<String, DataSource> dataSourceMap = getShardingDataBase();
        return ShardingDataSourceFactory.createDataSource(dataSourceMap, shardingRuleConfig, props);
    }

    /**
     * 配置
     */
    private Set<TableRuleConfiguration> addTableRuleConfigs() {
        Set<TableRuleConfiguration> sets = new HashSet<>();
        for (String centerTable : centerTables) {
            TableRuleConfiguration tableRuleConfig = new TableRuleConfiguration(centerTable,
                    String.format(centerTablesDataNode, centerTable));
            sets.add(tableRuleConfig);
        }

//        // 定义区域表的分库规则
//        InlineShardingStrategyConfiguration databaseShardingStrategyConfig = new InlineShardingStrategyConfiguration(
//                regionTablesShardingDatabaseColumn, regionTablesShardingDatabaseAlgorithm);
//        for (String regionTable : regionTables) {
//            TableRuleConfiguration tableRuleConfig = new TableRuleConfiguration(regionTable, String.format(regionTablesDataNode, regionTable));
//            tableRuleConfig.setDatabaseShardingStrategyConfig(databaseShardingStrategyConfig);
//            sets.add(tableRuleConfig);
//        }
        return sets;
    }

    /**
     * 配置数据源
     */
    private Map<String, DataSource> getShardingDataBase() {
        String testQuery = "SELECT 1";
        Map<String, DataSource> map = new HashMap<>();
        datasource.forEach((datasourceName, shardingDataBase) -> {
            HikariConfig config = new HikariConfig();
            config.setDriverClassName(shardingDataBase.getDriverClassName());
            config.setJdbcUrl(shardingDataBase.getJdbcUrl());
            config.setUsername(shardingDataBase.getUsername());
            config.setPassword(shardingDataBase.getPassword());
            config.setPoolName(datasourceName);
            config.setMinimumIdle(shardingDataBase.getMinimumIdle());
            config.setMaximumPoolSize(shardingDataBase.getMaximumPoolSize());
            config.setIdleTimeout(shardingDataBase.getIdleTimeout());
            config.setMaxLifetime(shardingDataBase.getMaxLifetime());
            config.setConnectionTimeout(shardingDataBase.getConnectionTimeout());
            config.setConnectionTestQuery(testQuery);
            map.put(datasourceName, new HikariDataSource(config));
        });
        return map;
    }

    /**
     * 配置读写分离
     */
    private Set<MasterSlaveRuleConfiguration> masterSlaveRuleConfigs() {
        Set<MasterSlaveRuleConfiguration> sets = new HashSet<>();
        masterSlaveRules.forEach((databaseName, masterSlaveRules) -> {
            MasterSlaveRuleConfiguration masterSlaveRuleConfig = new MasterSlaveRuleConfiguration(databaseName,
                    masterSlaveRules.getMasterDataSourceName(), masterSlaveRules.getSlaveDataSourceNames());
            sets.add(masterSlaveRuleConfig);
        });
        return sets;
    }
}