@Configuration
@EnableShardingJdbc
public class ShardingSphereConfig {
    
    /**
     * 配置數(shù)據(jù)源映射
     * 定義多個(gè)數(shù)據(jù)庫(kù)實(shí)例用于分片存儲(chǔ)
     */
    @Bean
    public Map<String, DataSource> dataSourceMap() {
        Map<String, DataSource> dataSourceMap = new HashMap<>();
        
        // 配置第一個(gè)分片數(shù)據(jù)源
        HikariDataSource dataSource1 = new HikariDataSource();
        dataSource1.setJdbcUrl("jdbc:mysql://localhost:3306/shard_db_1");
        dataSource1.setUsername("root");
        dataSource1.setPassword("password");
        dataSourceMap.put("shard_db_1", dataSource1);
        
        // 配置第二個(gè)分片數(shù)據(jù)源  
        HikariDataSource dataSource2 = new HikariDataSource();
        dataSource2.setJdbcUrl("jdbc:mysql://localhost:3306/shard_db_2");
        dataSource2.setUsername("root");
        dataSource2.setPassword("password");
        dataSourceMap.put("shard_db_2", dataSource2);
        
        return dataSourceMap;
    }
}

/**
 * 分片規(guī)則配置類(lèi)
 * 定義數(shù)據(jù)庫(kù)和表的分片策略
 */
@Component
public class ShardingRuleConfiguration {
    
    /**
     * 配置表分片規(guī)則
     * 基于用戶(hù)ID進(jìn)行分片
     */
    public TableRuleConfiguration getUserTableRuleConfig() {
        TableRuleConfiguration config = new TableRuleConfiguration();
        config.setLogicTable("t_user");
        config.setActualDataNodes("shard_db_${0..1}.t_user_${0..1}");
        
        // 配置數(shù)據(jù)庫(kù)分片策略
        config.setDatabaseShardingStrategyConfig(
            new InlineShardingStrategyConfiguration("user_id", "shard_db_${user_id % 2}")
        );
        
        // 配置表分片策略
        config.setTableShardingStrategyConfig(
            new InlineShardingStrategyConfiguration("user_id", "t_user_${user_id % 2}")
        );
        
        return config;
    }
}

/**
 * 自定義水平分片算法
 * 實(shí)現(xiàn)基于用戶(hù)ID的取模分片
 */
@Component
public class UserShardingAlgorithm implements PreciseShardingAlgorithm<Long> {
    
    /**
     * 執(zhí)行精確分片計(jì)算
     * @param availableTargetNames 可用的目標(biāo)分片名稱(chēng)集合
     * @param shardingValue 分片值對(duì)象
     * @return 目標(biāo)分片名稱(chēng)
     */
    @Override
    public String doSharding(Collection<String> availableTargetNames, 
                           PreciseShardingValue<Long> shardingValue) {
        
        Long userId = shardingValue.getValue();
        // 基于用戶(hù)ID取模運(yùn)算確定分片
        int shardIndex = (int) (userId % availableTargetNames.size());
        
        String[] targetNames = availableTargetNames.toArray(new String[0]);
        String targetShardName = targetNames[shardIndex];
        
        // 記錄分片路由信息用于調(diào)試
        System.out.println("User ID: " + userId + " routed to: " + targetShardName);
        
        return targetShardName;
    }
}

/**
 * 范圍分片算法實(shí)現(xiàn)
 * 根據(jù)訂單創(chuàng)建時(shí)間進(jìn)行分片
 */
@Component
public class OrderRangeShardingAlgorithm implements RangeShardingAlgorithm<Date> {
    
