flux/lib/main.dart

import 'dart:developer';

import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:flutter_dotenv/flutter_dotenv.dart';
import 'package:flux/core/blocs/session/session_bloc.dart';
import 'package:flux/core/routes/app_router.dart';
import 'package:flux/core/theme/theme.dart';
import 'package:flux/core/theme/bloc/theme_bloc.dart';
import 'package:flux/features/auth/bloc/auth_bloc.dart';
import 'package:flux/features/company/bloc/company_bloc.dart';
import 'package:flux/features/company/data/company_repository.dart';
import 'package:flux/features/customers/blocs/customer_bloc.dart';
import 'package:flux/features/customers/data/customer_repository.dart';
import 'package:flux/features/master_data/products/blocs/product_cubit.dart';
import 'package:flux/features/master_data/products/data/product_repository.dart';
import 'package:flux/features/master_data/providers/blocs/provider_cubit.dart';
import 'package:flux/features/master_data/providers/data/provider_repository.dart';
import 'package:flux/features/master_data/staff/blocs/staff_cubit.dart';
import 'package:flux/features/master_data/staff/data/staff_repository.dart';
import 'package:flux/features/master_data/store/bloc/store_cubit.dart';
import 'package:flux/features/master_data/store/data/store_repository.dart';
import 'package:flux/features/services/blocs/services_cubit.dart';
import 'package:flux/features/services/data/services_repository.dart';
import 'package:flux/features/settings/settings.dart';
import 'package:get_it/get_it.dart';
import 'package:go_router/go_router.dart';
import 'package:shared_preferences/shared_preferences.dart';
import 'package:supabase_flutter/supabase_flutter.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await dotenv.load(fileName: ".env");
  await setupLocator();

  runApp(
    MultiBlocProvider(
      providers: [
        BlocProvider<ThemeBloc>(
          create: (context) => ThemeBloc()..add(LoadThemeEvent()),
        ),
        BlocProvider<SessionBloc>(
          create: (context) => SessionBloc()..add(AppStarted()),
        ),
      ],
      child: const FluxApp(),
    ),
  );
}

Future<void> setupLocator() async {
  final GetIt getIt = GetIt.instance;
  getIt.registerSingleton<SharedPreferences>(
    await SharedPreferences.getInstance(),
  );

  await Supabase.initialize(
    url: dotenv.env['SUPABASE_URL'] ?? '',
    anonKey: dotenv.env['SUPABASE_ANON_KEY'] ?? '',
  );
  getIt.registerSingleton<SupabaseClient>(Supabase.instance.client);
  getIt.registerLazySingleton<AppSettings>(() => AppSettings());
  getIt.registerLazySingleton<CompanyRepository>(() => CompanyRepository());
  getIt.registerLazySingleton<StoreRepository>(() => StoreRepository());
  getIt.registerLazySingleton<CustomerRepository>(() => CustomerRepository());
  getIt.registerLazySingleton<ProductRepository>(() => ProductRepository());
  getIt.registerLazySingleton<StaffRepository>(() => StaffRepository());
  getIt.registerLazySingleton<ServicesRepository>(() => ServicesRepository());
  getIt.registerLazySingleton<ProviderRepository>(() => ProviderRepository());
}

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

  @override
  State<FluxApp> createState() => _FluxAppState();
}

class _FluxAppState extends State<FluxApp> {
  late final GoRouter _router;

  @override
  void initState() {
    super.initState();
    // Lo creiamo una volta sola all'avvio dell'app
    _router = AppRouter.createRouter(context.read<SessionBloc>());
  }

  @override
  Widget build(BuildContext context) {
    return MultiBlocProvider(
      providers: [
        BlocProvider<AuthBloc>(create: (_) => AuthBloc()),
        BlocProvider<CompanyBloc>(create: (_) => CompanyBloc()),
        BlocProvider<StoreCubit>(
          create: (_) => StoreCubit(context.read<SessionBloc>())..loadStores(),
        ),
        BlocProvider<CustomerBloc>(create: (_) => CustomerBloc()),
        BlocProvider<ProductCubit>(
          create: (context) => ProductCubit(context.read<SessionBloc>()),
        ),
        BlocProvider<StaffCubit>(
          create: (_) =>
              StaffCubit(context.read<SessionBloc>())..loadAllStaff(),
        ),
        BlocProvider<ServicesCubit>(
          create: (_) => ServicesCubit(context.read<SessionBloc>()),
        ),
        BlocProvider<ProvidersCubit>(
          create: (_) => ProvidersCubit(context.read<SessionBloc>()),
        ),
      ],
      child: BlocBuilder<ThemeBloc, ThemeState>(
        builder: (context, state) {
          return MaterialApp.router(
            title: 'FLUX Gestionale',
            debugShowCheckedModeBanner: false,
            theme: fluxLightTheme,
            darkTheme: fluxDarkTheme,
            themeMode: state.currentTheme.themeMode,
            routerConfig: _router, // Usa l'istanza mantenuta nello stato
          );
        },
      ),
    );
  }
}