import 'package:get/get.dart';

import 'dart:io' show Platform;
import 'dart:math';
import 'package:kaer_with_panels/app/utils/kr_network_check.dart';
import 'package:kaer_with_panels/app/utils/kr_log_util.dart';
import 'package:kaer_with_panels/app/routes/app_pages.dart';
import 'package:kaer_with_panels/app/common/app_config.dart';
import 'package:kaer_with_panels/app/common/app_run_data.dart';
import 'package:kaer_with_panels/app/services/singbox_imp/kr_sing_box_imp.dart';
import 'package:kaer_with_panels/app/services/kr_site_config_service.dart';
import 'package:kaer_with_panels/app/services/kr_device_info_service.dart';
import 'package:kaer_with_panels/app/services/api_service/kr_auth_api.dart';
import 'package:kaer_with_panels/app/model/enum/kr_request_type.dart';

import 'package:kaer_with_panels/app/localization/app_translations.dart';
import 'dart:async';

class KRSplashController extends GetxController {
  // 加载状态
  final RxBool kr_isLoading = true.obs;
  
  // 错误状态
  final RxBool kr_hasError = false.obs;
  
  // 错误信息
  final RxString kr_errorMessage = ''.obs;

  // 倒计时
  // final count = 0.obs;
  // 是否正在加载
  final isLoading = true.obs;
  // // 是否初始化成功
  // final isInitialized = false.obs;

  @override
  void onInit() {
    super.onInit();

    // 使用 print 确保日志一定会输出
    print('═══════════════════════════════════════');
    print('🎬 KRSplashController onInit 被调用了！');
    print('═══════════════════════════════════════');

    KRLogUtil.kr_i('═══════════════════════════════════════', tag: 'SplashController');
    KRLogUtil.kr_i('🎬 启动页控制器 onInit', tag: 'SplashController');
    KRLogUtil.kr_i('═══════════════════════════════════════', tag: 'SplashController');

    // 立即初始化网站配置（在任何其他逻辑之前）
    print('🌐 准备调用 _kr_initSiteConfig...');
    // 必须等待网站配置和设备登录完成后，再进行后续初始化
    _kr_initSiteConfig().then((_) {
      print('🔧 网站配置完成，开始调用 _kr_initialize...');
      _kr_initialize();
    });
  }

