import 'package:get/get.dart';
import 'dart:async';
import '../../../routes/app_routes.dart';
import '../../../core/utils/logger.dart';
import 'package:flutter/material.dart';
import '../../../data/services/bluetooth_manager.dart';
import '../../../data/services/ble_manager.dart';

/// 连接状态枚举
enum ConnectionStatus {
  disconnected, // 未连接
  connecting, // 连接中
  connected, // 已连接
  failed // 连接失败
}

/// 主页控制器，管理设备连接状态和信息展示
class HomeController extends GetxController {
  static const String _tag = 'HomeCtrl';
  static HomeController get to => Get.find();

  // 连接状态相关
  final _isFullyConnected = false.obs;
  
  // Getter方法
  bool get isFullyConnected => _isFullyConnected.value;
  RxBool get isFullyConnectedRx => _isFullyConnected;  // 响应式getter供UI使用
  BluetoothDevice? get currentDevice => _bluetoothManager.currentDevice;
  Rx<DeviceInfo?> get deviceInfo => _bleManager.deviceInfo;

  // 设备详细信息的getter，从deviceInfo获取数据
  final leftEarBattery = 0.obs;
  final rightEarBattery = 0.obs;
  final caseBattery = 0.obs;
  final leftEarCharging = false.obs;
  final rightEarCharging = false.obs;
  final caseCharging = false.obs;
  final firmwareVersion = ''.obs;

  // int get leftEarBattery => deviceInfo?.leftEarBattery ?? 0;
  // int get rightEarBattery => deviceInfo?.rightEarBattery ?? 0;
  // int get caseBattery => deviceInfo?.caseBattery ?? 0;
  // bool get leftEarCharging => deviceInfo?.leftEarCharging ?? false;
  // bool get rightEarCharging => deviceInfo?.rightEarCharging ?? false;
  // bool get caseCharging => deviceInfo?.caseCharging ?? false;
  // String get firmwareVersion => deviceInfo?.firmwareVersion ?? '';
  /// 当有新的deviceInfo时更新所有Observable变量
  void updateDeviceInfo(DeviceInfo? newDeviceInfo) {
    leftEarBattery.value = newDeviceInfo?.leftEarBattery ?? 0;
    rightEarBattery.value = newDeviceInfo?.rightEarBattery ?? 0;
    caseBattery.value = newDeviceInfo?.caseBattery ?? 0;
    leftEarCharging.value = newDeviceInfo?.leftEarCharging ?? false;
    rightEarCharging.value = newDeviceInfo?.rightEarCharging ?? false;
    caseCharging.value = newDeviceInfo?.caseCharging ?? false;
    firmwareVersion.value = newDeviceInfo?.firmwareVersion ?? '';
  }

  // 监听和订阅
  Worker? _deviceInfoWorker;
  Worker? _classicBluetoothWorker;
  Worker? _bleConnectionWorker;

  // 蓝牙服务
  final _bluetoothManager = Get.find<BluetoothManager>();
  final _bleManager = Get.find<BleManager>();
  @override
  void onInit() {
    super.onInit();
    _initWithCachedInfo();
  }

  @override
  void onClose() {
    _deviceInfoWorker?.dispose();
    _classicBluetoothWorker?.dispose();
    _bleConnectionWorker?.dispose();
    super.onClose();
  }

  /// 初始化
  void _initWithCachedInfo() {
    // 设置监听器
    _setupStateListeners();
    
    // 延迟检查初始连接状态，确保监听器已经设置
    Future.delayed(const Duration(milliseconds: 100), () {
      _checkConnectionStatus();
    });
  }

  /// 设置状态监听器
  void _setupStateListeners() {
    // 设备信息监听
    _deviceInfoWorker = ever(_bleManager.deviceInfo, (DeviceInfo? info) {
      if (info != null) {
        Logger.d(_tag, '更新设备信息: ${info.toString()}');
        updateDeviceInfo(info);
      }
      update();
    });

    // 经典蓝牙连接监听
    _classicBluetoothWorker = ever(_bluetoothManager.currentDeviceRx, (BluetoothDevice? device) {
      Logger.d(_tag, '经典蓝牙: ${device != null ? "已连接" : "已断开"}');
      _checkConnectionStatus();
    });
    
    // BLE连接监听
    _bleConnectionWorker = ever(_bleManager.connectionStateRx, (int state) {
      Logger.d(_tag, 'BLE状态变化: $state (${state == 2 ? "已连接" : "未连接"})');
      _checkConnectionStatus();
    });
  }

  /// 刷新设备连接状态
  Future<void> refreshDeviceConnection() async {
    _checkConnectionStatus();
  }

  // 导航和功能方法

  /// 重新扫描设备
  void rescanDevices() {
    Get.toNamed(Routes.pairing);
  }

  /// 打开翻译功能
  void openTranslation() {
    Get.toNamed(Routes.translation);
  }

  /// 展示AI功能
  void exploreAIFeatures() {
    Get.toNamed(Routes.agent);
  }

