main.dart

import 'dart:async';
import 'dart:ui';

import 'package:firebase_core/firebase_core.dart';
import 'package:firebase_messaging/firebase_messaging.dart';
import 'package:flutter/foundation.dart' show kIsWeb;
import 'package:flutter/material.dart';
import 'package:flutter_web_plugins/url_strategy.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:google_fonts/google_fonts.dart';
import 'package:marionette_flutter/marionette_flutter.dart';
import 'package:supabase_flutter/supabase_flutter.dart';

import 'integration_test_gate_stub.dart'
    if (dart.library.io) 'integration_test_gate_io.dart'
    as integration_test_gate;
import 'marionette_debug_gate_stub.dart'
    if (dart.library.io) 'marionette_debug_gate_io.dart'
    as marionette_gate;
import 'core/firebase/fcm_background_handler.dart';
import 'core/firebase/fcm_service.dart';
import 'firebase_options.dart';
import 'core/router.dart';
import 'core/platform/platform_notifications.dart';
import 'core/services/notification_service.dart';
import 'core/services/prefs_schema.dart';
import 'core/services/stripe_init_service.dart';
import 'core/theme/theme.dart';
import 'core/widgets/app_snack_bar.dart';

const _supabaseUrl = String.fromEnvironment('SUPABASE_URL');
const _supabaseAnonKey = String.fromEnvironment('SUPABASE_ANON_KEY');
const _stripePublishableKey = String.fromEnvironment('STRIPE_PUBLISHABLE_KEY');

void _assertEnvVars() {
  final missing = <String>[
    if (_supabaseUrl.isEmpty) 'SUPABASE_URL',
    if (_supabaseAnonKey.isEmpty) 'SUPABASE_ANON_KEY',
    if (_stripePublishableKey.isEmpty) 'STRIPE_PUBLISHABLE_KEY',
  ];
  if (missing.isNotEmpty) {
    throw StateError(
      'Missing required --dart-define variables: ${missing.join(', ')}.\n'
      'Run the app with:\n'
      '  flutter run \\\n'
      '    --dart-define=SUPABASE_URL=<url> \\\n'
      '    --dart-define=SUPABASE_ANON_KEY=<key> \\\n'
      '    --dart-define=STRIPE_PUBLISHABLE_KEY=<key>\n'
      'Or use: flutter run --dart-define-from-file=.env',
    );
  }
}

bool _integrationTestBindingActive() {
  if (integration_test_gate.integrationTestActive) return true;
  try {
    final type = WidgetsBinding.instance.runtimeType.toString();
    return type.contains('IntegrationTest') ||
        type.contains('AutomatedTestWidgetsFlutterBinding');
  } catch (_) {
    return false;
  }
}

Future<void> main() async {
  final integrationTest = _integrationTestBindingActive();
  final marionetteEnabled =
      !integrationTest && marionette_gate.marionetteEnabledInThisBuild;
  if (marionetteEnabled) {
    MarionetteBinding.ensureInitialized();
  } else if (!integrationTest) {
    WidgetsFlutterBinding.ensureInitialized();
  }

  if (kIsWeb) {
    usePathUrlStrategy();
    // C6: Cap Flutter's in-memory image cache to 64 MB on web to prevent
    // unbounded growth in long-running sessions.
    PaintingBinding.instance.imageCache.maximumSizeBytes = 64 * 1024 * 1024;
  }

  if (!integrationTest) {
    FlutterError.onError = (details) {
      FlutterError.presentError(details);
    };
    PlatformDispatcher.instance.onError = (error, stack) {
      debugPrint('Unhandled async error: $error\n$stack');
      return true;
    };
  }

  _assertEnvVars();
  await PrefsSchema.migrate();

  GoogleFonts.config.allowRuntimeFetching = kIsWeb;

  if (!kIsWeb) {
    await ensureStripeReady(publishableKey: _stripePublishableKey);
  }

  await Supabase.initialize(url: _supabaseUrl, publishableKey: _supabaseAnonKey);

  if (kIsWeb) {
    runApp(const ProviderScope(child: PetfolioApp()));
    unawaited(_initializeWebPushStack());
    return;
  }

  if (!integrationTest) {
    await NotificationService.instance.initialize(
      onTap: FcmService.instance.handleNotificationTap,
    );
    await PlatformNotifications.instance.initialize();

    await Firebase.initializeApp(options: DefaultFirebaseOptions.currentPlatform);
    FirebaseMessaging.onBackgroundMessage(firebaseMessagingBackgroundHandler);
    await FcmService.instance.initialize();
  }

  runApp(const ProviderScope(child: PetfolioApp()));
}

Future<void> _initializeWebPushStack() async {
  try {
    await Firebase.initializeApp(
      options: DefaultFirebaseOptions.currentPlatform,
    );
    await FcmService.instance.initialize();
  } catch (e, stack) {
    debugPrint('Web push stack init failed: $e\n$stack');
  }
}

class PetfolioApp extends ConsumerWidget {
  const PetfolioApp({super.key});

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final router = ref.watch(routerProvider);
    final themeMode = ref.watch(themeProvider);

    FcmService.instance.updateRouter(router);

    return MaterialApp.router(
      title: 'PetFolio',
      debugShowCheckedModeBanner: false,
      scaffoldMessengerKey: appSnackBarMessengerKey,
      theme: AppTheme.light(),
      darkTheme: AppTheme.dark(),
      themeMode: themeMode,
      routerConfig: router,
    );
  }
}