import 'package:get/get.dart';
import 'dart:async';
import '../../../routes/app_routes.dart';
import '../../../core/utils/logger.dart';
import 'package:flutter/material.dart';
import '../../explore/controllers/explore_controller.dart';
import 'package:classic_bluetooth/classic_bluetooth.dart' show BluetoothDevice;
import '../../../data/services/bluetooth_manager.dart';
import '../../../data/services/ble_manager.dart';

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

/// 主页控制器，管理设备连接状态和信息展示
class HomeController extends GetxController {
  static HomeController get to => Get.find();
  
  // 依赖的控制器
  final ExploreController exploreController = Get.find<ExploreController>();

  // 连接状态相关
  final _connectionStatus = ConnectionStatus.disconnected.obs;
  final _connectionErrorMsg = ''.obs;
  final _bluetoothState = 'unknown'.obs;
  
  // Getter方法
  ConnectionStatus get connectionStatus => _connectionStatus.value;
  String get connectionErrorMsg => _connectionErrorMsg.value;
  String get bluetoothState => _bluetoothState.value;
  BluetoothDevice? get currentDevice => _bluetoothManager.currentDevice;
  DeviceInfo? get deviceInfo => _bleManager.deviceInfo;
  bool get isConnected => currentDevice != null;
  
  // 设备详细信息的getter，从deviceInfo获取数据
  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 ?? '';


  
  // 监听和订阅
  Worker? _deviceInfoWorker;
  Worker? _bluetoothStateWorker;
  Worker? _deviceWorker;
  
  // 蓝牙服务
  final _bluetoothManager = Get.find<BluetoothManager>();
  final _bleManager = Get.find<BleManager>();
  @override
  void onInit() {
    super.onInit();
    _initWithCachedInfo();
  }
  
  @override
  void onClose() {
    _deviceInfoWorker?.dispose();
    _bluetoothStateWorker?.dispose();
    _deviceWorker?.dispose();
    super.onClose();
  }

  /// 使用缓存的蓝牙设备信息初始化
  void _initWithCachedInfo() {
    // 使用蓝牙服务中的当前状态
    _bluetoothState.value = _bluetoothManager.bluetoothState;
    
    // 根据当前设备状态设置连接状态
    if (currentDevice != null) {
      _connectionStatus.value = ConnectionStatus.connected;
      _connectionErrorMsg.value = '';
      Logger.info('主页加载缓存设备信息: ${currentDevice!.name}');
    } else {
      _connectionStatus.value = ConnectionStatus.disconnected;
      if (_bluetoothState.value == 'off') {
        _connectionErrorMsg.value = '蓝牙未开启';
      } else {
        _connectionErrorMsg.value = '未连接到设备';
      }
    }
    
    // 设置监听器监听蓝牙服务状态变化
    _setupStateListeners();
  }
  
  /// 设置状态监听器
  void _setupStateListeners() {
    // 设备信息监听 - 设备信息更新时自动触发UI更新
    _deviceInfoWorker = ever(_bleManager.deviceInfo.obs, (DeviceInfo? info) {
      if (info != null) {
        Logger.info('主页更新设备信息: ${info.toString()}');
      } else {
        Logger.info('主页清空设备信息');
      }
      update();
    });
    
    // 蓝牙状态监听
    _bluetoothStateWorker = ever(_bluetoothManager.bluetoothState.obs, (String state) {
      _bluetoothState.value = state;
      
      // 如果蓝牙关闭，更新错误信息
      if (state == 'off') {
        _connectionErrorMsg.value = '蓝牙未开启';
        _connectionStatus.value = ConnectionStatus.disconnected;
      }
      
      update();
    });
    
    // 设备连接状态监听 - 直接监听设备变化
    _deviceWorker = ever(_bluetoothManager.currentDeviceRx, (BluetoothDevice? device) {
      if (device != null) {
        // 设备已连接
        if (_connectionStatus.value != ConnectionStatus.connected) {
          _connectionStatus.value = ConnectionStatus.connected;
          _connectionErrorMsg.value = '';
          
          Logger.info('主页检测到设备已连接: ${device.name}');
        }
      } else if (_connectionStatus.value == ConnectionStatus.connected) {
        // 设备已断开
        _connectionStatus.value = ConnectionStatus.disconnected;
        _connectionErrorMsg.value = '设备已断开连接';
        
        Logger.info('主页检测到设备已断开连接');
      }
      
      update();
    });
  }
  
