// main.dart — 入口(演示态)
// 串接:登录 → 引导 → 主框架(4 Tab);状态层统一走 Riverpod。
import 'dart:async';
import 'dart:io';
import 'dart:ui' as ui;

import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:window_manager/window_manager.dart';

import 'bridge/log.dart';
import 'bridge/vpn_bridge_provider.dart';
import 'models/node.dart';
import 'pangolin_theme.dart';
import 'services/device_identity.dart';
import 'services/token_store.dart';
import 'shell/home_shell.dart';
import 'state/account_providers.dart';
import 'state/app_providers.dart';
import 'state/auth_provider.dart';
import 'state/connection_provider.dart';
import 'state/nodes_provider.dart';
import 'state/settings_provider.dart';
import 'system_tray.dart';
import 'screens/device_limit_screen.dart';
import 'widgets/auth_screen.dart';
import 'widgets/onboarding_screen.dart';
import 'widgets/pangolin_logo.dart';
import 'widgets/pangolin_toast.dart';

Future<void> main(List<String> args) async {
  WidgetsFlutterBinding.ensureInitialized();
  // 开机自启拉起(计划任务 /tr 带 --autostart)→ 直接最小化到托盘,不弹主窗口。
  final bootAutostart = args.contains('--autostart');
  // 桌面端:单实例 + 常驻系统托盘(关闭窗口隐藏到托盘而非退出)。
  if (isDesktop) {
    if (!await ensureSingleInstance()) {
      exit(0); // 已有实例在跑(已唤起其窗口),本进程退出。
    }
    await TrayService.instance.init();
    // 桌面窗口尺寸：默认 920×640；最小宽 720（低于 form_factor 的 680 阈值会
    // 掉进 MobileShell，侧栏消失）。init() 内已 windowManager.ensureInitialized()。
    await windowManager.setMinimumSize(const Size(720, 560));
    await windowManager.setSize(const Size(920, 640));
    await windowManager.center();
    // 窗口标题用中文品牌名(不带 "VPN" 字眼);英文环境下原生标题为 "Pangolin"。
    await windowManager.setTitle('穿山甲');
    // 自启:首帧前就隐藏窗口(避免闪现),托盘已就绪可随时唤回;自动连接逻辑照常跑。
    if (bootAutostart) {
      await windowManager.hide();
      logLine('AutoStart', 'launched by --autostart; hiding to tray');
    }
  }
  runApp(const ProviderScope(child: PangolinApp()));
}

class PangolinApp extends ConsumerStatefulWidget {
  const PangolinApp({super.key});

  @override
  ConsumerState<PangolinApp> createState() => _PangolinAppState();
}

class _PangolinAppState extends ConsumerState<PangolinApp> {
  AppLifecycleListener? _lifecycle;
  // 是否正在「真退出」(托盘「退出」菜单触发)。区分:点关闭只隐藏到托盘、保持隧道。
  bool _isQuitting = false;

  @override
  void initState() {
    super.initState();
    if (isDesktop) {
      // 关闭 / 退出请求的处理:
      // - Windows:点 X / Alt+F4 会触发 onExitRequested,但桌面端要常驻托盘、隧道不断
      //   → 取消退出并隐藏到托盘。真正退出只走托盘「退出」菜单(见 onBeforeQuit)。
      //   (否则会出现:连接被拆、窗口却只是隐藏,即「关掉就断网但进程还在」。)
      // - macOS:Cmd+Q 等真退出 → 先停内核拆隧道再退出(红叉关闭走 onWindowClose 隐藏)。
      _lifecycle = AppLifecycleListener(onExitRequested: () async {
        if (Platform.isWindows && !_isQuitting) {
          await windowManager.hide();
          return ui.AppExitResponse.cancel;
        }
        await _teardownVpn();
        return ui.AppExitResponse.exit;
      });
      // 托盘「退出」前置钩子:标记真退出 + 停内核拆隧道(避免 sing-box 孤儿 + TUN 残留)。
      TrayService.instance.onBeforeQuit = () async {
        _isQuitting = true;
        await _teardownVpn();
      };
    }
  }

  Future<void> _teardownVpn() async {
    try {
      await ref.read(vpnBridgeProvider).stop().timeout(const Duration(seconds: 3));
    } catch (_) {
      // 内核未启动/已退出:忽略。
    }
  }

