import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:flutter/foundation.dart' show kIsWeb;
import 'package:flutter_web_plugins/url_strategy.dart';
import 'package:geosector_app/core/services/app_info_service.dart';
import 'package:geosector_app/app.dart';
import 'package:hive_flutter/hive_flutter.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/core/data/models/region_model.dart';
import 'package:geosector_app/core/constants/app_keys.dart';
import 'package:geosector_app/core/services/hive_reset_state_service.dart';
import 'package:geosector_app/chat/models/chat_adapters.dart';

void main() async {
  // IMPORTANT: Configurer l'URL strategy pour éviter les # dans les URLs
  usePathUrlStrategy();

  WidgetsFlutterBinding.ensureInitialized();

  // Initialiser les services essentiels
  await _initializeServices();

  // Initialiser Hive avec gestion des erreurs
  final hiveInitialized = await _initializeHive();

  // TEMPORAIREMENT: Ne pas marquer l'erreur pour éviter la redirection
  // if (!hiveInitialized) {
  //   debugPrint('Incompatibilité détectée dans les données Hive. Marquage pour affichage du dialogue...');
  //   hiveResetStateService.markAsReset();
  // }

  // Configurer l'orientation de l'application (mobile uniquement)
  if (!kIsWeb) {
    await SystemChrome.setPreferredOrientations([
      DeviceOrientation.portraitUp,
      DeviceOrientation.portraitDown,
    ]);
  }

  // Lancer l'application
  runApp(const GeosectorApp());
}

/// Initialise les services essentiels
Future<void> _initializeServices() async {
  try {
    await AppInfoService.initialize();
    debugPrint('Services initialisés avec succès');
  } catch (e) {
    debugPrint('Erreur lors de l\'initialisation des services: $e');
  }
}

/// Initialise Hive et les adaptateurs
Future<bool> _initializeHive() async {
  try {
    // Initialiser Hive
    await Hive.initFlutter();

    // Enregistrer les adaptateurs Hive pour les modèles principaux
    _registerHiveAdapters();

    // Ouvrir uniquement les boîtes essentielles au démarrage
    await _openEssentialHiveBoxes();

    debugPrint('Hive initialisé avec succès');
    return true;
  } catch (e) {
    debugPrint('Erreur lors de l\'initialisation de Hive: $e');
    return false;
  }
}

/// Enregistre tous les adaptateurs Hive
void _registerHiveAdapters() {
  // Vérifier si les adaptateurs sont déjà enregistrés pour éviter les doublons
  if (!Hive.isAdapterRegistered(0)) {
    Hive.registerAdapter(UserModelAdapter());
  }
  if (!Hive.isAdapterRegistered(1)) {
    Hive.registerAdapter(AmicaleModelAdapter());
  }
  if (!Hive.isAdapterRegistered(2)) {
    Hive.registerAdapter(ClientModelAdapter());
  }
  if (!Hive.isAdapterRegistered(3)) {
    Hive.registerAdapter(OperationModelAdapter());
  }
  if (!Hive.isAdapterRegistered(4)) {
    Hive.registerAdapter(SectorModelAdapter());
  }
  if (!Hive.isAdapterRegistered(5)) {
    Hive.registerAdapter(PassageModelAdapter());
  }
  if (!Hive.isAdapterRegistered(6)) {
    Hive.registerAdapter(MembreModelAdapter());
  }
  if (!Hive.isAdapterRegistered(7)) {
    Hive.registerAdapter(UserSectorModelAdapter());
  }
  if (!Hive.isAdapterRegistered(8)) {
    Hive.registerAdapter(RegionModelAdapter());
  }

  // Modèles de chat
  if (!Hive.isAdapterRegistered(9)) {
    Hive.registerAdapter(ConversationModelAdapter());
  }
  if (!Hive.isAdapterRegistered(10)) {
    Hive.registerAdapter(MessageModelAdapter());
  }
  if (!Hive.isAdapterRegistered(11)) {
    Hive.registerAdapter(ParticipantModelAdapter());
  }
  if (!Hive.isAdapterRegistered(12)) {
    Hive.registerAdapter(AnonymousUserModelAdapter());
  }
  if (!Hive.isAdapterRegistered(13)) {
    Hive.registerAdapter(AudienceTargetModelAdapter());
  }
  if (!Hive.isAdapterRegistered(14)) {
    Hive.registerAdapter(NotificationSettingsAdapter());
  }
}

/// Ouvre les boîtes Hive essentielles
Future<void> _openEssentialHiveBoxes() async {
  final boxesToOpen = [
    {'name': AppKeys.usersBoxName, 'type': 'UserModel'},
    {'name': AppKeys.amicaleBoxName, 'type': 'AmicaleModel'},
    {'name': AppKeys.clientsBoxName, 'type': 'ClientModel'},
    {'name': AppKeys.settingsBoxName, 'type': 'dynamic'},
    {'name': AppKeys.chatConversationsBoxName, 'type': 'ConversationModel'},
    {'name': AppKeys.chatMessagesBoxName, 'type': 'MessageModel'},
  ];

  for (final box in boxesToOpen) {
    try {
      final boxName = box['name'] as String;
      final boxType = box['type'] as String;

      // Vérifier si la boîte est déjà ouverte
      if (Hive.isBoxOpen(boxName)) {
        debugPrint('Boîte $boxName déjà ouverte');
        continue;
      }

      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 'ConversationModel':
          await Hive.openBox<ConversationModel>(boxName);
          break;
        case 'MessageModel':
          await Hive.openBox<MessageModel>(boxName);
          break;
        default:
          await Hive.openBox(boxName);
      }

      debugPrint('Boîte $boxName ouverte avec succès');
    } catch (e) {
      debugPrint('Erreur lors de l\'ouverture de la boîte ${box['name']}: $e');
      // Ne pas lancer d'erreur, continuer avec les autres boîtes
    }
  }
}