main.dart

import 'dart:async';
import 'dart:ui';
// trigger rebuild

import 'package:flutter/cupertino.dart';
import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:marionette_flutter/marionette_flutter.dart';

import 'package:awesome_notifications/awesome_notifications.dart';
import 'package:firebase_auth/firebase_auth.dart';
import 'package:firebase_core/firebase_core.dart';
import 'package:firebase_crashlytics/firebase_crashlytics.dart';
import 'package:firebase_messaging/firebase_messaging.dart';
import 'package:omi/gen/pigeon_communicator.g.dart';
import 'package:omi/services/bridges/ble_bridge.dart';
import 'package:flutter_foreground_task/flutter_foreground_task.dart';
import 'package:flutter_localizations/flutter_localizations.dart';
import 'package:opus_dart/opus_dart.dart';
import 'package:opus_flutter/opus_flutter.dart' as opus_flutter;
import 'package:provider/provider.dart';
import 'package:talker_flutter/talker_flutter.dart';

import 'package:omi/app_globals.dart';
import 'package:omi/backend/http/shared.dart';
import 'package:omi/backend/preferences.dart';
import 'package:omi/coordinators/provider_capture_external_actions.dart';
import 'package:omi/core/app_shell.dart';
import 'package:omi/env/dev_env.dart';
import 'package:omi/env/env.dart';
import 'package:omi/env/prod_env.dart';
import 'package:omi/firebase_options_dev.dart' as dev;
import 'package:omi/firebase_options_prod.dart' as prod;
import 'package:omi/flavors.dart';
import 'package:omi/startup_routing.dart';
import 'package:omi/l10n/app_localizations.dart';
import 'package:omi/pages/apps/providers/add_app_provider.dart';
import 'package:omi/pages/conversation_detail/conversation_detail_provider.dart';
import 'package:omi/pages/payments/payment_method_provider.dart';
import 'package:omi/providers/action_items_provider.dart';
import 'package:omi/providers/announcement_provider.dart';
import 'package:omi/providers/app_provider.dart';
import 'package:omi/providers/auth_provider.dart';
import 'package:omi/providers/capture_provider.dart';
import 'package:omi/providers/connectivity_provider.dart';
import 'package:omi/providers/conversation_provider.dart';
import 'package:omi/providers/device_provider.dart';
import 'package:omi/providers/folder_provider.dart';
import 'package:omi/providers/goals_provider.dart';
import 'package:omi/providers/home_provider.dart';
import 'package:omi/providers/integration_provider.dart';
import 'package:omi/providers/local_recordings_provider.dart';
import 'package:omi/providers/locale_provider.dart';
import 'package:omi/providers/mcp_provider.dart';
import 'package:omi/providers/memories_provider.dart';
import 'package:omi/providers/message_provider.dart';
import 'package:omi/providers/onboarding_provider.dart';
import 'package:omi/providers/people_provider.dart';
import 'package:omi/providers/speech_profile_provider.dart';
import 'package:omi/providers/sync_provider.dart';
import 'package:omi/providers/task_integration_provider.dart';
import 'package:omi/providers/usage_provider.dart';
import 'package:omi/providers/user_provider.dart';
import 'package:omi/providers/voice_recorder_provider.dart';
import 'package:omi/providers/phone_call_provider.dart';
import 'package:omi/services/auth_service.dart';
import 'package:omi/services/notifications.dart';
import 'package:omi/services/notifications/action_item_notification_handler.dart';
import 'package:omi/services/notifications/important_conversation_notification_handler.dart';
import 'package:omi/services/notifications/merge_notification_handler.dart';
import 'package:omi/services/devices/connectors/limitless_connection.dart';
import 'package:omi/services/services.dart';
import 'package:omi/services/wals.dart';
import 'package:omi/utils/debug_log_manager.dart';
import 'package:omi/utils/debugging/crashlytics_manager.dart';
import 'package:omi/utils/environment_detector.dart';
import 'package:omi/utils/analytics/rage_click_context_tracker.dart';
import 'package:omi/utils/l10n_extensions.dart';
import 'package:omi/utils/logger.dart';
import 'package:omi/utils/platform/platform_service.dart';
import 'package:omi/utils/platform/platform_manager.dart';
import 'package:omi/utils/notification_channel_strings.dart';

