import 'dart:async';
import 'package:connectivity_plus/connectivity_plus.dart';
import 'package:flutter/material.dart';
import 'package:get/get.dart';
import 'package:vbvs_app/enum/NetworkType.dart';
import 'package:vbvs_app/enum/SignalLevel.dart';
import 'package:vbvs_app/pages/mh_page/test/WebviewTestModel.dart';

class NetworkStatusController extends GetxController {
  static NetworkStatusController get instance =>
      Get.find<NetworkStatusController>();

  // 响应式变量
  final Rx<NetworkType> _networkType = NetworkType.none.obs;
  final Rx<SignalLevel> _signalLevel = SignalLevel.none.obs;
  final RxInt _signalStrength = 0.obs;
  final RxBool _isLoading = true.obs;

  // 上一次发送的网络状态（用于避免重复发送相同状态）
  String _lastSentNetworkType = '';
  int _lastSentSignalStrength = 0;

  // 实例
  final Connectivity _connectivity = Connectivity();
  StreamSubscription? _subscription;

  // Getters
  NetworkType get networkType => _networkType.value;
  SignalLevel get signalLevel => _signalLevel.value;
  int get signalStrength => _signalStrength.value;
  bool get isLoading => _isLoading.value;

  // 便利方法
  bool get isUsingWifi => networkType == NetworkType.wifi;
  bool get isUsingCellular => networkType == NetworkType.cellular;
  bool get isConnected => networkType != NetworkType.none;

  @override
  void onInit() {
    super.onInit();
    print('网络-----> NetworkStatusController onInit() 开始执行');
    _initNetworkMonitoring();
  }

  Future<void> _initNetworkMonitoring() async {
    _isLoading.value = true;

    try {
      // 初始检查
      await _checkNetworkStatus();

      // 监听网络变化
      _subscription = _connectivity.onConnectivityChanged
          .listen((List<ConnectivityResult> results) {
        _updateNetworkType(results);
        _checkNetworkStatus();
      });

      // 定期刷新网络状态（每10秒）
      Timer.periodic(const Duration(seconds: 10), (timer) {
        _checkNetworkStatus();
      });
      
      print('网络-----> 网络监控初始化完成');
    } catch (e) {
      print('网络-----> 网络监控初始化失败: $e');
    } finally {
      _isLoading.value = false;
    }
  }

  Future<void> _checkNetworkStatus() async {
    try {
      // 获取连接类型
      final connectivityResults = await _connectivity.checkConnectivity();
      _updateNetworkType(connectivityResults);

      // 根据网络类型设置信号强度
      _updateSignalLevelAndStrength();

      // 打印当前网络状态
      _logCurrentNetworkStatus();

      // 发送网络状态到 WebView
      _sendNetworkStatusToWebView();
    } catch (e) {
      print('网络-----> 检查网络状态失败: $e');
    }
  }

  /// 发送网络状态到 WebView
  void _sendNetworkStatusToWebView() {
    try {
      // 检查网络状态是否发生变化
      String currentNetworkType = _getNetworkTypeString();
      int currentSignalStrength = _signalStrength.value;

      // 如果状态没有变化，不重复发送
      // if (currentNetworkType == _lastSentNetworkType && 
      //     currentSignalStrength == _lastSentSignalStrength) {
      //   return;
      // }

      // 更新上一次发送的状态
      _lastSentNetworkType = currentNetworkType;
      _lastSentSignalStrength = currentSignalStrength;

      // 准备要发送的数据
      Map<String, dynamic> networkData = {
        'networkType': currentNetworkType,
        'signalStrength': currentSignalStrength,
      };

      print('网络-----> 发送网络状态到 WebView: $networkData');

      // 通过 WebviewTestController 发送到 WebView
      if (Get.isRegistered<WebviewTestController>()) {
        final webviewTestController = Get.find<WebviewTestController>();
        
        // 检查 jsbridge 是否可用
        if (webviewTestController.web.jsbridge?.dart != null) {
          webviewTestController.web.jsbridge?.dart?.switchNetWork(networkData);
          print('网络-----> 网络状态已成功发送到 WebView');
        } else {
          print('网络-----> WebView jsbridge 不可用');
        }
      } else {
        print('网络-----> WebviewTestController 未注册');
      }
    } catch (e) {
      print('网络-----> 发送网络状态到 WebView 失败: $e');
    }
  }

  /// 获取网络类型字符串
  String _getNetworkTypeString() {
    if (isUsingWifi) {
      return 'wifi';
    } else if (isUsingCellular) {
      return 'cellular';
    } else {
      return 'none';
    }
  }

  void _logCurrentNetworkStatus() {
    print('网络-----> 当前网络类型: ${_networkType.value.description}');
    print('网络-----> 当前信号等级: ${_signalLevel.value.description}');
    print('网络-----> 当前信号强度: ${_signalStrength.value}dBm');
    print('网络-----> 是否连接: ${isConnected ? "是" : "否"}');
    print('网络-----> 发送到WebView的类型: ${_getNetworkTypeString()}');
  }

