geo/app/lib/presentation/admin/admin_dashboard_page.dart

import 'package:geosector_app/app.dart'; // Pour accéder aux instances globales
import 'package:flutter/material.dart';
import 'package:hive_flutter/hive_flutter.dart';
import 'package:geosector_app/presentation/widgets/dashboard_layout.dart';
import 'package:geosector_app/core/constants/app_keys.dart';
import 'dart:math' as math;

// Import des pages admin
import 'admin_dashboard_home_page.dart';
import 'admin_statistics_page.dart';
import 'admin_history_page.dart';
import 'admin_communication_page.dart';
import 'admin_map_page.dart';
import 'admin_amicale_page.dart';

/// Class pour dessiner les petits points blancs sur le fond
class DotsPainter extends CustomPainter {
  @override
  void paint(Canvas canvas, Size size) {
    final paint = Paint()
      ..color = Colors.white.withOpacity(0.5)
      ..style = PaintingStyle.fill;

    final random = math.Random(42); // Seed fixe pour consistance
    final numberOfDots = (size.width * size.height) ~/ 1500;

    for (int i = 0; i < numberOfDots; i++) {
      final x = random.nextDouble() * size.width;
      final y = random.nextDouble() * size.height;
      final radius = 1.0 + random.nextDouble() * 2.0;
      canvas.drawCircle(Offset(x, y), radius, paint);
    }
  }

  @override
  bool shouldRepaint(covariant CustomPainter oldDelegate) => false;
}

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

  @override
  State<AdminDashboardPage> createState() => _AdminDashboardPageState();
}

class _AdminDashboardPageState extends State<AdminDashboardPage> with WidgetsBindingObserver {
  int _selectedIndex = 0;

  // Liste des pages à afficher
  late final List<Widget> _pages;

  // Référence à la boîte Hive pour les paramètres
  late Box _settingsBox;

  // Liste des éléments de navigation de base (toujours visibles)
  final List<_NavigationItem> _baseNavigationItems = [
    const _NavigationItem(
      label: 'Tableau de bord',
      icon: Icons.dashboard_outlined,
      selectedIcon: Icons.dashboard,
      pageType: _PageType.dashboardHome,
    ),
    const _NavigationItem(
      label: 'Statistiques',
      icon: Icons.bar_chart_outlined,
      selectedIcon: Icons.bar_chart,
      pageType: _PageType.statistics,
    ),
    const _NavigationItem(
      label: 'Historique',
      icon: Icons.history_outlined,
      selectedIcon: Icons.history,
      pageType: _PageType.history,
    ),
    const _NavigationItem(
      label: 'Messages',
      icon: Icons.chat_outlined,
      selectedIcon: Icons.chat,
      pageType: _PageType.communication,
    ),
    const _NavigationItem(
      label: 'Carte',
      icon: Icons.map_outlined,
      selectedIcon: Icons.map,
      pageType: _PageType.map,
    ),
  ];

  // Éléments de navigation supplémentaires pour le rôle 2
  final List<_NavigationItem> _adminNavigationItems = [
    const _NavigationItem(
      label: 'Amicale & membres',
      icon: Icons.business_outlined,
      selectedIcon: Icons.business,
      pageType: _PageType.amicale,
      requiredRole: 2,
    ),
    const _NavigationItem(
      label: 'Opérations',
      icon: Icons.calendar_today_outlined,
      selectedIcon: Icons.calendar_today,
      pageType: _PageType.operations,
      requiredRole: 2,
    ),
  ];

  // Construire la page basée sur le type
  Widget _buildPage(_PageType pageType) {
    switch (pageType) {
      case _PageType.dashboardHome:
        return const AdminDashboardHomePage();
      case _PageType.statistics:
        return const AdminStatisticsPage();
      case _PageType.history:
        return const AdminHistoryPage();
      case _PageType.communication:
        return const AdminCommunicationPage();
      case _PageType.map:
        return const AdminMapPage();
      case _PageType.amicale:
        return AdminAmicalePage(
          userRepository: userRepository,
          amicaleRepository: amicaleRepository,
          membreRepository: membreRepository,
          passageRepository: passageRepository,
          operationRepository: operationRepository,
        );
      case _PageType.operations:
        return const Scaffold(body: Center(child: Text('Page Opérations')));
    }
  }

  // Construire la liste des destinations de navigation en fonction du rôle
  List<NavigationDestination> _buildNavigationDestinations() {
    final destinations = <NavigationDestination>[];
    final currentUser = userRepository.getCurrentUser();

    // Ajouter les éléments de base
    for (final item in _baseNavigationItems) {
      destinations.add(
        NavigationDestination(
          icon: Icon(item.icon),
          selectedIcon: Icon(item.selectedIcon),
          label: item.label,
        ),
      );
    }

    // Ajouter les éléments admin si l'utilisateur a le rôle requis
    if (currentUser?.role == 2) {
      for (final item in _adminNavigationItems) {
        if (item.requiredRole == null || item.requiredRole == 2) {
          destinations.add(
            NavigationDestination(
              icon: Icon(item.icon),
              selectedIcon: Icon(item.selectedIcon),
              label: item.label,
            ),
          );
        }
      }
    }

    return destinations;
  }

