import 'dart:io';
import 'dart:async';
import 'package:kaer_with_panels/app/utils/kr_log_util.dart';

/// 延迟测试工具类
/// 提供真实的 TCP 连接延迟测试功能
class KRLatencyTester {
  /// 测试单个节点的延迟
  /// 
  /// 参数:
  ///   - host: 主机地址
  ///   - port: 端口号
  ///   - timeout: 超时时间（毫秒）
  /// 
  /// 返回:
  ///   - 延迟时间（毫秒），如果失败返回 65535
  static Future<int> testNode({
    required String host,
    required int port,
    int timeout = 5000,
  }) async {
    try {
      final stopwatch = Stopwatch()..start();
      
      final socket = await Socket.connect(
        host,
        port,
        timeout: Duration(milliseconds: timeout),
      ).timeout(Duration(milliseconds: timeout));
      
      stopwatch.stop();
      
      // 立即关闭连接
      await socket.close();
      socket.destroy();
      
      final latency = stopwatch.elapsedMilliseconds;
      KRLogUtil.kr_i('✅ 延迟测试成功: $host:$port = ${latency}ms', tag: 'KRLatencyTester');
      
      return latency;
    } catch (e) {
      KRLogUtil.kr_w('❌ 延迟测试失败: $host:$port - $e', tag: 'KRLatencyTester');
      return 65535; // 测试失败返回最大值
    }
  }

  /// 批量测试多个节点的延迟
  /// 
  /// 参数:
  ///   - nodes: 节点列表，格式为 [{"host": "example.com", "port": 443}]
  ///   - concurrency: 并发数量
  ///   - timeout: 超时时间（毫秒）
  /// 
  /// 返回:
  ///   - 测试结果映射，键为 "host:port"，值为延迟时间
  static Future<Map<String, int>> testMultipleNodes({
    required List<MapEntry<String, SocketAddress>> nodes,
    int concurrency = 10,
    int timeout = 5000,
  }) async {
    final results = <String, int>{};
    final semaphore = Completer<void>();
    var activeCount = 0;
    var completedCount = 0;

    KRLogUtil.kr_i('🚀 开始批量延迟测试，共 ${nodes.length} 个节点，并发数: $concurrency', tag: 'KRLatencyTester');

    Future<void> processNode(MapEntry<String, SocketAddress> node) async {
      try {
        final host = node.value.address;
        final port = node.value.port;
        final key = node.key;
        
        final latency = await testNode(
          host: host,
          port: port,
          timeout: timeout,
        );
        
        results[key] = latency;
      } catch (e) {
        results[node.key] = 65535;
        KRLogUtil.kr_e('❌ 节点测试异常: ${node.key} - $e', tag: 'KRLatencyTester');
      } finally {
        completedCount++;
        activeCount--;
        
        if (completedCount >= nodes.length) {
          semaphore.complete();
        }
      }
    }

    // 分批处理节点
    for (var i = 0; i < nodes.length; i += concurrency) {
      final batch = nodes.skip(i).take(concurrency);
      
      for (final node in batch) {
        activeCount++;
        processNode(node);
      }
      
      // 等待当前批次完成
      if (i + concurrency < nodes.length) {
        await Future.delayed(Duration(milliseconds: 100));
      }
    }

    // 等待所有任务完成
    await semaphore.future;
    
    KRLogUtil.kr_i('✅ 批量延迟测试完成，成功: ${results.length} 个', tag: 'KRLatencyTester');
    return results;
  }
}

/// Socket 地址类
/// 表示网络地址和端口的组合
class SocketAddress {
  final String address;
  final int port;

  SocketAddress(this.address, this.port);

  @override
  String toString() => '$address:$port';
}