  void _updateNetworkType(List<ConnectivityResult> results) {
    if (results.isEmpty) {
      _networkType.value = NetworkType.none;
      print('网络-----> 网络类型变化: 无网络连接');
      return;
    }

    ConnectivityResult mainResult = results.first;

    // 优先选择WiFi
    if (results.contains(ConnectivityResult.wifi)) {
      mainResult = ConnectivityResult.wifi;
    } else if (results.contains(ConnectivityResult.mobile)) {
      mainResult = ConnectivityResult.mobile;
    }

    NetworkType newType;

    switch (mainResult) {
      case ConnectivityResult.wifi:
        newType = NetworkType.wifi;
        break;
      case ConnectivityResult.mobile:
        newType = NetworkType.cellular;
        break;
      case ConnectivityResult.ethernet:
        newType = NetworkType.ethernet;
        break;
      case ConnectivityResult.bluetooth:
        newType = NetworkType.bluetooth;
        break;
      case ConnectivityResult.vpn:
        newType = NetworkType.vpn;
        break;
      case ConnectivityResult.other:
        newType = NetworkType.other;
        break;
      case ConnectivityResult.none:
      default:
        newType = NetworkType.none;
        break;
    }

    if (newType != _networkType.value) {
      _networkType.value = newType;
      print('网络-----> 网络类型变化: ${newType.description}');
    }
  }

  void _updateSignalLevelAndStrength() {
    // 根据网络类型设置信号等级和强度
    switch (_networkType.value) {
      case NetworkType.none:
        _signalLevel.value = SignalLevel.none;
        _signalStrength.value = 0;
        break;

      case NetworkType.wifi:
        // WiFi连接
        _signalLevel.value = SignalLevel.good;
        _signalStrength.value = -65; // WiFi正常连接强度
        break;

      case NetworkType.cellular:
        // 移动网络
        _signalLevel.value = SignalLevel.good;
        _signalStrength.value = -85; // 移动网络正常强度
        break;

      default:
        // 其他网络类型
        _signalLevel.value = SignalLevel.good;
        _signalStrength.value = -60;
        break;
    }

    print(
        '网络-----> 信号等级: ${_signalLevel.value.description}, 强度: ${_signalStrength.value}dBm');
  }

  /// 手动刷新网络状态并发送到 WebView
  Future<void> refresh() async {
    await _checkNetworkStatus();
  }

  /// 获取网络状态描述
  String getNetworkStatusDescription() {
    if (isUsingWifi) {
      return 'WiFi，信号${signalLevel.description}';
    } else if (isUsingCellular) {
      return '移动网络，信号${signalLevel.description}';
    } else {
      return '无网络连接';
    }
  }

  /// 获取网络状态颜色
  Color getNetworkStatusColor() {
    switch (signalLevel) {
      case SignalLevel.excellent:
      case SignalLevel.good:
        return Colors.green;
      case SignalLevel.fair:
        return Colors.orange;
      case SignalLevel.poor:
      case SignalLevel.none:
        return Colors.red;
    }
  }

  /// 获取WiFi图标
  IconData getWifiIcon() {
    if (!isUsingWifi) return Icons.signal_wifi_off;

    switch (signalLevel) {
      case SignalLevel.excellent:
        return Icons.signal_wifi_4_bar;
      case SignalLevel.good:
        return Icons.signal_wifi_4_bar;
      case SignalLevel.fair:
        return Icons.signal_wifi_4_bar;
      case SignalLevel.poor:
        return Icons.signal_wifi_4_bar;
      case SignalLevel.none:
        return Icons.signal_wifi_off;
    }
  }

  /// 获取蜂窝网络图标
  IconData getCellularIcon() {
    switch (signalLevel) {
      case SignalLevel.excellent:
      case SignalLevel.good:
        return Icons.signal_cellular_4_bar;
      case SignalLevel.fair:
        return Icons.signal_cellular_4_bar;
      case SignalLevel.poor:
        return Icons.signal_cellular_4_bar;
      case SignalLevel.none:
        return Icons.signal_cellular_0_bar;
    }
  }

  /// 获取当前应该显示的图标
  IconData getCurrentNetworkIcon() {
    if (isUsingWifi) {
      return getWifiIcon();
    } else if (isUsingCellular) {
      return getCellularIcon();
    } else {
      return Icons.signal_wifi_off;
    }
  }

  /// 获取当前网络状态数据（供外部调用）
  Map<String, dynamic> getCurrentNetworkData() {
    return {
      'networkType': _getNetworkTypeString(),
      'signalStrength': signalStrength,
    };
  }

  /// 手动发送网络状态到 WebView（供外部调用）
  void sendNetworkStatus() {
    _sendNetworkStatusToWebView();
  }

  @override
  void onClose() {
    _subscription?.cancel();
    print('网络-----> NetworkStatusController 已关闭');
    super.onClose();
  }
}