geo/flutt/lib/app.dart

import 'package:flutter/material.dart';
import 'package:geosector_app/core/theme/app_theme.dart';
import 'package:go_router/go_router.dart';
import 'package:geosector_app/core/services/api_service.dart';
import 'package:geosector_app/core/repositories/user_repository.dart';
import 'package:geosector_app/core/repositories/operation_repository.dart';
import 'package:geosector_app/core/repositories/passage_repository.dart';
import 'package:geosector_app/core/repositories/sector_repository.dart';
import 'package:geosector_app/core/repositories/membre_repository.dart';
import 'package:geosector_app/core/services/sync_service.dart';
import 'package:geosector_app/core/services/connectivity_service.dart';
import 'package:geosector_app/presentation/auth/splash_page.dart';
import 'package:geosector_app/presentation/public/landing_page.dart';
import 'package:geosector_app/presentation/auth/login_page.dart';
import 'package:geosector_app/presentation/auth/register_page.dart';
import 'package:geosector_app/presentation/admin/admin_dashboard_page.dart';
import 'package:geosector_app/presentation/user/user_dashboard_page.dart';

// Instances globales des services et repositories
final apiService = ApiService();
final operationRepository = OperationRepository(apiService);
final passageRepository = PassageRepository(apiService);
final userRepository = UserRepository(apiService);
final sectorRepository = SectorRepository(apiService);
final membreRepository = MembreRepository(apiService);
final syncService = SyncService(userRepository: userRepository);
final connectivityService = ConnectivityService();

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

  @override
  Widget build(BuildContext context) {
    // Utiliser directement le router sans provider
    final router = GoRouter(
      initialLocation: '/',
      debugLogDiagnostics: true,
      refreshListenable:
          userRepository, // Écouter les changements d'état d'authentification
      redirect: (context, state) {
        // Sauvegarder le chemin actuel pour l'utilisateur connecté, sauf pour la page de splash
        if (state.uri.toString() != '/' && userRepository.isLoggedIn) {
          // Ne pas sauvegarder les chemins de login/register
          if (!state.uri.toString().startsWith('/login') &&
              !state.uri.toString().startsWith('/register') &&
              !state.uri.toString().startsWith('/public')) {
            userRepository.updateLastPath(state.uri.toString());
          }
        }

        // Vérifier si l'utilisateur est sur la page de splash
        if (state.uri.toString() == '/') {
          // Vérifier si l'utilisateur a une session valide
          final currentUser = userRepository.getCurrentUser();
          if (currentUser == null || currentUser.sessionId == null) {
            // Si pas de session valide, rediriger vers la landing page
            return '/public';
          }

          // Si l'utilisateur a une session valide et un chemin précédent, y retourner
          final lastPath = userRepository.getLastPath();
          if (lastPath != null && lastPath.isNotEmpty) {
            return lastPath;
          }

          // Sinon, rediriger vers le tableau de bord approprié
          if (userRepository.isAdmin()) {
            return '/admin';
          } else {
            return '/user';
          }
        }

        // Vérifier si l'utilisateur est sur une page d'authentification
        final isLoggedIn = userRepository.isLoggedIn;
        final isOnLoginPage = state.uri.toString() == '/login';
        final isOnRegisterPage = state.uri.toString() == '/register';
        final isOnAdminRegisterPage = state.uri.toString() == '/admin-register';
        final isOnPublicPage = state.uri.toString() == '/public';

        // Vérifier si l'utilisateur vient de la landing page et va vers la page de connexion
        // Cette information est stockée dans les paramètres de la route
        final isFromLandingPage =
            state.uri.queryParameters['from'] == 'landing';

        // Permettre l'accès aux pages publiques sans authentification
        if (isOnPublicPage) {
          return null;
        }

        // Si l'utilisateur vient de la landing page et va vers la page de connexion ou d'inscription,
        // ne pas rediriger, même s'il est déjà connecté
        if ((isOnLoginPage || isOnRegisterPage) && isFromLandingPage) {
          return null;
        }

        // Si l'utilisateur n'est pas connecté et n'est pas sur une page d'authentification, rediriger vers la page de connexion
        if (!isLoggedIn &&
            !isOnLoginPage &&
            !isOnRegisterPage &&
            !isOnAdminRegisterPage) {
          return '/login';
        }

        // Si l'utilisateur est connecté et se trouve sur une page d'authentification, rediriger vers le tableau de bord approprié
        if (isLoggedIn &&
            (isOnLoginPage || isOnRegisterPage || isOnAdminRegisterPage)) {
          if (userRepository.isAdmin()) {
            return '/admin';
          } else {
            return '/user';
          }
        }

        // Si l'utilisateur est connecté en tant qu'administrateur mais essaie d'accéder à une page utilisateur, rediriger vers le tableau de bord admin
        if (isLoggedIn &&
            userRepository.isAdmin() &&
            state.uri.toString().startsWith('/user')) {
          return '/admin';
        }

        // Si l'utilisateur est connecté en tant qu'utilisateur mais essaie d'accéder à une page admin, rediriger vers le tableau de bord utilisateur
        if (isLoggedIn &&
            !userRepository.isAdmin() &&
            state.uri.toString().startsWith('/admin')) {
          return '/user';
        }

        return null;
      },
      routes: [
        // Splash screen et page de démarrage
        GoRoute(
          path: '/',
          builder: (context, state) => const SplashPage(),
        ),

        // Pages publiques
        GoRoute(
          path: '/public',
          builder: (context, state) => const LandingPage(),
        ),

        // Pages d'authentification
        GoRoute(
          path: '/login',
          builder: (context, state) {
            // Extraire le type de connexion depuis les extras
            Map<String, dynamic>? extras;
            if (state.extra != null && state.extra is Map<String, dynamic>) {
              extras = state.extra as Map<String, dynamic>;
            }

            String? loginType = extras?['type'];
            print('DEBUG ROUTER: Type dans les extras: $loginType');

            // Nettoyer le paramètre type si présent
            if (loginType != null) {
              loginType = loginType.trim().toLowerCase();
              print('DEBUG ROUTER: Type nettoyé: $loginType');
            } else {
              // Fallback: essayer de récupérer depuis les paramètres d'URL
              final queryParams = state.uri.queryParameters;
              loginType = queryParams['type'];
              if (loginType != null) {
                loginType = loginType.trim().toLowerCase();
                print('DEBUG ROUTER: Type récupéré des params URL: $loginType');
              } else {
                loginType = 'admin'; // Valeur par défaut
                print('DEBUG ROUTER: Type par défaut: admin');
              }
            }

            return LoginPage(
              key: Key('login_page_${loginType}'),
              loginType: loginType,
            );
          },
        ),
        GoRoute(
          path: '/register',
          builder: (context, state) => const RegisterPage(),
        ),

        // Pages administrateur
        GoRoute(
          path: '/admin',
          builder: (context, state) => const AdminDashboardPage(),
          routes: [
            // Ajouter d'autres routes admin ici
          ],
        ),

        // Pages utilisateur
        GoRoute(
          path: '/user',
          builder: (context, state) => const UserDashboardPage(),
          routes: [
            // Ajouter d'autres routes utilisateur ici
          ],
        ),
      ],
    );

    return MaterialApp.router(
      debugShowCheckedModeBanner: false,
      title: 'GEOSECTOR',
      theme: AppTheme.lightTheme,
      darkTheme: AppTheme.darkTheme,
      themeMode: ThemeMode.system,
      routerConfig: router,
    );
  }
}