Livraison d ela gestion des opérations v0.4.0

app/lib/presentation/auth/splash_page.dart

@@ -1,18 +1,7 @@
 import 'package:flutter/material.dart';
 import 'package:go_router/go_router.dart';
-import 'package:hive_flutter/hive_flutter.dart';
 import 'package:geosector_app/core/services/app_info_service.dart';
-import 'package:geosector_app/core/constants/app_keys.dart';
-import 'package:geosector_app/core/data/models/user_model.dart';
-import 'package:geosector_app/core/data/models/amicale_model.dart';
-import 'package:geosector_app/core/data/models/client_model.dart';
-import 'package:geosector_app/core/data/models/operation_model.dart';
-import 'package:geosector_app/core/data/models/sector_model.dart';
-import 'package:geosector_app/core/data/models/passage_model.dart';
-import 'package:geosector_app/core/data/models/membre_model.dart';
-import 'package:geosector_app/core/data/models/user_sector_model.dart';
-import 'package:geosector_app/chat/models/conversation_model.dart';
-import 'package:geosector_app/chat/models/message_model.dart';
+import 'package:geosector_app/core/services/hive_service.dart';
 import 'dart:async';
 import 'dart:math' as math;
 import 'package:flutter/foundation.dart' show kIsWeb;
@@ -108,337 +97,66 @@ class _SplashPageState extends State<SplashPage> with SingleTickerProviderStateM
   }
 
   void _startInitialization() async {
-    // Table rase complète et recréation propre
-    await _completeReset();
-
-    // Finalisation
-    if (mounted) {
-      setState(() {
-        _statusMessage = "Application prête !";
-        _progress = 1.0;
-        _isInitializing = false;
-        _showButtons = true;
-      });
-    }
-  }
-
-  /// RESET COMPLET : Destruction totale et recréation propre
-  Future<void> _completeReset() async {
     try {
-      debugPrint('🧹 RESET COMPLET : Destruction totale des données Hive...');
-
-      // Étape 1: Sauvegarder les utilisateurs existants (optionnel)
-      Map<dynamic, UserModel>? existingUsers;
+      debugPrint('🚀 Début de l\'initialisation complète de l\'application...');
 
+      // Étape 1: Initialisation complète de Hive avec HiveService
       if (mounted) {
         setState(() {
-          _statusMessage = "Sauvegarde des utilisateurs...";
-          _progress = 0.05;
+          _statusMessage = "Initialisation de la base de données...";
+          _progress = 0.1;
         });
       }
 
-      try {
-        if (Hive.isBoxOpen(AppKeys.userBoxName)) {
-          final userBox = Hive.box<UserModel>(AppKeys.userBoxName);
-          existingUsers = Map.from(userBox.toMap());
-          debugPrint('📦 ${existingUsers.length} utilisateurs sauvegardés');
-        }
-      } catch (e) {
-        debugPrint('⚠️ Erreur sauvegarde utilisateurs: $e');
-        existingUsers = null;
-      }
-
-      // Étape 2: DESTRUCTION RADICALE - Fermer tout ce qui peut être ouvert
-      if (mounted) {
-        setState(() {
-          _statusMessage = "Fermeture de toutes les bases de données...";
-          _progress = 0.15;
-        });
-      }
-
-      await _closeAllKnownBoxes();
-
-      // Étape 3: DESTRUCTION RADICALE - Supprimer tout Hive du disque
-      if (mounted) {
-        setState(() {
-          _statusMessage = "Suppression complète des anciennes données...";
-          _progress = 0.25;
-        });
-      }
-
-      await _nukeHiveCompletely();
-
-      // Étape 4: RECRÉATION PROPRE
-      if (mounted) {
-        setState(() {
-          _statusMessage = "Création des nouvelles bases de données...";
-          _progress = 0.40;
-        });
-      }
-
-      await _createAllBoxesFresh();
-
-      // Étape 5: Restaurer les utilisateurs (optionnel)
-      if (existingUsers != null && existingUsers.isNotEmpty) {
-        if (mounted) {
-          setState(() {
-            _statusMessage = "Restauration des utilisateurs...";
-            _progress = 0.80;
-          });
-        }
-
-        await _restoreUsers(existingUsers);
-      }
-
-      // Étape 6: Vérification finale
+      // HiveService fait TOUT le travail lourd (adaptateurs, destruction, recréation)
+      await HiveService.instance.initializeAndResetHive();
       if (mounted) {
         setState(() {
           _statusMessage = "Vérification des bases de données...";
-          _progress = 0.90;
+          _progress = 0.7;
         });
       }
 
-      debugPrint('✅ RESET COMPLET terminé avec succès');
-    } catch (e) {
-      debugPrint('❌ Erreur lors du reset complet: $e');
+      // Étape 2: S'assurer que toutes les Box sont ouvertes
+      await HiveService.instance.ensureBoxesAreOpen();
 
       if (mounted) {
         setState(() {
-          _statusMessage = "Erreur critique - Redémarrage recommandé";
+          _statusMessage = "Finalisation...";
+          _progress = 0.9;
+        });
+      }
+
+      // Étape 3: Vérification finale
+      final allBoxesOpen = HiveService.instance.areAllBoxesOpen();
+      if (!allBoxesOpen) {
+        final diagnostic = HiveService.instance.getDiagnostic();
+        debugPrint('❌ Diagnostic des Box: $diagnostic');
+        throw Exception('Certaines bases de données ne sont pas accessibles');
+      }
+
+      // Finalisation
+      if (mounted) {
+        setState(() {
+          _statusMessage = "Application prête !";
           _progress = 1.0;
           _isInitializing = false;
           _showButtons = true;
         });
       }
-    }
-  }
 
