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/repositories/user_repository.dart';
import 'package:geosector_app/core/constants/app_keys.dart';
import 'package:geosector_app/shared/app_theme.dart';
import 'package:geosector_app/presentation/widgets/loading_progress_overlay.dart';
import 'package:geosector_app/core/models/loading_state.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_entite.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({Key? key}) : super(key: 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;

  // Index de la page Amicale et membres
  static const int entitePageIndex = 5;

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

  // Overlay pour afficher la progression du chargement
  OverlayEntry? _progressOverlay;

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

    try {
      debugPrint('Initialisation de AdminDashboardPage');

      // Vérifier que userRepository est correctement initialisé
      if (userRepository == null) {
        debugPrint('ERREUR: userRepository est null dans AdminDashboardPage');
      } else {
        debugPrint('userRepository est correctement initialisé');

        // Vérifier l'utilisateur courant
        final currentUser = userRepository.getCurrentUser();
        if (currentUser == null) {
          debugPrint(
            'ERREUR: Aucun utilisateur connecté dans AdminDashboardPage',
          );
        } else {
          debugPrint(
            'Utilisateur connecté: ${currentUser.username} (${currentUser.id})',
          );
        }

        // Écouter les changements d'état du UserRepository
        userRepository.addListener(_handleUserRepositoryChanges);
      }

      _pages = [
        const AdminDashboardHomePage(),
        const AdminStatisticsPage(),
        const AdminHistoryPage(),
        const AdminCommunicationPage(),
        const AdminMapPage(),
        const AdminEntitePage(),
      ];

      // 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);
    if (userRepository != null) {
      userRepository.removeListener(_handleUserRepositoryChanges);
    }
    _removeProgressOverlay();
    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
  }

  // Méthodes pour gérer l'overlay de progression (désactivées)
  void _showProgressOverlay(LoadingState state) {
    // La barre de progression est désactivée, ne rien faire
  }

  void _updateProgressOverlay(LoadingState state) {
    // La barre de progression est désactivée, ne rien faire
  }

  void _removeProgressOverlay() {
    // 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: Container(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],
        ),
      ],
    );
  }

  /// Construit la liste des destinations de navigation
  List<NavigationDestination> _buildNavigationDestinations() {
    // Destinations de base toujours présentes
    final List<NavigationDestination> destinations = [
      const NavigationDestination(
        icon: Icon(Icons.dashboard_outlined),
        selectedIcon: Icon(Icons.dashboard),
        label: 'Tableau de bord',
      ),
      const NavigationDestination(
        icon: Icon(Icons.bar_chart_outlined),
        selectedIcon: Icon(Icons.bar_chart),
        label: 'Statistiques',
      ),
      const NavigationDestination(
        icon: Icon(Icons.history_outlined),
        selectedIcon: Icon(Icons.history),
        label: 'Historique',
      ),
      const NavigationDestination(
        icon: Icon(Icons.chat_outlined),
        selectedIcon: Icon(Icons.chat),
        label: 'Messages',
      ),
      const NavigationDestination(
        icon: Icon(Icons.map_outlined),
        selectedIcon: Icon(Icons.map),
        label: 'Carte',
      ),
    ];

    // Ajouter la destination "Amicale et membres"
    destinations.add(
      const NavigationDestination(
        icon: Icon(Icons.business_outlined),
        selectedIcon: Icon(Icons.business),
        label: 'Amicale',
      ),
    );

    return destinations;
  }
}