    /**
     * 執(zhí)行范圍分片計(jì)算
     * @param availableTargetNames 可用目標(biāo)分片集合
     * @param shardingValue 包含范圍條件的分片值
     * @return 匹配的分片名稱(chēng)集合
     */
    @Override
    public Collection<String> doSharding(Collection<String> availableTargetNames,
                                       RangeShardingValue<Date> shardingValue) {
        
        Collection<String> result = new ArrayList<>();
        Range<Date> valueRange = shardingValue.getValueRange();
        
        // 定義時(shí)間分片邊界（以月為單位）
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(valueRange.lowerEndpoint());
        int startMonth = calendar.get(Calendar.MONTH);
        
        calendar.setTime(valueRange.upperEndpoint());
        int endMonth = calendar.get(Calendar.MONTH);
        
        // 根據(jù)時(shí)間范圍確定涉及的分片
        for (String shardName : availableTargetNames) {
            int shardMonth = Integer.parseInt(shardName.substring(shardName.length() - 1));
            if (shardMonth >= startMonth && shardMonth <= endMonth) {
                result.add(shardName);
            }
        }
        
        return result;
    }
}

/**
 * 復(fù)合分片鍵算法實(shí)現(xiàn)
 * 基于用戶(hù)ID和訂單類(lèi)型進(jìn)行復(fù)合分片
 */
@Component
public class CompositeShardingAlgorithm implements ComplexKeysShardingAlgorithm<String> {
    
    /**
     * 執(zhí)行復(fù)合鍵分片計(jì)算
     * @param availableTargetNames 可用分片目標(biāo)集合
     * @param shardingValue 復(fù)合分片鍵值對(duì)象
     * @return 目標(biāo)分片名稱(chēng)集合
     */
    @Override
    public Collection<String> doSharding(Collection<String> availableTargetNames,
                                       ComplexKeysShardingValue<String> shardingValue) {
        
        Collection<String> result = new ArrayList<>();
        
        // 獲取用戶(hù)ID分片鍵值
        Collection<Long> userIds = shardingValue.getColumnNameAndShardingValuesMap()
            .get("user_id");
        
        // 獲取訂單類(lèi)型分片鍵值
        Collection<String> orderTypes = shardingValue.getColumnNameAndShardingValuesMap()
            .get("order_type");
        
        // 基于復(fù)合鍵計(jì)算分片位置
        for (Long userId : userIds) {
            for (String orderType : orderTypes) {
                // 組合計(jì)算哈希值確定分片
                int hashCode = (userId.toString() + orderType).hashCode();
                int shardIndex = Math.abs(hashCode) % availableTargetNames.size();
                
                String[] targets = availableTargetNames.toArray(new String[0]);
                result.add(targets[shardIndex]);
            }
        }
        
        return result;
    }
}

/**
 * 分片性能監(jiān)控和優(yōu)化配置
 * 提供分片執(zhí)行狀態(tài)的監(jiān)控能力
 */
@Component
public class ShardingPerformanceMonitor {
    
    private final Logger logger = LoggerFactory.getLogger(ShardingPerformanceMonitor.class);
    
    /**
     * 監(jiān)控分片查詢(xún)執(zhí)行情況
     * @param sql 執(zhí)行的SQL語(yǔ)句
     * @param shardingResults 分片執(zhí)行結(jié)果
     */
    public void monitorShardingExecution(String sql, Map<String, Object> shardingResults) {
        
        long startTime = System.currentTimeMillis();
        
        // 統(tǒng)計(jì)涉及的分片數(shù)量
        int shardCount = shardingResults.size();
        
        // 記錄執(zhí)行時(shí)間和分片分布
        shardingResults.forEach((shardName, result) -> {
            logger.info("Shard: {} executed SQL: {} with result count: {}", 
                       shardName, sql, getResultCount(result));
        });
        
        long executionTime = System.currentTimeMillis() - startTime;
        
        // 性能告警檢查
        if (executionTime > 1000) { // 超過(guò)1秒進(jìn)行告警
            logger.warn("Slow sharding query detected. SQL: {}, " +
                       "Execution time: {}ms, Shard count: {}", 
                       sql, executionTime, shardCount);
        }
        
        // 分片均勻性檢查
        checkShardingBalance(shardingResults);
    }
    
