import 'dart:async';
import 'package:geosector_app/core/services/js_stub.dart'
    if (dart.library.js) 'dart:js' as js;
import 'package:flutter/foundation.dart';
import 'package:hive_flutter/hive_flutter.dart';
import 'package:geosector_app/core/constants/app_keys.dart';

/// Service pour gérer les problèmes spécifiques à Hive en version web
class HiveWebFix {
  /// Nettoie en toute sécurité les boîtes Hive en version web
  /// Cette méthode est plus sûre que de supprimer directement IndexedDB
  static Future<void> safeCleanHiveBoxes({List<String>? excludeBoxes}) async {
    if (!kIsWeb) return;

    try {
      debugPrint('HiveWebFix: Nettoyage sécurisé des boîtes Hive en version web');

      // Liste des boîtes à nettoyer
      final boxesToClean = [
        AppKeys.operationsBoxName,
        AppKeys.sectorsBoxName,
        AppKeys.passagesBoxName,
      ];

      // Exclure certaines boîtes si spécifié
      if (excludeBoxes != null) {
        boxesToClean.removeWhere((box) => excludeBoxes.contains(box));
      }

      // Nettoyer chaque boîte individuellement au lieu de supprimer IndexedDB
      for (final boxName in boxesToClean) {
        try {
          if (Hive.isBoxOpen(boxName)) {
            debugPrint('HiveWebFix: Nettoyage de la boîte $boxName');
            final box = Hive.box(boxName);
            await box.clear();
            debugPrint('HiveWebFix: Boîte $boxName nettoyée avec succès');
          } else {
            debugPrint('HiveWebFix: La boîte $boxName n\'est pas ouverte, ouverture temporaire');
            final box = await Hive.openBox(boxName);
            await box.clear();
            await box.close();
            debugPrint('HiveWebFix: Boîte $boxName nettoyée et fermée');
          }
        } catch (e) {
          debugPrint('HiveWebFix: Erreur lors du nettoyage de la boîte $boxName: $e');
        }
      }

      debugPrint('HiveWebFix: Nettoyage sécurisé terminé');
    } catch (e) {
      debugPrint('HiveWebFix: Erreur lors du nettoyage sécurisé: $e');
    }
  }

  /// Vérifie l'intégrité des boîtes Hive et tente de les réparer si nécessaire
  static Future<bool> checkAndRepairHiveBoxes() async {
    if (!kIsWeb) return true;

    try {
      debugPrint('HiveWebFix: Vérification de l\'intégrité des boîtes Hive');

      // Vérifier si IndexedDB est accessible
      final isIndexedDBAvailable = js.context.hasProperty('indexedDB');
      if (!isIndexedDBAvailable) {
        debugPrint('HiveWebFix: IndexedDB n\'est pas disponible dans ce navigateur');
        return false;
      }

      // Liste des boîtes essentielles
      final essentialBoxes = [
        AppKeys.userBoxName,
        AppKeys.settingsBoxName,
      ];

      // Vérifier chaque boîte essentielle
      for (final boxName in essentialBoxes) {
        try {
          if (!Hive.isBoxOpen(boxName)) {
            debugPrint('HiveWebFix: Ouverture de la boîte essentielle $boxName');
            await Hive.openBox(boxName);
          }

          // Vérifier si la boîte est accessible
          final box = Hive.box(boxName);
          // Tenter une opération simple pour vérifier l'intégrité
          final length = box.length;
          debugPrint('HiveWebFix: Boîte $boxName accessible avec $length éléments');
        } catch (e) {
          debugPrint('HiveWebFix: Erreur d\'accès à la boîte $boxName: $e');

          // Tenter de réparer en réinitialisant Hive
          try {
            debugPrint('HiveWebFix: Tentative de réparation de la boîte $boxName');
            // Fermer la boîte si elle est ouverte
            if (Hive.isBoxOpen(boxName)) {
              await Hive.box(boxName).close();
            }

            // Réouvrir la boîte
            await Hive.openBox(boxName);
            debugPrint('HiveWebFix: Boîte $boxName réparée avec succès');
          } catch (repairError) {
            debugPrint('HiveWebFix: Échec de la réparation de la boîte $boxName: $repairError');
            return false;
          }
        }
      }

      debugPrint('HiveWebFix: Toutes les boîtes essentielles sont intègres');
      return true;
    } catch (e) {
      debugPrint('HiveWebFix: Erreur lors de la vérification d\'intégrité: $e');
      return false;
    }
  }

  /// Réinitialise complètement Hive en cas de problème grave
  /// À utiliser en dernier recours car cela supprimera toutes les données
  static Future<void> resetHiveCompletely() async {
    if (!kIsWeb) return;

    try {
      debugPrint('HiveWebFix: Réinitialisation complète de Hive');

      // Fermer toutes les boîtes ouvertes
      final boxesToClose = [
        AppKeys.userBoxName,
        AppKeys.operationsBoxName,
        AppKeys.sectorsBoxName,
        AppKeys.passagesBoxName,
        AppKeys.settingsBoxName,
      ];

      for (final boxName in boxesToClose) {
        if (Hive.isBoxOpen(boxName)) {
          debugPrint('HiveWebFix: Fermeture de la boîte $boxName');
          await Hive.box(boxName).close();
        }
      }

      // Supprimer IndexedDB avec une approche plus sûre
      js.context.callMethod('eval', [
        '''
        (function() {
          return new Promise(function(resolve, reject) {
            var request = indexedDB.deleteDatabase("geosector_app");
            request.onsuccess = function() { 
              console.log("IndexedDB nettoyé avec succès"); 
              resolve(true);
            };
            request.onerror = function(event) { 
              console.log("Erreur lors du nettoyage d'IndexedDB", event); 
              reject(event);
            };
          });
        })();
        '''
      ]);

      // Attendre un peu pour s'assurer que la suppression est terminée
      await Future.delayed(const Duration(milliseconds: 500));

      // Réinitialiser Hive
      await Hive.initFlutter();

      // Réenregistrer les adaptateurs
      // Note: Cette partie devrait être gérée par le code principal de l'application

      debugPrint('HiveWebFix: Réinitialisation complète terminée');
    } catch (e) {
      debugPrint('HiveWebFix: Erreur lors de la réinitialisation complète: $e');
    }
  }
}
