import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart' as fr;
import 'package:go_router/go_router.dart';
import 'package:logging/logging.dart';
import 'package:media_kit/media_kit.dart';
import 'package:multi_trigger_autocomplete/multi_trigger_autocomplete.dart';
import 'package:package_info_plus/package_info_plus.dart';
import 'package:provider/provider.dart';

import 'app_theme.dart';
import 'di_initialization.dart';
import 'globals.dart';
import 'riverpod_controllers/focus_mode.dart';
import 'routes.dart';
import 'services/auth_service.dart';
import 'services/blocks_manager.dart';
import 'services/connections_manager.dart';
import 'services/direct_message_service.dart';
import 'services/entry_manager_service.dart';
import 'services/follow_requests_manager.dart';
import 'services/gallery_service.dart';
import 'services/hashtag_service.dart';
import 'services/interactions_manager.dart';
import 'services/log_service.dart';
import 'services/notifications_manager.dart';
import 'services/setting_service.dart';
import 'services/status_service.dart';
import 'services/timeline_entry_filter_service.dart';
import 'services/timeline_manager.dart';
import 'utils/active_profile_selector.dart';
import 'utils/app_scrolling_behavior.dart';
import 'utils/old_android_letsencrypte_cert.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  MediaKit.ensureInitialized();

  final logService = LogService();
  getIt.registerSingleton<LogService>(logService);

  // await dotenv.load(fileName: '.env');
  Logger.root.level = Level.OFF;
  Logger.root.onRecord.listen((event) {
    logService.add(event);
  });

  await fixLetsEncryptCertOnOldAndroid();
  await dependencyInjectionInitialization();
  await setupPackageInfoAndUserAgent();

  // TODO Add back Device Preview once supported in Flutter 3.22+
  // runApp(DevicePreview(
  //   enabled: !kReleaseMode && enablePreview,
  //   builder: (context) => const App(),
  // ));
  runApp(const fr.ProviderScope(child: App()));
}

Future<void> setupPackageInfoAndUserAgent() async {
  PackageInfo packageInfo = await PackageInfo.fromPlatform();
  appVersion = packageInfo.version;
  userAgent = 'Relatica/$appVersion';
}

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

  // This widget is the root of your application.
  @override
  fr.ConsumerState<App> createState() => _AppState();
}

class _AppState extends fr.ConsumerState<App> {
  @override
  Widget build(BuildContext context) {
    final settingsService = getIt<SettingsService>();
    final authService = getIt<AccountsService>();

    final appRouter = GoRouter(
      initialLocation: ScreenPaths.timelines,
      debugLogDiagnostics: true,
      refreshListenable: authService,
      redirect: (context, state) async {
        final loggedIn = authService.loggedIn;
        final focusMode = ref.read(focusModeProvider);
        print('Focus mode? $focusMode');

        if (!loggedIn && authService.initializing) {
          return ScreenPaths.splash;
        }

        if (!loggedIn && !allowedLoggedOut.contains(state.uri.toString())) {
          return ScreenPaths.signin;
        }

        if (loggedIn && allowedLoggedOut.contains(state.uri.toString())) {
          return ScreenPaths.timelines;
        }

        return null;
      },
      routes: routes,
    );
    return AnimatedBuilder(
      builder: (context, child) {
        Logger.root.level = settingsService.logLevel;
        return Portal(
          child: MultiProvider(
            providers: [
              ChangeNotifierProvider<LogService>(
                create: (_) => getIt<LogService>(),
                lazy: true,
              ),
              ChangeNotifierProvider<StatusService>(
                create: (_) => getIt<StatusService>(),
                lazy: true,
              ),
              ChangeNotifierProvider<SettingsService>(
                create: (_) => getIt<SettingsService>(),
                lazy: true,
              ),
              ChangeNotifierProvider<AccountsService>(
                create: (_) => getIt<AccountsService>(),
                lazy: true,
              ),
              ChangeNotifierProvider<ActiveProfileSelector<ConnectionsManager>>(
                create: (_) =>
                    getIt<ActiveProfileSelector<ConnectionsManager>>(),
                lazy: true,
              ),
              ChangeNotifierProvider<
                  ActiveProfileSelector<EntryManagerService>>(
                create: (_) =>
                    getIt<ActiveProfileSelector<EntryManagerService>>(),
                lazy: true,
              ),
              ChangeNotifierProvider<ActiveProfileSelector<GalleryService>>(
                create: (_) => getIt<ActiveProfileSelector<GalleryService>>(),
                lazy: true,
              ),
              ChangeNotifierProvider<HashtagService>(
                create: (_) => getIt<HashtagService>(),
                lazy: true,
              ),
              ChangeNotifierProvider<ActiveProfileSelector<TimelineManager>>(
                create: (_) => getIt<ActiveProfileSelector<TimelineManager>>(),
              ),
              ChangeNotifierProvider<
                  ActiveProfileSelector<NotificationsManager>>(
                create: (_) =>
                    getIt<ActiveProfileSelector<NotificationsManager>>(),
              ),
              ChangeNotifierProvider<
                  ActiveProfileSelector<FollowRequestsManager>>(
                create: (_) =>
                    getIt<ActiveProfileSelector<FollowRequestsManager>>(),
              ),
              ChangeNotifierProvider<
                  ActiveProfileSelector<DirectMessageService>>(
                create: (_) =>
                    getIt<ActiveProfileSelector<DirectMessageService>>(),
              ),
              ChangeNotifierProvider<
                  ActiveProfileSelector<InteractionsManager>>(
                create: (_) =>
                    getIt<ActiveProfileSelector<InteractionsManager>>(),
              ),
              ChangeNotifierProvider<ActiveProfileSelector<BlocksManager>>(
                create: (_) => getIt<ActiveProfileSelector<BlocksManager>>(),
              ),
              ChangeNotifierProvider<
                  ActiveProfileSelector<TimelineEntryFilterService>>(
                create: (_) =>
                    getIt<ActiveProfileSelector<TimelineEntryFilterService>>(),
              ),
            ],
            child: MaterialApp.router(
              // TODO Add back Device Preview once supported in Flutter 3.22+
              // locale: DevicePreview.locale(context),
              // builder: DevicePreview.appBuilder,
              theme: buildTheme(
                brightness: Brightness.light,
                blindnessType: settingsService.colorBlindnessType,
              ),
              darkTheme: buildTheme(
                brightness: Brightness.dark,
                blindnessType: settingsService.colorBlindnessType,
              ),
              themeMode: settingsService.themeMode,
              debugShowCheckedModeBanner: false,
              scrollBehavior: AppScrollingBehavior(),
              routerDelegate: appRouter.routerDelegate,
              routeInformationProvider: appRouter.routeInformationProvider,
              routeInformationParser: appRouter.routeInformationParser,
            ),
          ),
        );
      },
      animation: getIt<SettingsService>(),
    );
  }
}