EM2_ERP/em2rp/lib/main.dart

import 'package:em2rp/providers/users_provider.dart';
import 'package:em2rp/providers/event_provider.dart';
import 'package:em2rp/providers/equipment_provider.dart';
import 'package:em2rp/providers/container_provider.dart';
import 'package:em2rp/providers/maintenance_provider.dart';
import 'package:em2rp/providers/alert_provider.dart';
import 'package:em2rp/utils/auth_guard_widget.dart';
import 'package:em2rp/views/alerts_page.dart';
import 'package:em2rp/views/calendar_page.dart';
import 'package:em2rp/views/login_page.dart';
import 'package:em2rp/views/equipment_management_page.dart';
import 'package:em2rp/views/container_management_page.dart';
import 'package:em2rp/views/container_form_page.dart';
import 'package:em2rp/views/container_detail_page.dart';
import 'package:em2rp/views/event_preparation_page.dart';
import 'package:em2rp/models/container_model.dart';
import 'package:em2rp/models/event_model.dart';
import 'package:firebase_auth/firebase_auth.dart';
import 'package:cloud_firestore/cloud_firestore.dart';
import 'package:flutter/material.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';
import 'utils/colors.dart';
import 'views/my_account_page.dart';
import 'views/user_management_page.dart';
import 'package:provider/provider.dart';
import 'providers/local_user_provider.dart';
import 'views/reset_password_page.dart';
import 'config/env.dart';
import 'config/api_config.dart';
import 'package:flutter_localizations/flutter_localizations.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await Firebase.initializeApp(
    options: DefaultFirebaseOptions.currentPlatform,
  );

  // Configuration des émulateurs en mode développement
  if (ApiConfig.isDevelopment) {
    print('🔧 Mode développement activé - Utilisation des émulateurs');

    // Configurer l'émulateur Auth
    await FirebaseAuth.instance.useAuthEmulator('localhost', 9199);
    print('✓ Auth émulateur configuré: localhost:9199');

    // Configurer l'émulateur Firestore
    FirebaseFirestore.instance.useFirestoreEmulator('localhost', 8088);
    print('✓ Firestore émulateur configuré: localhost:8088');
  }

  await FirebaseAuth.instance.setPersistence(Persistence.LOCAL);

  runApp(
    MultiProvider(
      providers: [
        // LocalUserProvider pour la gestion de l'authentification
        ChangeNotifierProvider<LocalUserProvider>(
            create: (context) => LocalUserProvider()),

        // UsersProvider migré vers l'API
        ChangeNotifierProvider<UsersProvider>(
          create: (context) => UsersProvider(),
        ),

        // EventProvider migré vers l'API
        ChangeNotifierProvider<EventProvider>(
          create: (context) => EventProvider(),
        ),

        // EquipmentProvider migré vers l'API
        ChangeNotifierProvider<EquipmentProvider>(
          create: (context) => EquipmentProvider(),
        ),

        // ContainerProvider migré vers l'API
        ChangeNotifierProvider<ContainerProvider>(
          create: (context) => ContainerProvider(),
        ),

        // MaintenanceProvider migré vers l'API
        ChangeNotifierProvider<MaintenanceProvider>(
          create: (context) => MaintenanceProvider(),
        ),
        ChangeNotifierProvider<AlertProvider>(
          create: (context) => AlertProvider(),
        ),
      ],
      child: const MyApp(),
    ),
  );
}

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

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'EM2 ERP',
      theme: ThemeData(
        primarySwatch: Colors.red,
        primaryColor: AppColors.noir,
        colorScheme:
            ColorScheme.fromSwatch().copyWith(secondary: AppColors.rouge),
        textTheme: const TextTheme(
          bodyMedium: TextStyle(color: AppColors.noir),
        ),
        inputDecorationTheme: const InputDecorationTheme(
          focusedBorder: OutlineInputBorder(
            borderSide: BorderSide(color: AppColors.noir),
          ),
          enabledBorder: OutlineInputBorder(
            borderSide: BorderSide(color: AppColors.gris),
          ),
          labelStyle: TextStyle(color: AppColors.noir),
          hintStyle: TextStyle(color: AppColors.gris),
        ),
        elevatedButtonTheme: ElevatedButtonThemeData(
          style: ElevatedButton.styleFrom(
            foregroundColor: AppColors.blanc,
            backgroundColor: AppColors.noir,
          ),
        ),
      ),
      locale: const Locale('fr', 'FR'),
      supportedLocales: const [
        Locale('fr', 'FR'),
      ],
      localizationsDelegates: const [
        GlobalMaterialLocalizations.delegate,
        GlobalWidgetsLocalizations.delegate,
        GlobalCupertinoLocalizations.delegate,
      ],
      initialRoute: '/',
      routes: {
        '/': (context) => const AutoLoginWrapper(),
        '/login': (context) => const LoginPage(),
        '/alerts': (context) => const AuthGuard(child: AlertsPage()),
        '/calendar': (context) => const AuthGuard(child: CalendarPage()),
        '/my_account': (context) => const AuthGuard(child: MyAccountPage()),
        '/user_management': (context) => const AuthGuard(
            requiredPermission: "view_all_users", child: UserManagementPage()),
        '/reset_password': (context) {
          final args = ModalRoute.of(context)!.settings.arguments
              as Map<String, dynamic>;
          return ResetPasswordPage(
            email: args['email'] as String,
            actionCode: args['actionCode'] as String,
          );
        },
        '/equipment_management': (context) => const AuthGuard(
            requiredPermission: "view_equipment",
            child: EquipmentManagementPage()),
        '/container_management': (context) => const AuthGuard(
            requiredPermission: "view_equipment",
            child: ContainerManagementPage()),
        '/container_form': (context) {
          final args = ModalRoute.of(context)?.settings.arguments;
          return AuthGuard(
            requiredPermission: "manage_equipment",
            child: ContainerFormPage(
              container: args as ContainerModel?,
            ),
          );
        },
        '/container_detail': (context) {
          final container = ModalRoute.of(context)!.settings.arguments as ContainerModel;
          return AuthGuard(
            requiredPermission: "view_equipment",
            child: ContainerDetailPage(container: container),
          );
        },
        '/event_preparation': (context) {
          final args = ModalRoute.of(context)!.settings.arguments as Map<String, dynamic>;
          final event = args['event'] as EventModel;
          return AuthGuard(
            child: EventPreparationPage(
              initialEvent: event,
            ),
          );
        },
      },
    );
  }
}

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

  @override
  State<AutoLoginWrapper> createState() => _AutoLoginWrapperState();
}