  @override
  void dispose() {
    _lifecycle?.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    final mode = ref.watch(themeModeProvider);
    return MaterialApp(
      title: '穿山甲',
      debugShowCheckedModeBanner: false,
      theme: PangolinTheme.light,
      darkTheme: PangolinTheme.dark,
      themeMode: mode,
      home: const RootFlow(),
    );
  }
}

/// 应用根流转:启动时若已有有效会话(7 天内 refresh 有效)直接进主界面,
/// 免登陆;会话失效则回登录页。引导页仅首次注册/登录后看一次。
class RootFlow extends ConsumerStatefulWidget {
  const RootFlow({super.key});
  @override
  ConsumerState<RootFlow> createState() => _RootFlowState();
}

class _RootFlowState extends ConsumerState<RootFlow> {
  final _store = const TokenStore();
  bool _forceOnboarding = false;
  bool _autoConnectArmed = false; // 自动连接每进程只尝试一次
  bool _homeLogged = false; // 仅日志:HomeShell 首次显示打一行
  bool _sessionWatchdogArmed = false; // 会话有效性轮询每进程只起一次
  bool _forcedLogoutHandling = false; // 正在弹「被强制下线」框 + 登出,避免重复
  Timer? _sessionPoll;

  @override
  void dispose() {
    _sessionPoll?.cancel();
    super.dispose();
  }

  // 会话有效性轮询:每 15s 问服务端「本设备会话还在吗」,被其他设备强制退出即登出。
  // 控制面无推送通道,用轮询把远程下线延迟压到 ~15s(而非 access token 的 15 分钟)。
  void _startSessionWatchdog() {
    if (_sessionWatchdogArmed) return;
    _sessionWatchdogArmed = true;
    _sessionPoll = Timer.periodic(const Duration(seconds: 15), (_) => _checkSession());
  }

  Future<void> _checkSession() async {
    if (!mounted || _forcedLogoutHandling || !ref.read(authProvider).isLoggedIn) return;
    try {
      final deviceId = await ref.read(deviceIdentityProvider).deviceId();
      final active = await ref.read(accountApiProvider).sessionActive(deviceId);
      if (active || !mounted || !ref.read(authProvider).isLoggedIn) return;
      // 被其他设备强制下线:先弹对话框告知原因,用户确认后再登出跳登录页。
      _forcedLogoutHandling = true;
      logLine('Session', 'server revoked this device → notify + logout');
      await _showForcedLogoutDialog();
      if (mounted) await ref.read(authProvider.notifier).logout();
      _forcedLogoutHandling = false;
    } catch (_) {
      // 网络/鉴权异常不据此登出(fail-safe):只在服务端明确 active=false 才登出。
    }
  }