-  /// Ferme toutes les boîtes connues
-  Future<void> _closeAllKnownBoxes() async {
-    try {
-      final allKnownBoxes = [
-        AppKeys.userBoxName,
-        AppKeys.amicaleBoxName,
-        AppKeys.clientsBoxName,
-        AppKeys.regionsBoxName,
-        AppKeys.operationsBoxName,
-        AppKeys.sectorsBoxName,
-        AppKeys.passagesBoxName,
-        AppKeys.membresBoxName,
-        AppKeys.userSectorBoxName,
-        AppKeys.settingsBoxName,
-        AppKeys.chatConversationsBoxName,
-        AppKeys.chatMessagesBoxName,
-        // Boîtes potentiellement problématiques
-        'auth', 'locations', 'messages', 'temp'
-      ];
-
-      debugPrint('🔒 Fermeture de ${allKnownBoxes.length} boîtes connues...');
-
-      for (final boxName in allKnownBoxes) {
-        try {
-          if (Hive.isBoxOpen(boxName)) {
-            await Hive.box(boxName).close();
-            debugPrint('✅ Boîte $boxName fermée');
-          }
-        } catch (e) {
-          debugPrint('⚠️ Erreur fermeture $boxName: $e');
-          // Continuer même en cas d'erreur
-        }
-      }
-
-      await Future.delayed(const Duration(milliseconds: 1000));
+      debugPrint('✅ Initialisation complète de l\'application terminée avec succès');
     } catch (e) {
-      debugPrint('❌ Erreur fermeture des boîtes: $e');
-    }
-  }
+      debugPrint('❌ Erreur lors de l\'initialisation: $e');
 