/// Background message handler for FCM data messages
@pragma('vm:entry-point')
Future<void> _firebaseMessagingBackgroundHandler(RemoteMessage message) async {
  await Firebase.initializeApp();
  await NotificationChannelStrings.loadAppLocale();

  await AwesomeNotifications().initialize(null, [
    NotificationChannel(
      channelKey: 'channel',
      channelName: NotificationChannelStrings.omiChannelName,
      channelDescription: NotificationChannelStrings.omiChannelDescription,
      defaultColor: const Color(0xFF9D50DD),
      ledColor: Colors.white,
    ),
  ]);

  final data = message.data;
  final messageType = data['type'];
  const channelKey = 'channel';

  // Handle action item messages
  if (messageType == 'action_item_reminder') {
    await ActionItemNotificationHandler.handleReminderMessage(data, channelKey);
  } else if (messageType == 'action_item_update') {
    await ActionItemNotificationHandler.handleUpdateMessage(data, channelKey);
  } else if (messageType == 'action_item_delete') {
    await ActionItemNotificationHandler.handleDeletionMessage(data);
  } else if (messageType == 'merge_completed') {
    await MergeNotificationHandler.handleMergeCompleted(data, channelKey, isAppInForeground: false);
  } else if (messageType == 'important_conversation') {
    await ImportantConversationNotificationHandler.handleImportantConversation(
      data,
      channelKey,
      isAppInForeground: false,
    );
  }
}

Future _init() async {
  // Env
  if (F.env == Environment.prod) {
    Env.init(ProdEnv());
  } else {
    Env.init(DevEnv());
  }
  validateApplicationStartupRouting();

  FlutterForegroundTask.initCommunicationPort();

  // Service manager
  await ServiceManager.init();
  LimitlessDeviceConnection.realtimeSuppressionPolicy = () => SharedPreferencesUtil().batchModeEnabled;

  // Firebase
  if (Firebase.apps.isEmpty) {
    final options = F.env == Environment.prod
        ? prod.DefaultFirebaseOptions.currentPlatform
        : dev.DefaultFirebaseOptions.currentPlatform;
    await Firebase.initializeApp(options: options);
  } else {
    // Firebase may already be initialized by native SDK (macOS)
    debugPrint('Firebase already initialized.');
  }

  await PlatformManager.initializeServices();
  await NotificationChannelStrings.loadAppLocale();
  await NotificationService.instance.initialize();

  // Register FCM background message handler
  if (PlatformManager().isFCMSupported) {
    FirebaseMessaging.onBackgroundMessage(_firebaseMessagingBackgroundHandler);
  }

  await SharedPreferencesUtil.init();

  // TestFlight remains a distribution/telemetry signal; production-family
  // builds always use the established production backend.
  if (F.env == Environment.prod) {
    Env.isTestFlight = await EnvironmentDetector.isTestFlight();
  }

  bool isAuth = (await AuthService.instance.getIdToken()) != null;
  if (isAuth) {
    PlatformManager.instance.analytics.identify();
    // Restore onboarding state from server if not already set locally
    // This handles the case where cached credentials are used on startup
    if (!SharedPreferencesUtil().onboardingCompleted) {
      await AuthService.instance.restoreOnboardingState();
    }
  }
  initOpus(await opus_flutter.load());

  // Register native BLE bridge
  BleFlutterApi.setUp(BleBridge.instance);

  BleBridge.instance.stateRestoredCallback = (List<String> peripheralUuids) {
    Logger.debug('main: restored ${peripheralUuids.length} BLE peripherals');
  };

  await CrashlyticsManager.init();
  if (isAuth) {
    PlatformManager.instance.crashReporter.identifyUser(
      FirebaseAuth.instance.currentUser?.email ?? '',
      SharedPreferencesUtil().fullName,
      SharedPreferencesUtil().uid,
    );
  }
  FlutterError.onError = (FlutterErrorDetails details) {
    FirebaseCrashlytics.instance.recordFlutterFatalError(details);
  };

  PlatformDispatcher.instance.onError = (error, stack) {
    FirebaseCrashlytics.instance.recordError(error, stack, fatal: true);
    return true;
  };

  await ServiceManager.instance().start();
  return;
}