class _AutoLoginWrapperState extends State<AutoLoginWrapper> {
  @override
  void initState() {
    super.initState();
    _autoLogin();
  }

  Future<void> _autoLogin() async {
    try {
      final localAuthProvider =
          Provider.of<LocalUserProvider>(context, listen: false);

      // Vérifier si l'utilisateur est déjà connecté
      if (FirebaseAuth.instance.currentUser == null && Env.isDevelopment) {
        // Connexion automatique en mode développement
        await localAuthProvider.signInWithEmailAndPassword(
          Env.devAdminEmail,
          Env.devAdminPassword,
        );
      }

      // Charger les données utilisateur
      await localAuthProvider.loadUserData();

      if (mounted) {
        // MODIFIÉ : Vérifier si une route spécifique est demandée dans l'URL
        // En Flutter Web, on peut vérifier window.location.hash
        final currentUri = Uri.base;
        final fragment = currentUri.fragment; // Ex: "/alerts" si URL est /#/alerts

        print('[AutoLoginWrapper] Fragment URL: $fragment');

        // Si une route spécifique est demandée (autre que / ou vide)
        if (fragment.isNotEmpty && fragment != '/' && fragment != '/calendar') {
          print('[AutoLoginWrapper] Redirection vers: $fragment');
          Navigator.of(context).pushReplacementNamed(fragment);
        } else {
          // Route par défaut : calendrier
          print('[AutoLoginWrapper] Redirection vers: /calendar (défaut)');
          Navigator.of(context).pushReplacementNamed('/calendar');
        }
      }
    } catch (e) {
      print('Auto login failed: $e');
      if (mounted) {
        Navigator.of(context).pushReplacementNamed('/login');
      }
    }
  }

  @override
  Widget build(BuildContext context) {
    return const Scaffold(
      body: Center(
        child: CircularProgressIndicator(),
      ),
    );
  }
}