    /**
     * 檢查分片數(shù)據(jù)分布均勻性
     */
    private void checkShardingBalance(Map<String, Object> shardingResults) {
        List<Integer> counts = shardingResults.values().stream()
            .mapToInt(this::getResultCount)
            .boxed()
            .collect(Collectors.toList());
        
        int maxCount = Collections.max(counts);
        int minCount = Collections.min(counts);
        
        // 如果最大值和最小值差異過(guò)大，記錄告警
        if (maxCount > minCount * 2) {
            logger.warn("Unbalanced sharding detected. Max: {}, Min: {}", maxCount, minCount);
        }
    }
    
    private int getResultCount(Object result) {
        if (result instanceof Collection) {
            return ((Collection<?>) result).size();
        }
        return 1;
    }
}

/**
 * 電商訂單分片配置實(shí)現(xiàn)
 * 結(jié)合用戶(hù)ID和創(chuàng)建時(shí)間的分片策略
 */
@Configuration
public class ECommerceShardingConfig {
    
    /**
     * 配置訂單表分片規(guī)則
     * 基于用戶(hù)ID進(jìn)行數(shù)據(jù)庫(kù)分片，基于創(chuàng)建時(shí)間進(jìn)行表分片
     */
    @Bean
    public ShardingRuleConfiguration orderShardingRule() {
        ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
        
        // 配置訂單表規(guī)則
        TableRuleConfiguration orderTableRule = new TableRuleConfiguration();
        orderTableRule.setLogicTable("t_order");
        orderTableRule.setActualDataNodes("order_db_${0..3}.t_order_${2023..2024}${01..12}");
        
        // 數(shù)據(jù)庫(kù)分片策略：基于用戶(hù)ID取模
        InlineShardingStrategyConfiguration dbShardingStrategy = 
            new InlineShardingStrategyConfiguration("user_id", "order_db_${user_id % 4}");
        orderTableRule.setDatabaseShardingStrategyConfig(dbShardingStrategy);
        
        // 表分片策略：基于創(chuàng)建時(shí)間按月分片
        StandardShardingStrategyConfiguration tableShardingStrategy = 
            new StandardShardingStrategyConfiguration("create_time", new OrderTimeShardingAlgorithm());
        orderTableRule.setTableShardingStrategyConfig(tableShardingStrategy);
        
        // 配置主鍵生成策略
        orderTableRule.setKeyGeneratorConfig(new KeyGeneratorConfiguration("SNOWFLAKE", "order_id"));
        
        shardingRuleConfig.getTableRuleConfigs().add(orderTableRule);
        return shardingRuleConfig;
    }
    
    /**
     * 訂單業(yè)務(wù)服務(wù)層實(shí)現(xiàn)
     * 展示分片環(huán)境下的業(yè)務(wù)操作
     */
    @Service
    public class OrderService {
        
        @Autowired
        private OrderMapper orderMapper;
        
        /**
         * 創(chuàng)建訂單（自動(dòng)路由到正確分片）
         */
        public void createOrder(Order order) {
            // ShardingSphere會(huì)自動(dòng)根據(jù)user_id和create_time路由到正確的分片
            orderMapper.insert(order);
        }
        
        /**
         * 查詢(xún)用戶(hù)訂單（單分片查詢(xún)）
         */
        public List<Order> getUserOrders(Long userId) {
            // 查詢(xún)會(huì)自動(dòng)路由到用戶(hù)對(duì)應(yīng)的數(shù)據(jù)庫(kù)分片
            return orderMapper.selectByUserId(userId);
        }
        
        /**
         * 按時(shí)間范圍查詢(xún)訂單（可能涉及多個(gè)分片）
         */
        public List<Order> getOrdersByTimeRange(Date startTime, Date endTime) {
            // ShardingSphere會(huì)自動(dòng)識(shí)別涉及的時(shí)間分片并合并結(jié)果
            return orderMapper.selectByTimeRange(startTime, endTime);
        }
    }
}