  Future<void> _showForcedLogoutDialog() async {
    if (!mounted) return;
    final c = context.pangolin;
    final t = ref.read(appTextProvider);
    await showDialog<void>(
      context: context,
      barrierDismissible: false,
      builder: (ctx) => AlertDialog(
        backgroundColor: c.surface,
        shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(PangolinRadius.xl)),
        title: Text(t.sessionRevokedTitle,
            style: PangolinText.body.copyWith(color: c.fg1, fontWeight: FontWeight.w700)),
        content: Text(t.sessionRevokedBody, style: PangolinText.sm.copyWith(color: c.fg2, height: 1.5)),
        actions: [
          TextButton(
            onPressed: () => Navigator.pop(ctx),
            child: Text(t.sessionRevokedOk,
                style: PangolinText.sm.copyWith(color: c.accent, fontWeight: FontWeight.w700)),
          ),
        ],
      ),
    );
  }

  // 进入登录态主界面后:开了「自动连接」且当前未连接,就自动连一次。
  // 关键:必须同时等「设置已从持久化加载完(settings.loaded)」与「节点已就绪」——
  // 二者都是异步且完成时刻接近,早读 autoConnect 会撞上还没加载完的默认 false(实测差 1ms)。
  // 同时监听两者,任一变化就重判,直到都就绪再决策(只决策一次)。
  void _maybeAutoConnect() {
    if (_autoConnectArmed) return;
    _autoConnectArmed = true;
    logLine('AutoConnect', 'armed; waiting for settings loaded + nodes ready');
    ProviderSubscription<AsyncValue<List<Node>>>? nodeSub;
    ProviderSubscription<AppSettings>? settingsSub;
    ProviderSubscription<String>? selSub;
    Timer? poll;
    var decided = false;
    void finish() {
      nodeSub?.close();
      settingsSub?.close();
      selSub?.close();
      poll?.cancel();
    }
    void tryGo() {
      if (decided) return;
      final settings = ref.read(settingsProvider);
      final selLoaded = ref.read(selectedNodeCodeProvider.notifier).loaded;
      // 直接判 _connect 实际会用的「生效节点」是否就绪(uuid 非空),而非「列表里有任一就绪节点」——
      // 否则可能在 effectiveNode 尚是占位/未就绪时就触发,_connect 报「节点尚未就绪」。
      // 还要等设置 + 选中节点都从持久化恢复完,否则可能用到未恢复的默认(智能)而非上次选择。
      final node = ref.read(effectiveNodeProvider);
      logLine('AutoConnect',
          'check: settingsLoaded=${settings.loaded} selLoaded=$selLoaded node=${node.code} uuid=${node.uuid.isEmpty ? "EMPTY" : "ok"}');
      if (!settings.loaded || !selLoaded || node.uuid.isEmpty) return;
      decided = true;
      finish();
      final phase = ref.read(connectionProvider).phase;
      logLine('AutoConnect', 'ready: autoConnect=${settings.autoConnect} phase=$phase node=${node.code} uuid=${node.uuid.isEmpty ? "EMPTY" : "ok"}');
      if (settings.autoConnect && phase == VpnPhase.off) {
        logLine('AutoConnect', 'triggering connect → ${node.code}');
        ref.read(connectionProvider.notifier).toggle();
        // 自动连接 toast:「正在自动连接到 X」(主显示区内居中,见 pangolin_toast)。
        final t = ref.read(appTextProvider);
        if (mounted) showPangolinToast(context, t.autoConnectingTo(node.localizedName(t.lang)));
      } else {
        logLine('AutoConnect', 'NOT connecting (autoConnect=${settings.autoConnect} phase=$phase)');
      }
    }

    nodeSub = ref.listenManual(nodesProvider, (_, __) => tryGo());
    settingsSub = ref.listenManual(settingsProvider, (_, __) => tryGo());
    selSub = ref.listenManual(selectedNodeCodeProvider, (_, __) => tryGo());
    // 兜底轮询:有些就绪信号(如选中节点 _load 完成但值未变,不会发通知)不会触发上面的监听,
    // 靠定时复查避免「明明都就绪了却没人再调 tryGo」的死锁。最多等 ~12s。
    poll = Timer.periodic(const Duration(milliseconds: 400), (t) {
      if (decided || t.tick > 30) {
        t.cancel();
        return;
      }
      tryGo();
    });
    tryGo();
  }

  // 登录/注册成功后:未看过引导才进引导,否则直接主界面。
  Future<void> _afterAuth() async {
    final onboarded = await _store.isOnboarded();
    if (!mounted) return;
    setState(() => _forceOnboarding = !onboarded);
  }

  Future<void> _afterOnboarding() async {
    await _store.markOnboarded();
    if (!mounted) return;
    setState(() => _forceOnboarding = false);
  }

  @override
  Widget build(BuildContext context) {
    final t = ref.watch(appTextProvider);
    final auth = ref.watch(authProvider);

    if (auth.isLoading) return const _Splash();
    if (!auth.isLoggedIn) {
      return AuthScreen(t: t, onDone: () { _afterAuth(); });
    }
    // 设备数超上限挡板(#16):登录成功但活跃设备超套餐上限 → 先移除设备降到上限内。
    final deviceLimit = ref.watch(deviceLimitProvider);
    if (deviceLimit != null) {
      return DeviceLimitScreen(t: t, limit: deviceLimit);
    }
    if (_forceOnboarding) {
      return OnboardingScreen(t: t, onDone: () { _afterOnboarding(); });
    }
    if (!_homeLogged) {
      _homeLogged = true;
      logLine('AutoConnect', 'HomeShell shown; scheduling auto-connect check');
    }
    WidgetsBinding.instance.addPostFrameCallback((_) {
      if (mounted) {
        _maybeAutoConnect();
        _startSessionWatchdog();
      }
    });
    return const HomeShell();
  }
}

/// 会话恢复期间的极简启动屏(避免登录页一闪而过)。
class _Splash extends StatelessWidget {
  const _Splash();
  @override
  Widget build(BuildContext context) => const Scaffold(
        body: Center(child: PangolinMark(size: 56)),
      );
}