void main() {
  runZonedGuarded(() async {
    // Ensure
    if (kDebugMode) {
      MarionetteBinding.ensureInitialized();
    } else {
      WidgetsFlutterBinding.ensureInitialized();
    }
    await _init();
    runApp(const MyApp());
  }, (error, stack) => FirebaseCrashlytics.instance.recordError(error, stack, fatal: true));
}

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

  @override
  State<MyApp> createState() => _MyAppState();

  static _MyAppState of(BuildContext context) => context.findAncestorStateOfType<_MyAppState>()!;

  // The navigator key is necessary to navigate using static methods
  // Delegates to the extracted globalNavigatorKey so files don't need to import main.dart
  static GlobalKey<NavigatorState> get navigatorKey => globalNavigatorKey;
}

class _MyAppState extends State<MyApp> with WidgetsBindingObserver {
  @override
  void initState() {
    NotificationUtil.initializeNotificationsEventListeners();
    NotificationUtil.initializeIsolateReceivePort();
    WidgetsBinding.instance.addObserver(this);
    if (SharedPreferencesUtil().devLogsToFileEnabled) {
      DebugLogManager.setEnabled(true);
    }

    super.initState();
  }

  void _deinit() {
    Logger.debug("App > _deinit");
    ServiceManager.instance().deinit();
    ApiClient.dispose();
  }

  @override
  void didChangeAppLifecycleState(AppLifecycleState state) {
    super.didChangeAppLifecycleState(state);

    if (state == AppLifecycleState.resumed) {
      // Resume the upload reconciler at fast cadence and check immediately.
      SyncReconciler.instance.onForeground();
      SyncUploadGate.instance.reconcileFairUseStatus();
    } else if (state == AppLifecycleState.paused) {
      SyncReconciler.instance.onBackground();
      _onAppPaused();
    } else if (state == AppLifecycleState.detached) {
      _deinit();
    }
  }

  void _onAppPaused() {
    imageCache.clear();
    imageCache.clearLiveImages();
  }

