flux/lib/main.dart

import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:flutter_dotenv/flutter_dotenv.dart';
import 'package:flux/features/auth/bloc/auth_cubit.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';
import 'package:flux/core/blocs/session/session_cubit.dart';
import 'package:flux/core/data/core_repository.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/customers/blocs/customer_cubit.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';

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

  // Inizializza le dipendenze PRIMA di lanciare l'app
  await setupLocator();

  runApp(
    MultiBlocProvider(
      providers: [
        BlocProvider<AuthCubit>(create: (context) => AuthCubit()),
        BlocProvider<ThemeBloc>(
          create: (context) => ThemeBloc()..add(LoadThemeEvent()),
        ),
        // Il Vigile Urbano viene inizializzato!
        BlocProvider<SessionCubit>(create: (_) => GetIt.I<SessionCubit>()),

        // Cubit delle feature
        BlocProvider<StoreCubit>(create: (_) => StoreCubit()),
        BlocProvider<CustomerCubit>(create: (_) => CustomerCubit()),
        BlocProvider<ProductCubit>(create: (_) => ProductCubit()),
        BlocProvider<StaffCubit>(create: (_) => StaffCubit()),
        BlocProvider<ServicesCubit>(create: (_) => ServicesCubit()),
        BlocProvider<ProvidersCubit>(create: (_) => ProvidersCubit()),
      ],
      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);

  // Settings
  getIt.registerLazySingleton<AppSettings>(() => AppSettings());

  // Repositories
  getIt.registerLazySingleton<CoreRepository>(
    () => CoreRepository(),
  ); // <-- NUOVO
  getIt.registerLazySingleton<StoreRepository>(() => StoreRepository());
  getIt.registerLazySingleton<CustomerRepository>(() => CustomerRepository());
  getIt.registerLazySingleton<ProductRepository>(() => ProductRepository());
  getIt.registerLazySingleton<StaffRepository>(() => StaffRepository());
  getIt.registerLazySingleton<ServicesRepository>(() => ServicesRepository());
  getIt.registerLazySingleton<ProviderRepository>(() => ProviderRepository());

  // NOTA: CompanyRepository l'ho tolto perché la logica della Company
  // ora è gestita dal CoreRepository durante l'Onboarding.
  // Se ti serve per altro, rimettilo pure!

  // Inizializziamo il SessionCubit (che prende CoreRepository e SharedPreferences)
  // Usiamo registerSingleton così viene creato subito e inizia ad ascoltare Supabase Auth.
  getIt.registerSingleton<SessionCubit>(
    SessionCubit(getIt<CoreRepository>(), getIt<SharedPreferences>()),
  );
}

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();
    // Creiamo il router passandogli il Cubit per i redirect
    _router = AppRouter.createRouter(context.read<SessionCubit>());
  }

  @override
  Widget build(BuildContext context) {
    return BlocBuilder<SessionCubit, SessionState>(
      builder: (context, sessionState) {
        if (sessionState.status == SessionStatus.initial) {
          return _buildLoadingScreen();
        }

        return BlocBuilder<ThemeBloc, ThemeState>(
          builder: (context, themeState) {
            return MaterialApp.router(
              title: 'FLUX Gestionale',
              debugShowCheckedModeBanner: false,
              theme: fluxLightTheme,
              darkTheme: fluxDarkTheme,
              themeMode: themeState.currentTheme.themeMode,
              routerConfig: _router,
            );
          },
        );
      },
    );
  }

  Widget _buildLoadingScreen() {
    return MaterialApp(
      debugShowCheckedModeBanner: false,
      home: Scaffold(
        body: Center(
          child: Column(
            mainAxisAlignment: MainAxisAlignment.center,
            children: [
              const Icon(Icons.bolt, size: 64, color: Colors.blue),
              const SizedBox(height: 24),
              const CircularProgressIndicator(),
              const SizedBox(height: 16),
              const Text(
                "Inizializzazione sessione...",
                style: TextStyle(
                  fontWeight: FontWeight.bold,
                  color: Colors.grey,
                ),
              ),
            ],
          ),
        ),
      ),
    );
  }
}