import 'dart:async';
import 'package:flutter/scheduler.dart';

import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:go_router/go_router.dart';
import 'di/injection.dart';
import '../core/l10n/l10n.dart';
import '../l10n/app_localizations.dart';
import '../features/auth/presentation/bloc/auth_bloc.dart';
import '../features/auth/presentation/bloc/auth_event.dart';
import '../features/auth/presentation/bloc/auth_state.dart';
import '../features/chat/presentation/bloc/chat_bloc.dart';
import '../data/cache/cache_scope.dart';
import 'services/app_prewarm_orchestrator.dart';
import 'services/session_scope_manager.dart';
import 'router/app_router.dart';
import '../core/theme/app_theme.dart';
import '../core/inbox/inbox_sync_store.dart';
import '../core/notification/services/reminder_permission_service.dart';
import '../core/notification/services/reminder_notification_router.dart';
import '../core/notification/models/reminder_alarm.dart';
import 'router/app_routes.dart';

class LinksyApp extends StatefulWidget {
  const LinksyApp({super.key});

  @override
  State<LinksyApp> createState() => _LinksyAppState();
}

class _LinksyAppState extends State<LinksyApp> {
  late final AuthBloc _authBloc;
  late final GoRouter _router;
  StreamSubscription<ReminderNotificationTap>? _reminderTapSubscription;
  String? _pendingReminderRoute;
  Future<void> _authTransitionQueue = Future<void>.value();

  Future<void> _onAuthenticated(String userId) async {
    await sl<SessionScopeManager>().activate(userId);
    await sl<InboxSyncStore>().resetForUser(userId);
    await sl<AppPrewarmOrchestrator>().ensureStartedFor(userId);
  }

  Future<void> _onUnauthenticated() async {
    await sl<SessionScopeManager>().clearActiveUserScope();
    await sl<InboxSyncStore>().resetForUser(null);
    await sl<ChatBloc>().switchUser(null);
    sl<AppPrewarmOrchestrator>().reset();
  }

  @override
  void initState() {
    super.initState();
    _authBloc = sl<AuthBloc>();
    CacheScope.resetProvider();
    _authBloc.add(AuthStarted());
    _router = createAppRouter(_authBloc);
    SchedulerBinding.instance.addPostFrameCallback((_) {
      unawaited(_bootstrapReminderNotification());
    });
  }

  Future<void> _bootstrapReminderNotification() async {
    await sl<ReminderPermissionService>().initializeAtBoot();
    final router = sl<ReminderNotificationRouter>();
    _reminderTapSubscription ??= router.taps.listen(_onReminderTap);
    await router.start();
  }

  void _onReminderTap(ReminderNotificationTap tap) {
    final route = AppRoutes.calendarReminderAlarm(tap.eventId);
    _pendingReminderRoute = route;
    _enqueueAuthTransition(() async {
      if (_authBloc.state is! AuthAuthenticated) {
        return;
      }
      final pendingRoute = _pendingReminderRoute;
      if (pendingRoute == null) {
        return;
      }
      _pendingReminderRoute = null;
      _router.go(pendingRoute);
    });
  }

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

  void _enqueueAuthTransition(Future<void> Function() transition) {
    _authTransitionQueue = _authTransitionQueue
        .catchError((Object error, StackTrace stackTrace) {
          FlutterError.reportError(
            FlutterErrorDetails(exception: error, stack: stackTrace),
          );
          Zone.current.handleUncaughtError(error, stackTrace);
        })
        .then((_) => transition())
        .catchError((Object error, StackTrace stackTrace) {
          FlutterError.reportError(
            FlutterErrorDetails(exception: error, stack: stackTrace),
          );
          Zone.current.handleUncaughtError(error, stackTrace);
        });
  }

  @override
  Widget build(BuildContext context) {
    return BlocProvider<AuthBloc>.value(
      value: _authBloc,
      child: BlocListener<AuthBloc, AuthState>(
        listener: (context, state) {
          if (state is AuthAuthenticated) {
            _enqueueAuthTransition(() => _onAuthenticated(state.user.id));
          }
          if (state is AuthUnauthenticated) {
            _enqueueAuthTransition(_onUnauthenticated);
          }
        },
        child: MaterialApp.router(
          onGenerateTitle: (context) => AppLocalizations.of(context).appTitle,
          debugShowCheckedModeBanner: false,
          theme: AppTheme.light,
          darkTheme: AppTheme.dark,
          themeMode: ThemeMode.system,
          locale: const Locale('zh'),
          supportedLocales: AppLocalizations.supportedLocales,
          localizationsDelegates: AppLocalizations.localizationsDelegates,
          builder: (context, child) {
            L10n.setLocale(Localizations.localeOf(context));
            return child ?? const SizedBox.shrink();
          },
          routerConfig: _router,
        ),
      ),
    );
  }
}