  // Construire la liste des pages en fonction du rôle
  List<Widget> _buildPages() {
    final pages = <Widget>[];
    final currentUser = userRepository.getCurrentUser();

    // Ajouter les pages de base
    for (final item in _baseNavigationItems) {
      pages.add(_buildPage(item.pageType));
    }

    // Ajouter les pages admin si l'utilisateur a le rôle requis
    if (currentUser?.role == 2) {
      for (final item in _adminNavigationItems) {
        if (item.requiredRole == null || item.requiredRole == 2) {
          pages.add(_buildPage(item.pageType));
        }
      }
    }

    return pages;
  }

  @override
  void initState() {
    super.initState();
    WidgetsBinding.instance.addObserver(this);

    try {
      debugPrint('Initialisation de AdminDashboardPage');

      // Vérifier que userRepository est correctement initialisé
      debugPrint('userRepository est correctement initialisé');
      final currentUser = userRepository.getCurrentUser();
      if (currentUser == null) {
        debugPrint('ERREUR: Aucun utilisateur connecté dans AdminDashboardPage');
      } else {
        debugPrint('Utilisateur connecté: ${currentUser.username} (${currentUser.id})');
      }
      userRepository.addListener(_handleUserRepositoryChanges);

      // Initialiser les pages et les destinations
      _pages = _buildPages();

      // Initialiser et charger les paramètres
      _initSettings();

      // Vérifier si des données sont en cours de chargement
      WidgetsBinding.instance.addPostFrameCallback((_) {
        _checkLoadingState();
      });
    } catch (e) {
      debugPrint('ERREUR CRITIQUE dans AdminDashboardPage.initState: $e');
    }
  }

  @override
  void dispose() {
    WidgetsBinding.instance.removeObserver(this);
    userRepository.removeListener(_handleUserRepositoryChanges);
    super.dispose();
  }

  // Méthode pour gérer les changements d'état du UserRepository
  void _handleUserRepositoryChanges() {
    _checkLoadingState();
  }

  // Méthode pour vérifier l'état de chargement (barre de progression désactivée)
  void _checkLoadingState() {
    // La barre de progression est désactivée, ne rien faire
  }

  // Initialiser la boîte de paramètres et charger les préférences
  Future<void> _initSettings() async {
    try {
      // Ouvrir la boîte de paramètres si elle n'est pas déjà ouverte
      if (!Hive.isBoxOpen(AppKeys.settingsBoxName)) {
        _settingsBox = await Hive.openBox(AppKeys.settingsBoxName);
      } else {
        _settingsBox = Hive.box(AppKeys.settingsBoxName);
      }

      // Charger l'index de page sélectionné
      final savedIndex = _settingsBox.get('adminSelectedPageIndex');

      // Vérifier si l'index sauvegardé est valide
      if (savedIndex != null && savedIndex is int) {
        debugPrint('Index sauvegardé trouvé: $savedIndex');

        // S'assurer que l'index est dans les limites valides
        if (savedIndex >= 0 && savedIndex < _pages.length) {
          setState(() {
            _selectedIndex = savedIndex;
          });
          debugPrint('Index sauvegardé valide, utilisé: $_selectedIndex');
        } else {
          debugPrint(
            'Index sauvegardé invalide ($savedIndex), utilisation de l\'index par défaut: 0',
          );
          // Réinitialiser l'index sauvegardé à 0 si invalide
          _settingsBox.put('adminSelectedPageIndex', 0);
        }
      } else {
        debugPrint(
          'Aucun index sauvegardé trouvé, utilisation de l\'index par défaut: 0',
        );
      }
    } catch (e) {
      debugPrint('Erreur lors du chargement des paramètres: $e');
    }
  }

  // Sauvegarder les paramètres utilisateur
  void _saveSettings() {
    try {
      // Sauvegarder l'index de page sélectionné
      _settingsBox.put('adminSelectedPageIndex', _selectedIndex);
    } catch (e) {
      debugPrint('Erreur lors de la sauvegarde des paramètres: $e');
    }
  }

  @override
  Widget build(BuildContext context) {
    return Stack(
      children: [
        // Fond dégradé avec petits points blancs
        Container(
          decoration: BoxDecoration(
            gradient: LinearGradient(
              begin: Alignment.topCenter,
              end: Alignment.bottomCenter,
              colors: [Colors.white, Colors.red.shade300],
            ),
          ),
          child: CustomPaint(
            painter: DotsPainter(),
            child: const SizedBox(width: double.infinity, height: double.infinity),
          ),
        ),
        // Contenu de la page
        DashboardLayout(
          title: 'Tableau de bord Administration',
          selectedIndex: _selectedIndex,
          onDestinationSelected: (index) {
            setState(() {
              _selectedIndex = index;
              _saveSettings(); // Sauvegarder l'index de page sélectionné
            });
          },
          destinations: _buildNavigationDestinations(),
          showNewPassageButton: false,
          isAdmin: true,
          body: _pages[_selectedIndex],
        ),
      ],
    );
  }
}

// Enum pour les types de pages
enum _PageType {
  dashboardHome,
  statistics,
  history,
  communication,
  map,
  amicale,
  operations,
}

// Classe pour représenter une destination de navigation avec sa page associée
class _NavigationItem {
  final String label;
  final IconData icon;
  final IconData selectedIcon;
  final _PageType pageType;
  final int? requiredRole; // null si accessible à tous les rôles

  const _NavigationItem({
    required this.label,
    required this.icon,
    required this.selectedIcon,
    required this.pageType,
    this.requiredRole,
  });
}