import 'package:flutter/material.dart';
import 'package:flutter/foundation.dart' show kIsWeb;
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/repositories/amicale_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/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 amicaleRepository = AmicaleRepository(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
      // Gestionnaire de redirection global - intercepte toutes les navigations
      redirect: (context, state) {
        // Détection manuelle des paramètres d'URL pour le Web
        if (kIsWeb && state.uri.path == '/login') {
          try {
            // Obtenir le paramètre 'type' de l'URL actuelle
            final typeParam = state.uri.queryParameters['type'];

            // Obtenir l'URL brute du navigateur pour comparer
            final rawUri = Uri.parse(Uri.base.toString());
            final rawTypeParam = rawUri.queryParameters['type'];

            print('APP ROUTER: state.uri = ${state.uri}, type = $typeParam');
            print('APP ROUTER: rawUri = $rawUri, type = $rawTypeParam');

            // Pas de redirection si on a déjà le paramètre type
            if (typeParam != null) {
              print('APP ROUTER: Param type déjà présent, pas de redirection');
              return null; // Pas de redirection
            }

            // Si un paramètre type=user est présent dans l'URL brute mais pas dans l'état
            if (rawTypeParam == 'user' && typeParam == null) {
              print(
                  'APP ROUTER: Paramètre détecté dans l\'URL brute, redirection vers /login?type=user');
              return '/login?type=user';
            }
          } catch (e) {
            print('Erreur lors de la récupération des paramètres d\'URL: $e');
          }
        }
        // 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')) {
            userRepository.updateLastPath(state.uri.toString());
          }
        }

        // Vérifier si l'utilisateur est sur la page de splash
        if (state.uri.toString() == '/') {
          // Laisser l'utilisateur sur la page de splash, la redirection sera gérée par SplashPage
          return null;
        }

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

        // 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)) {
          // Récupérer le rôle de l'utilisateur directement
          final user = userRepository.getCurrentUser();
          if (user != null) {
            // Convertir le rôle en int si nécessaire
            int roleValue;
            if (user.role is String) {
              roleValue = int.tryParse(user.role as String) ?? 1;
            } else {
              roleValue = user.role as int;
            }

            // Redirection simple basée sur le rôle
            if (roleValue > 1) {
              debugPrint(
                  'Router: Redirection vers /admin (rôle $roleValue > 1)');
              return '/admin';
            } else {
              debugPrint(
                  'Router: Redirection vers /user (rôle $roleValue = 1)');
              return '/user';
            }
          }
        }

        // Si l'utilisateur est connecté mais essaie d'accéder à la mauvaise page selon son rôle
        if (isLoggedIn) {
          final user = userRepository.getCurrentUser();
          if (user != null) {
            // Convertir le rôle en int si nécessaire
            int roleValue;
            if (user.role is String) {
              roleValue = int.tryParse(user.role as String) ?? 1;
            } else {
              roleValue = user.role as int;
            }

            // Vérifier si l'utilisateur est sur la bonne page en fonction de son rôle
            final isOnUserPage = state.uri.toString().startsWith('/user');
            final isOnAdminPage = state.uri.toString().startsWith('/admin');

            // Admin (rôle > 1) essayant d'accéder à une page utilisateur
            if (roleValue > 1 && isOnUserPage) {
              debugPrint(
                  'Router: Redirection d\'admin (rôle $roleValue) vers /admin');
              return '/admin';
            }

            // Utilisateur standard (rôle = 1) essayant d'accéder à une page admin
            if (roleValue == 1 && isOnAdminPage) {
              debugPrint(
                  'Router: Redirection d\'utilisateur (rôle $roleValue) vers /user');
              return '/user';
            }
          }
        }

        return null;
      },
      routes: [
        // Splash screen
        GoRoute(
          path: '/',
          builder: (context, state) => const SplashPage(),
        ),

        // Page de connexion utilisateur dédiée
        GoRoute(
          path: '/login/user',
          builder: (context, state) {
            print('ROUTER: Accès direct à la route login user');
            return const LoginPage(
              key: Key('login_page_user'),
              loginType: 'user',
            );
          },
        ),

        // Pages d'authentification standard
        GoRoute(
          path: '/login',
          builder: (context, state) {
            // Ajouter des logs de débogage détaillés pour comprendre les paramètres
            print('ROUTER DEBUG: Uri complète = ${state.uri}');
            print('ROUTER DEBUG: Path = ${state.uri.path}');
            print('ROUTER DEBUG: Query params = ${state.uri.queryParameters}');
            print(
                'ROUTER DEBUG: Has type? ${state.uri.queryParameters.containsKey("type")}');

            // Donner la priorité aux paramètres d'URL puis aux extras
            String? loginType;

            // 1. Essayer d'abord les paramètres d'URL (pour les liens externes)
            final queryParams = state.uri.queryParameters;
            loginType = queryParams['type'];
            print('ROUTER DEBUG: Type from query params = $loginType');

            // 2. Si aucun type dans les paramètres d'URL, vérifier les extras (pour la navigation interne)
            if (loginType == null &&
                state.extra != null &&
                state.extra is Map<String, dynamic>) {
              final extras = state.extra as Map<String, dynamic>;
              loginType = extras['type']?.toString();
              print('ROUTER DEBUG: Type from extras = $loginType');
            }

            // 3. Normaliser et valider le type
            if (loginType != null) {
              loginType = loginType.trim().toLowerCase();
              // Vérifier explicitement que c'est 'user', sinon mettre 'admin'
              if (loginType != 'user') {
                loginType = 'admin';
              }
            } else {
              // Si aucun type n'est spécifié, retourner la page de splash
              print(
                  'ROUTER: Aucun type spécifié, utilisation de la page splash');
              return const SplashPage();
            }

            print('ROUTER: Type de connexion final: $loginType');

            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,
    );
  }
}