  @override
  Widget build(BuildContext context) {
    return MultiProvider(
      providers: [
        ListenableProvider(create: (context) => ConnectivityProvider()),
        ChangeNotifierProvider(create: (context) => AuthenticationProvider()),
        ChangeNotifierProvider(create: (context) => ConversationProvider()),
        ListenableProvider(create: (context) => AppProvider()),
        ChangeNotifierProvider(create: (context) => PeopleProvider()),
        ChangeNotifierProvider(create: (context) => UsageProvider()),
        ChangeNotifierProxyProvider<AppProvider, MessageProvider>(
          create: (context) => MessageProvider(),
          update: (BuildContext context, value, MessageProvider? previous) =>
              (previous?..updateAppProvider(value)) ?? MessageProvider(),
        ),
        ChangeNotifierProxyProvider4<ConversationProvider, MessageProvider, PeopleProvider, UsageProvider,
            CaptureProvider>(
          create: (context) => CaptureProvider(),
          update: (BuildContext context, conversation, message, people, usage, CaptureProvider? previous) {
            final externalActions = ProviderCaptureExternalActions(
              conversationProvider: conversation,
              messageProvider: message,
              peopleProvider: people,
              usageProvider: usage,
            );
            return (previous?..updateExternalActions(externalActions)) ??
                CaptureProvider(externalActions: externalActions);
          },
        ),
        ChangeNotifierProxyProvider<ConversationProvider, LocalRecordingsProvider>(
          create: (context) => LocalRecordingsProvider(),
          update: (BuildContext context, conversation, LocalRecordingsProvider? previous) =>
              (previous?..setConversationProvider(conversation)) ?? LocalRecordingsProvider(),
        ),
        ChangeNotifierProxyProvider2<CaptureProvider, LocalRecordingsProvider, DeviceProvider>(
          create: (context) => DeviceProvider(),
          update: (BuildContext context, captureProvider, localRecordings, DeviceProvider? previous) =>
              (previous?..setProviders(captureProvider, localRecordings)) ?? DeviceProvider(),
        ),
        ChangeNotifierProxyProvider<DeviceProvider, OnboardingProvider>(
          create: (context) => OnboardingProvider(),
          update: (BuildContext context, value, OnboardingProvider? previous) =>
              (previous?..setDeviceProvider(value)) ?? OnboardingProvider(),
        ),
        ListenableProvider(create: (context) => HomeProvider()),
        ChangeNotifierProxyProvider<DeviceProvider, SpeechProfileProvider>(
          create: (context) => SpeechProfileProvider(),
          update: (BuildContext context, device, SpeechProfileProvider? previous) =>
              (previous?..setProviders(device)) ?? SpeechProfileProvider(),
        ),
        ChangeNotifierProxyProvider2<AppProvider, ConversationProvider, ConversationDetailProvider>(
          create: (context) => ConversationDetailProvider(),
          update: (BuildContext context, app, conversation, ConversationDetailProvider? previous) =>
              (previous?..setProviders(app, conversation)) ?? ConversationDetailProvider(),
        ),
        ChangeNotifierProxyProvider<AppProvider, AddAppProvider>(
          create: (context) => AddAppProvider(),
          update: (BuildContext context, value, AddAppProvider? previous) =>
              (previous?..setAppProvider(value)) ?? AddAppProvider(),
        ),
        ChangeNotifierProxyProvider<ConnectivityProvider, MemoriesProvider>(
          create: (context) => MemoriesProvider(),
          update: (context, connectivity, previous) =>
              (previous?..setConnectivityProvider(connectivity)) ?? MemoriesProvider(),
        ),
        ChangeNotifierProvider(create: (context) => UserProvider()),
        ChangeNotifierProvider(lazy: true, create: (context) => ActionItemsProvider()),
        ChangeNotifierProvider(lazy: true, create: (context) => GoalsProvider()..init()),
        ChangeNotifierProvider(create: (context) => SyncProvider()),
        ChangeNotifierProvider(lazy: true, create: (context) => TaskIntegrationProvider()),
        ChangeNotifierProvider(lazy: true, create: (context) => IntegrationProvider()),
        ChangeNotifierProvider(lazy: true, create: (context) => FolderProvider()),
        ChangeNotifierProvider(lazy: true, create: (context) => McpProvider()),
        ChangeNotifierProvider(lazy: true, create: (context) => PaymentMethodProvider()),
        ChangeNotifierProvider(create: (context) => VoiceRecorderProvider()..checkPendingRecording()),
        ChangeNotifierProvider(create: (context) => LocaleProvider()),
        ChangeNotifierProvider(create: (context) => AnnouncementProvider()),
        ChangeNotifierProvider(lazy: true, create: (context) => PhoneCallProvider()),
      ],
      builder: (context, child) {
        return WithForegroundTask(
          child: MaterialApp(
            debugShowCheckedModeBanner: F.env == Environment.dev,
            title: F.title,
            navigatorKey: MyApp.navigatorKey,
            locale: context.watch<LocaleProvider>().locale,
            localizationsDelegates: const [
              AppLocalizations.delegate,
              GlobalMaterialLocalizations.delegate,
              GlobalWidgetsLocalizations.delegate,
              GlobalCupertinoLocalizations.delegate,
            ],
            supportedLocales: AppLocalizations.supportedLocales,
            theme: ThemeData(
              useMaterial3: false,
              colorScheme: const ColorScheme.dark(
                primary: Colors.black,
                secondary: Color(0xFF35343B),
                surface: Colors.black38,
              ),
              snackBarTheme: const SnackBarThemeData(
                backgroundColor: Color(0xFF1F1F25),
                contentTextStyle: TextStyle(fontSize: 16, color: Colors.white, fontWeight: FontWeight.w500),
              ),
              textTheme: TextTheme(
                titleLarge: const TextStyle(fontSize: 18, color: Colors.white),
                titleMedium: const TextStyle(fontSize: 16, color: Colors.white),
                bodyMedium: const TextStyle(fontSize: 14, color: Colors.white),
                labelMedium: TextStyle(fontSize: 12, color: Colors.grey.shade200),
              ),
              textSelectionTheme: const TextSelectionThemeData(
                cursorColor: Colors.white,
                selectionColor: Colors.white24,
                selectionHandleColor: Colors.white,
              ),
              cupertinoOverrideTheme: const CupertinoThemeData(
                primaryColor: Colors.white, // Controls the selection handles on iOS
              ),
            ),
            themeMode: ThemeMode.dark,
            builder: (context, child) {
              FlutterError.onError = (FlutterErrorDetails details) {
                WidgetsBinding.instance.addPostFrameCallback((_) {
                  Logger.instance.talker.handle(details.exception, details.stack);
                  DebugLogManager.logError(details.exception, details.stack, 'FlutterError');
                });
              };
              ErrorWidget.builder = (errorDetails) {
                return CustomErrorWidget(errorMessage: errorDetails.exceptionAsString());
              };
              final content = child!;
              return PlatformService.isIOS && Env.posthogApiKey != null
                  ? RageClickContextTracker(child: content)
                  : content;
            },
            home: TalkerWrapper(
              talker: Logger.instance.talker,
              options: const TalkerWrapperOptions(enableErrorAlerts: false, enableExceptionAlerts: false),
              child: const AppShell(),
            ),
          ),
        );
      },
    );
  }
}

