import 'package:dio/dio.dart';
import 'package:flutter/foundation.dart';
import 'package:network_info_plus/network_info_plus.dart';

/// 局域网 NAS IP 探测（结果仅存内存静态字段）。
class UtilSearchNasIp {
  UtilSearchNasIp._();

  static const String _defaultPreUrl = 'http://192.168.1.';
  static const String _probePath =
      ':5666/sac/rpcproxy/v1/new-user-guide/status';
  static const Duration _timeout = Duration(seconds: 1);

  /// 命中的 NAS IPv4（仅内存，进程内有效）。
  static String? nasIp;

  /// 并发扫同网段 1～255，超时 1s；首个有 HTTP 响应者写入 [nasIp] 并返回。
  static Future<String?> discover() async {
    if (nasIp != null && nasIp!.isNotEmpty) {
      return nasIp;
    }

    final startedAt = DateTime.now();
    final preUrl = await _resolvePreUrl();
    final dio = Dio(
      BaseOptions(
        connectTimeout: _timeout,
        receiveTimeout: _timeout,
        sendTimeout: _timeout,
        validateStatus: (_) => true,
      ),
    );
    final cancelToken = CancelToken();

    try {
      await Future.wait([
        for (var host = 1; host <= 255; host++)
          _probeHost(
            dio: dio,
            cancelToken: cancelToken,
            preUrl: preUrl,
            host: host,
            startedAt: startedAt,
          ),
      ]);
      if (nasIp == null) {
        final elapsedMs = DateTime.now().difference(startedAt).inMilliseconds;
        debugPrint('NAS 探测未命中，总耗时: ${elapsedMs}ms');
      }
      return nasIp;
    } finally {
      dio.close(force: true);
    }
  }

  /// 由本机 Wi‑Fi IPv4 推导 `http://a.b.c.`，失败则用默认网段。
  static Future<String> _resolvePreUrl() async {
    try {
      final wifiIp = await NetworkInfo().getWifiIP();
      if (wifiIp == null || wifiIp.isEmpty) return _defaultPreUrl;
      final parts = wifiIp.split('.');
      if (parts.length != 4) return _defaultPreUrl;
      return 'http://${parts[0]}.${parts[1]}.${parts[2]}.';
    } catch (_) {
      return _defaultPreUrl;
    }
  }

  /// 探测单个主机；任意 HTTP 响应视为命中。
  static Future<void> _probeHost({
    required Dio dio,
    required CancelToken cancelToken,
    required String preUrl,
    required int host,
    required DateTime startedAt,
  }) async {
    if (cancelToken.isCancelled || nasIp != null) return;

    final target = '$preUrl$host$_probePath';
    try {
      await dio.get<dynamic>(target, cancelToken: cancelToken);
      _onHit(preUrl, host, cancelToken, startedAt);
    } on DioException catch (error) {
      if (error.type == DioExceptionType.cancel) return;
      // 带 response 的 DioException 也表示已连通
      if (error.response != null) {
        _onHit(preUrl, host, cancelToken, startedAt);
      }
    } catch (_) {
      // 超时 / 连接失败：未命中
    }
  }

  /// 记录命中：写 [nasIp]、打印 IP 与总耗时，并取消其余请求。
  static void _onHit(
    String preUrl,
    int host,
    CancelToken cancelToken,
    DateTime startedAt,
  ) {
    if (nasIp != null) return;
    final ip = '${_hostPrefix(preUrl)}$host';
    nasIp = ip;
    final elapsedMs = DateTime.now().difference(startedAt).inMilliseconds;
    debugPrint('NAS IP: $ip，探测总耗时: ${elapsedMs}ms');
    if (!cancelToken.isCancelled) {
      cancelToken.cancel('nas-found');
    }
  }

  /// `http://192.168.1.` → `192.168.1.`
  static String _hostPrefix(String preUrl) {
    return preUrl.replaceFirst(RegExp(r'^https?://'), '');
  }
}

// ---------------------------------------------------------------------------
// 调用案例
// ---------------------------------------------------------------------------
//
// 1) Auth 页静默探测（不阻塞登录）：
//
//   import 'dart:async';
//   import 'package:recording_tool/core/utils/util_search_nasIp.dart';
//
//   WidgetsBinding.instance.addPostFrameCallback((_) {
//     unawaited(UtilSearchNasIp.discover());
//   });
//
// 2) 业务侧读取已命中 IP：
//
//   final ip = UtilSearchNasIp.nasIp;
//   if (ip != null) {
//     final base = 'http://$ip:5666';
//     // 使用 base 访问 NAS...
//   }
//
// 3) 主动等待探测结果（少用，会阻塞当前异步流程）：
//
//   final ip = await UtilSearchNasIp.discover();
//   debugPrint('result: $ip');
//