-  /// Suppression RADICALE de tout Hive
-  Future<void> _nukeHiveCompletely() async {
-    try {
-      debugPrint('💥 DESTRUCTION NUCLÉAIRE de Hive...');
-
-      if (kIsWeb) {
-        // En version web, supprimer toutes les boîtes possibles une par une
-        final allPossibleBoxes = [
-          AppKeys.userBoxName,
-          AppKeys.amicaleBoxName,
-          AppKeys.clientsBoxName,
-          AppKeys.regionsBoxName,
-          AppKeys.operationsBoxName,
-          AppKeys.sectorsBoxName,
-          AppKeys.passagesBoxName,
-          AppKeys.membresBoxName,
-          AppKeys.userSectorBoxName,
-          AppKeys.settingsBoxName,
-          AppKeys.chatConversationsBoxName,
-          AppKeys.chatMessagesBoxName,
-          // Toutes les boîtes potentiellement corrompues
-          'auth', 'locations', 'messages', 'temp', 'cache', 'data'
-        ];
-
-        for (final boxName in allPossibleBoxes) {
-          try {
-            await Hive.deleteBoxFromDisk(boxName);
-            debugPrint('✅ Boîte $boxName DÉTRUITE');
-          } catch (e) {
-            debugPrint('⚠️ Erreur destruction $boxName: $e');
-          }
-        }
-      } else {
-        // Sur mobile/desktop, destruction totale
-        try {
-          await Hive.deleteFromDisk();
-          debugPrint('✅ Hive COMPLÈTEMENT DÉTRUIT');
-        } catch (e) {
-          debugPrint('⚠️ Erreur destruction totale: $e');
-          // Fallback : supprimer boîte par boîte
-          await _deleteBoxesOneByOne();
-        }
+      if (mounted) {
+        setState(() {
+          _statusMessage = "Erreur d'initialisation - Redémarrage recommandé";
+          _progress = 1.0;
+          _isInitializing = false;
+          _showButtons = true;
+        });
       }
-
-      // Attendre pour s'assurer que tout est détruit
-      await Future.delayed(const Duration(seconds: 2));
-    } catch (e) {
-      debugPrint('❌ Erreur destruction Hive: $e');
-    }
-  }
-
-  /// Fallback : supprimer les boîtes une par une
-  Future<void> _deleteBoxesOneByOne() async {
-    final allBoxes = [
-      AppKeys.userBoxName,
-      AppKeys.amicaleBoxName,
-      AppKeys.clientsBoxName,
-      AppKeys.regionsBoxName,
-      AppKeys.operationsBoxName,
-      AppKeys.sectorsBoxName,
-      AppKeys.passagesBoxName,
-      AppKeys.membresBoxName,
-      AppKeys.userSectorBoxName,
-      AppKeys.settingsBoxName,
-      AppKeys.chatConversationsBoxName,
-      AppKeys.chatMessagesBoxName,
-    ];
-
-    for (final boxName in allBoxes) {
-      try {
-        await Hive.deleteBoxFromDisk(boxName);
-        debugPrint('✅ Boîte $boxName supprimée (fallback)');
-      } catch (e) {
-        debugPrint('⚠️ Erreur suppression fallback $boxName: $e');
-      }
-    }
-  }
-
-  /// Recrée toutes les boîtes VIDES et PROPRES
-  Future<void> _createAllBoxesFresh() async {
-    try {
-      debugPrint('🆕 Création de toutes les boîtes vides...');
-
-      final boxesToCreate = [
-        {'name': AppKeys.userBoxName, 'type': 'UserModel'},
-        {'name': AppKeys.amicaleBoxName, 'type': 'AmicaleModel'},
-        {'name': AppKeys.clientsBoxName, 'type': 'ClientModel'},
-        {'name': AppKeys.regionsBoxName, 'type': 'dynamic'},
-        {'name': AppKeys.operationsBoxName, 'type': 'OperationModel'},
-        {'name': AppKeys.sectorsBoxName, 'type': 'SectorModel'},
-        {'name': AppKeys.passagesBoxName, 'type': 'PassageModel'},
-        {'name': AppKeys.membresBoxName, 'type': 'MembreModel'},
-        {'name': AppKeys.userSectorBoxName, 'type': 'UserSectorModel'},
-        {'name': AppKeys.settingsBoxName, 'type': 'dynamic'},
-        {'name': AppKeys.chatConversationsBoxName, 'type': 'ConversationModel'},
-        {'name': AppKeys.chatMessagesBoxName, 'type': 'MessageModel'},
-      ];
-
-      final progressIncrement = 0.35 / boxesToCreate.length; // De 0.40 à 0.75
-
-      for (int i = 0; i < boxesToCreate.length; i++) {
-        final boxInfo = boxesToCreate[i];
-        final boxName = boxInfo['name'] as String;
-        final boxType = boxInfo['type'] as String;
-
-        if (mounted) {
-          setState(() {
-            _statusMessage = "Création de $boxName...";
-            _progress = 0.40 + (progressIncrement * i);
-          });
-        }
-
-        try {
-          // Créer la boîte avec le bon type
-          switch (boxType) {
-            case 'UserModel':
-              await Hive.openBox<UserModel>(boxName);
-              break;
-            case 'AmicaleModel':
-              await Hive.openBox<AmicaleModel>(boxName);
-              break;
-            case 'ClientModel':
-              await Hive.openBox<ClientModel>(boxName);
-              break;
-            case 'OperationModel':
-              await Hive.openBox<OperationModel>(boxName);
-              break;
-            case 'SectorModel':
-              await Hive.openBox<SectorModel>(boxName);
-              break;
-            case 'PassageModel':
-              await Hive.openBox<PassageModel>(boxName);
-              break;
-            case 'MembreModel':
-              await Hive.openBox<MembreModel>(boxName);
-              break;
-            case 'UserSectorModel':
-              await Hive.openBox<UserSectorModel>(boxName);
-              break;
-            case 'ConversationModel':
-              await Hive.openBox<ConversationModel>(boxName);
-              break;
-            case 'MessageModel':
-              await Hive.openBox<MessageModel>(boxName);
-              break;
-            default:
-              await Hive.openBox(boxName);
-          }
-
-          debugPrint('✅ Boîte $boxName créée (type: $boxType)');
-        } catch (e) {
-          debugPrint('❌ Erreur création $boxName: $e');
-          // En cas d'erreur, essayer sans type
-          try {
-            await Hive.openBox(boxName);
-            debugPrint('⚠️ Boîte $boxName créée sans type');
-          } catch (e2) {
-            debugPrint('❌ Échec total création $boxName: $e2');
-          }
-        }
-
-        await Future.delayed(const Duration(milliseconds: 200));
-      }
-    } catch (e) {
-      debugPrint('❌ Erreur création des boîtes: $e');
-    }
-  }
-
-  /// Restaure les utilisateurs sauvegardés
-  Future<void> _restoreUsers(Map<dynamic, UserModel> users) async {
-    try {
-      if (Hive.isBoxOpen(AppKeys.userBoxName)) {
-        final userBox = Hive.box<UserModel>(AppKeys.userBoxName);
-
-        for (final entry in users.entries) {
-          try {
-            await userBox.put(entry.key, entry.value);
-          } catch (e) {
-            debugPrint('⚠️ Erreur restauration utilisateur ${entry.key}: $e');
-          }
-        }
-
-        debugPrint('✅ ${users.length} utilisateurs restaurés');
-      }
-    } catch (e) {
-      debugPrint('❌ Erreur restauration utilisateurs: $e');
     }
   }