class CustomErrorWidget extends StatelessWidget {
  final String errorMessage;

  const CustomErrorWidget({super.key, required this.errorMessage});

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            const Icon(Icons.error_outline, color: Colors.red, size: 50.0),
            const SizedBox(height: 10.0),
            Text(
              context.l10n.somethingWentWrong,
              textAlign: TextAlign.center,
              style: const TextStyle(fontSize: 18.0, fontWeight: FontWeight.bold),
            ),
            const SizedBox(height: 10.0),
            Container(
              padding: const EdgeInsets.all(10),
              margin: const EdgeInsets.all(16),
              height: 200,
              decoration: BoxDecoration(
                color: const Color.fromARGB(255, 63, 63, 63),
                borderRadius: BorderRadius.circular(10),
              ),
              child: Text(errorMessage, textAlign: TextAlign.start, style: const TextStyle(fontSize: 16.0)),
            ),
            const SizedBox(height: 10.0),
            SizedBox(
              width: 210,
              child: ElevatedButton(
                style: ElevatedButton.styleFrom(backgroundColor: Colors.red),
                onPressed: () {
                  Clipboard.setData(ClipboardData(text: errorMessage));
                  ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text(context.l10n.errorCopied)));
                },
                child: Row(
                  mainAxisAlignment: MainAxisAlignment.center,
                  crossAxisAlignment: CrossAxisAlignment.center,
                  children: [
                    Text(context.l10n.copyErrorMessage),
                    const SizedBox(width: 10),
                    const Icon(Icons.copy_rounded),
                  ],
                ),
              ),
            ),
          ],
        ),
      ),
    );
  }
}