  // UI辅助方法
  
  /// 检查连接状态
  void _checkConnectionStatus() {
    // 直接检查，不使用延迟
    bool hasClassicBluetooth = currentDevice != null;
    bool hasBleConnection = _bleManager.connectionState == 2; // 直接检查状态值，2 = connected
    
    Logger.d(_tag, '连接状态检查: 经典蓝牙=$hasClassicBluetooth, BLE=$hasBleConnection (状态值=${_bleManager.connectionState})');
    
    bool wasConnected = _isFullyConnected.value;
    bool isNowConnected = hasClassicBluetooth && hasBleConnection;
    
    // 只有状态真正改变时才更新
    if (_isFullyConnected.value != isNowConnected) {
      // 先更新状态
      _isFullyConnected.value = isNowConnected;
      Logger.d(_tag, '连接状态变更: ${wasConnected ? "已连接" : "未连接"} -> ${isNowConnected ? "已连接" : "未连接"}');
      
      // 强制触发响应式更新
      _isFullyConnected.refresh();
      
      // 如果从未连接变为连接，主动获取耳机信息
      if (!wasConnected && isNowConnected) {
        Logger.d(_tag, '设备连接成功，获取耳机信息');
        _bleManager.fetchDeviceInfo();
      }
      
      // 延迟一帧后再次刷新，确保UI更新
      Future.delayed(Duration.zero, () {
        update();
      });
    }
    
    // 总是调用update确保UI刷新
    update();
  }

  /// 获取连接状态对应的颜色
  Color getConnectionStatusColor() {
    return _isFullyConnected.value ? Colors.green : Colors.grey;
  }

  /// 获取连接状态对应的文本
  String getConnectionStatusText() {
    return _isFullyConnected.value ? 'connected'.tr : 'unconnected'.tr;
  }

  /// 判断是否应该显示设备信息（即使未完全连接）
  bool get shouldShowDeviceInfo => currentDevice != null;
  
  /// 获取设备名称
  String getDeviceName() {
    return currentDevice?.name ?? 'unknownEquipment'.tr;
  }

  /// 获取信号强度（模拟数据）
  String getSignalStrength() {
    if (!_isFullyConnected.value) {
      return 'zeroSignal'.tr;
    }

    final random = DateTime.now().millisecondsSinceEpoch % 3;
    switch (random) {
      case 0:
        return 'good'.tr;
      case 1:
        return 'fine'.tr;
      default:
        return 'excellent'.tr;
    }
  }

  /// 获取设备ID
  String getDeviceId() {
    return deviceInfo.value?.address ?? currentDevice?.address ?? 'unknown'.tr;
  }

  /// 获取设备电量文本
  String getBatteryText() {
    return deviceInfo.value?.batteryLevel != null &&
            deviceInfo.value!.batteryLevel > 0
        ? '${deviceInfo.value?.batteryLevel}%'
        : 'unknown'.tr;
  }

  /// 获取耳机左右电量文本
  String getEarbudsText() {
    if (deviceInfo == null ||
        (deviceInfo.value!.leftEarBattery <= 0 &&
                deviceInfo.value!.rightEarBattery <= 0 ||
            deviceInfo.value!.caseBattery > 100)) {
      return 'unknown'.tr;
    }

    String leftStatus = deviceInfo.value!.leftEarBattery > 0
        ? '${deviceInfo.value!.leftEarBattery}%'
        : 'N/A';
    String rightStatus = deviceInfo.value!.rightEarBattery > 0
        ? '${deviceInfo.value!.rightEarBattery}%'
        : 'N/A';

    leftStatus =
        deviceInfo.value!.leftEarCharging ? '$leftStatus ⚡' : leftStatus;
    rightStatus =
        deviceInfo.value!.rightEarCharging ? '$rightStatus ⚡' : rightStatus;

    return '左耳: $leftStatus / 右耳: $rightStatus';
  }

  /// 获取充电仓电量文本
  String getCaseText() {
    if (deviceInfo.value == null ||
        deviceInfo.value!.caseBattery <= 0 ||
        deviceInfo.value!.caseBattery > 100) {
      return 'unknown'.tr;
    }

    String caseStatus = '${deviceInfo.value!.caseBattery}%';
    if (deviceInfo.value!.caseCharging) {
      caseStatus = '$caseStatus ⚡';
    }

    return '充电仓: $caseStatus';
  }

  /// 获取充电状态文本
  String getChargingText() {
    if (deviceInfo == null) {
      return 'unknown'.tr;
    }

    bool isCharging = deviceInfo.value!.leftEarCharging ||
        deviceInfo.value!.rightEarCharging ||
        deviceInfo.value!.caseCharging;

    return isCharging ? 'charging'.tr : 'notCharging'.tr;
  }

  /// 获取设备版本文本
  String getVersionText() {
    return deviceInfo.value?.firmwareVersion.isNotEmpty == true
        ? deviceInfo.value!.firmwareVersion
        : 'unknown'.tr;
  }
}