  /// 初始化网站配置（最优先执行）
  Future<void> _kr_initSiteConfig() async {
    print('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
    print('🌐 【最优先】开始初始化网站配置...');
    print('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');

    KRLogUtil.kr_i('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', tag: 'SplashController');
    KRLogUtil.kr_i('🌐 【最优先】初始化网站配置...', tag: 'SplashController');
    KRLogUtil.kr_i('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', tag: 'SplashController');

    try {
      print('📞 准备调用 KRSiteConfigService().initialize()...');
      final success = await KRSiteConfigService().initialize();
      print('📞 KRSiteConfigService().initialize() 返回: $success');

      if (success) {
        print('✅ 网站配置初始化成功');
        KRLogUtil.kr_i('✅ 网站配置初始化成功', tag: 'SplashController');

        // 检查是否支持设备登录
        await _kr_checkAndPerformDeviceLogin();
      } else {
        print('⚠️ 网站配置初始化失败，将使用默认配置');
        KRLogUtil.kr_w('⚠️ 网站配置初始化失败，将使用默认配置', tag: 'SplashController');
      }
    } catch (e) {
      print('❌ 网站配置初始化异常: $e');
      KRLogUtil.kr_e('❌ 网站配置初始化异常: $e', tag: 'SplashController');
    }

    print('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
    KRLogUtil.kr_i('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', tag: 'SplashController');
  }

  /// 检查并执行设备登录
  Future<void> _kr_checkAndPerformDeviceLogin() async {
    try {
      print('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
      print('🔍 检查是否支持设备登录...');
      print('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');

      final siteConfigService = KRSiteConfigService();

      // 检查是否启用设备登录
      final isDeviceLoginEnabled = siteConfigService.isDeviceLoginEnabled();
      print('📱 设备登录状态: ${isDeviceLoginEnabled ? "已启用" : "未启用"}');
      KRLogUtil.kr_i('📱 设备登录状态: $isDeviceLoginEnabled', tag: 'SplashController');

      if (!isDeviceLoginEnabled) {
        print('⚠️ 设备登录未启用，跳过自动登录');
        KRLogUtil.kr_w('⚠️ 设备登录未启用', tag: 'SplashController');
        return;
      }

      print('✅ 设备登录已启用，开始初始化设备信息...');

      // 初始化设备信息服务
      await KRDeviceInfoService().initialize();

      print('🔐 开始执行设备登录...');
      KRLogUtil.kr_i('🔐 开始执行设备登录', tag: 'SplashController');

      // 执行设备登录
      final authApi = KRAuthApi();
      final result = await authApi.kr_deviceLogin();

      result.fold(
        (error) {
          print('❌ 设备登录失败: ${error.msg}');
          KRLogUtil.kr_e('❌ 设备登录失败: ${error.msg}', tag: 'SplashController');
        },
        (token) async {
          print('✅ 设备登录成功！');
          print('🎫 Token: ${token.substring(0, min(20, token.length))}...');
          KRLogUtil.kr_i('✅ 设备登录成功', tag: 'SplashController');

          // 使用 saveUserInfo 保存完整的用户信息
          // 设备登录使用特殊的账号标识，登录类型设为邮箱（后续可以绑定真实账号）
          final deviceId = KRDeviceInfoService().deviceId ?? 'unknown';
          await KRAppRunData.getInstance().kr_saveUserInfo(
            token,
            'device_$deviceId', // 使用设备ID作为临时账号
            KRLoginType.kr_email, // 默认登录类型
            null, // 设备登录无需区号
          );
          print('💾 用户信息已保存（包括Token）');
          print('✅ 已标记为登录状态');
          KRLogUtil.kr_i('✅ 设备登录流程完成', tag: 'SplashController');
        },
      );

      print('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
    } catch (e, stackTrace) {
      print('❌ 设备登录检查异常: $e');
      print('📚 堆栈跟踪: $stackTrace');
      KRLogUtil.kr_e('❌ 设备登录检查异常: $e', tag: 'SplashController');
    }
  }

  Future<void> _kr_initialize() async {
    try {
      KRLogUtil.kr_i('🔧 开始执行 _kr_initialize', tag: 'SplashController');

      // 只在手机端检查网络权限
      if (Platform.isIOS || Platform.isAndroid) {
        KRLogUtil.kr_i('📱 移动平台，检查网络权限...', tag: 'SplashController');
        final bool hasNetworkPermission = await KRNetworkCheck.kr_initialize(
          Get.context!,
          onPermissionGranted: () async {
            await _kr_continueInitialization();
          },
        );

        if (!hasNetworkPermission) {
          kr_hasError.value = true;
          kr_errorMessage.value = AppTranslations.kr_splash.kr_networkPermissionFailed;
          KRLogUtil.kr_e('❌ 网络权限检查失败', tag: 'SplashController');
          return;
        }
      } else {
        // 非手机端直接继续初始化
        KRLogUtil.kr_i('💻 桌面平台，直接执行初始化', tag: 'SplashController');
        await _kr_continueInitialization();
      }
    } catch (e) {
      KRLogUtil.kr_e('❌ _kr_initialize 异常: $e', tag: 'SplashController');
      kr_hasError.value = true;
      kr_errorMessage.value = '${AppTranslations.kr_splash.kr_initializationFailed}$e';
    }
  }

  Future<void> _kr_continueInitialization() async {
    try {
      KRLogUtil.kr_i('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', tag: 'SplashController');
      KRLogUtil.kr_i('🚀 启动页主流程开始...', tag: 'SplashController');
      KRLogUtil.kr_i('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', tag: 'SplashController');

      // 只在手机端检查网络连接
      if (Platform.isIOS || Platform.isAndroid) {
        KRLogUtil.kr_i('📱 检查网络连接...', tag: 'SplashController');
        final bool isConnected = await KRNetworkCheck.kr_checkNetworkConnection();
        if (!isConnected) {
          kr_hasError.value = true;
          kr_errorMessage.value = AppTranslations.kr_splash.kr_networkConnectionFailed;
          KRLogUtil.kr_e('❌ 网络连接失败', tag: 'SplashController');
          return;
        }
        KRLogUtil.kr_i('✅ 网络连接正常', tag: 'SplashController');
      } else {
        KRLogUtil.kr_i('💻 桌面平台，跳过网络连接检查', tag: 'SplashController');
      }

      // 初始化配置
      KRLogUtil.kr_i('⚙️ 开始初始化应用配置...', tag: 'SplashController');
      await AppConfig().initConfig(
        onSuccess: () async {
          // 配置初始化成功，继续后续步骤
          KRLogUtil.kr_i('✅ 应用配置初始化成功，继续后续步骤', tag: 'SplashController');
          await _kr_continueAfterConfig();
        },
      );
    } catch (e) {
      // 配置初始化失败，显示错误信息
      KRLogUtil.kr_e('❌ 启动页初始化异常: $e', tag: 'SplashController');
      kr_hasError.value = true;
      kr_errorMessage.value = '${AppTranslations.kr_splash.kr_initializationFailed}$e';
    }
  }

  // 配置初始化成功后的后续步骤
  Future<void> _kr_continueAfterConfig() async {
    try {
      // 初始化SingBox
      await KRSingBoxImp.instance.init();

      // 检查是否已经通过设备登录设置了用户信息
      // 如果已登录（设备登录已完成），则跳过 initializeUserInfo
      // 如果未登录（没有设备登录或设备登录失败），则尝试从本地加载
      if (!KRAppRunData.getInstance().kr_isLogin.value) {
        KRLogUtil.kr_i('未检测到设备登录，尝试从本地加载用户信息', tag: 'SplashController');
        await KRAppRunData.getInstance().kr_initializeUserInfo();
      } else {
        KRLogUtil.kr_i('设备登录已完成，跳过用户信息初始化', tag: 'SplashController');
      }

      // 等待一小段时间确保所有初始化完成
      await Future.delayed(const Duration(milliseconds: 500));

      // 验证登录状态是否已正确设置
      final loginStatus = KRAppRunData.getInstance().kr_isLogin.value;
      final token = KRAppRunData.getInstance().kr_token;
      final hasToken = token != null && token.isNotEmpty;

      print('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
      print('🎯 准备进入主页');
      print('📊 最终登录状态: $loginStatus');
      print('🎫 Token存在: $hasToken');
      if (hasToken) {
        print('🎫 Token前缀: ${token.substring(0, min(20, token.length))}...');
      }
      print('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');

      KRLogUtil.kr_i('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', tag: 'SplashController');
      KRLogUtil.kr_i('🎯 准备进入主页', tag: 'SplashController');
      KRLogUtil.kr_i('📊 最终登录状态: $loginStatus', tag: 'SplashController');
      KRLogUtil.kr_i('🎫 Token存在: $hasToken', tag: 'SplashController');
      KRLogUtil.kr_i('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', tag: 'SplashController');

      // 直接导航到主页（无论是否登录，主页会根据登录状态显示不同内容）
      Get.offAllNamed(Routes.KR_MAIN);
    } catch (e) {
      // 后续步骤失败，显示错误信息
      KRLogUtil.kr_e('启动初始化失败: $e', tag: 'SplashController');
      kr_hasError.value = true;
      kr_errorMessage.value = '${AppTranslations.kr_splash.kr_initializationFailed}$e';
    }
  }

  // 重试按钮点击事件
  void kr_retry() {
    kr_hasError.value = false;
    kr_errorMessage.value = '';
    _kr_initialize();
  }

  @override
  void onReady() {
    super.onReady();
  }

  @override
  void onClose() {
    super.onClose();
  }
}