  /// 刷新设备连接状态
  /// 注意：此方法不会主动刷新设备，只更新UI状态
  Future<void> refreshDeviceConnection() async {
    // 更新当前状态以反映UI变化
    bool hasDevice = currentDevice != null;
    
    if (hasDevice) {
      _connectionStatus.value = ConnectionStatus.connected;
      _connectionErrorMsg.value = '';
      Logger.info('使用缓存设备信息: ${currentDevice!.name}');
    } else {
      if (_bluetoothState.value == 'off') {
        _connectionErrorMsg.value = '蓝牙未开启';
      } else {
        _connectionErrorMsg.value = '未连接到设备';
      }
      _connectionStatus.value = ConnectionStatus.disconnected;
    }
    
    // 刷新UI
    update();
  }

  // 导航和功能方法
  
  /// 重新扫描设备
  void rescanDevices() {
    Get.toNamed(Routes.pairing);
  }

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

  /// 打开AI伴侣功能
  void openAIGirlfriend() {
    exploreController.onAIFeatureTap(2);
  }

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

  // UI辅助方法
  
  /// 获取连接状态对应的颜色
  Color getConnectionStatusColor() {
    switch (_connectionStatus.value) {
      case ConnectionStatus.connected:
        return Colors.green;
      case ConnectionStatus.connecting:
        return Colors.amber;
      case ConnectionStatus.failed:
        return Colors.red;
      case ConnectionStatus.disconnected:
      default:
        return Colors.grey;
    }
  }

  /// 获取连接状态对应的文本
  String getConnectionStatusText() {
    if (bluetoothState == 'off') {
      return 'bluetoothOff'.tr;
    }

    switch (_connectionStatus.value) {
      case ConnectionStatus.connected:
        return 'connected'.tr;
      case ConnectionStatus.connecting:
        return 'connecting'.tr;
      case ConnectionStatus.failed:
        return 'connectionFailure'.tr;
      case ConnectionStatus.disconnected:
      default:
        return 'unconnected'.tr;
    }
  }

  /// 获取设备名称
  String getDeviceName() {
    return currentDevice?.name ?? 'unknownEquipment'.tr;
  }

  /// 获取信号强度（模拟数据）
  String getSignalStrength() {
    if (!isConnected) {
      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?.address ?? currentDevice?.address ?? 'unknown'.tr;
  }
  
  /// 获取设备电量文本
  String getBatteryText() {
    return deviceInfo?.batteryLevel != null && deviceInfo!.batteryLevel > 0 
           ? '${deviceInfo!.batteryLevel}%' 
           : 'unknown'.tr;
  }
  
  /// 获取耳机左右电量文本
  String getEarbudsText() {
    if (deviceInfo == null || (deviceInfo!.leftEarBattery <= 0 && deviceInfo!.rightEarBattery <= 0)) {
      return 'unknown'.tr;
    }
    
    String leftStatus = deviceInfo!.leftEarBattery > 0 ? '${deviceInfo!.leftEarBattery}%' : 'N/A';
    String rightStatus = deviceInfo!.rightEarBattery > 0 ? '${deviceInfo!.rightEarBattery}%' : 'N/A';
    
    leftStatus = deviceInfo!.leftEarCharging ? '$leftStatus ⚡' : leftStatus;
    rightStatus = deviceInfo!.rightEarCharging ? '$rightStatus ⚡' : rightStatus;
    
    return '左耳: $leftStatus / 右耳: $rightStatus';
  }
  
  /// 获取充电仓电量文本
  String getCaseText() {
    if (deviceInfo == null || deviceInfo!.caseBattery <= 0) {
      return 'unknown'.tr;
    }
    
    String caseStatus = '${deviceInfo!.caseBattery}%';
    if (deviceInfo!.caseCharging) {
      caseStatus = '$caseStatus ⚡';
    }
    
    return '充电仓: $caseStatus';
  }
  
  /// 获取充电状态文本
  String getChargingText() {
    if (deviceInfo == null) {
      return 'unknown'.tr;
    }
    
    bool isCharging = deviceInfo!.leftEarCharging || 
                       deviceInfo!.rightEarCharging || 
                       deviceInfo!.caseCharging;
    
    return isCharging ? 'charging'.tr : 'notCharging'.tr;
  }
  
  /// 获取设备版本文本
  String getVersionText() {
    return deviceInfo?.firmwareVersion.isNotEmpty == true ? 
           deviceInfo!.firmwareVersion : 'unknown'.tr;
  }
  
}