import 'package:get_it/get_it.dart';
import 'package:shared_preferences/shared_preferences.dart';
import '../../../core/network/api_client.dart';
import '../../../core/network/network_info.dart';

// Domain
import '../domain/repositories/solidarite_repository.dart';
import '../domain/usecases/gerer_demandes_aide_usecase.dart';
import '../domain/usecases/gerer_propositions_aide_usecase.dart';
import '../domain/usecases/gerer_matching_usecase.dart';
import '../domain/usecases/gerer_evaluations_usecase.dart';
import '../domain/usecases/obtenir_statistiques_usecase.dart';

// Data
import 'datasources/solidarite_remote_data_source.dart';
import 'datasources/solidarite_local_data_source.dart';
import 'repositories/solidarite_repository_impl.dart';

/// Configuration de l'injection de dépendances pour le module solidarité
/// 
/// Cette classe configure tous les services, repositories, use cases
/// et data sources nécessaires au fonctionnement du module solidarité.
class SolidariteInjectionContainer {
  static final GetIt _sl = GetIt.instance;

  /// Initialise toutes les dépendances du module solidarité
  static Future<void> init() async {
    // ============================================================================
    // Features - Solidarité
    // ============================================================================

    // Use Cases - Demandes d'aide
    _sl.registerLazySingleton(() => CreerDemandeAideUseCase(_sl()));
    _sl.registerLazySingleton(() => MettreAJourDemandeAideUseCase(_sl()));
    _sl.registerLazySingleton(() => ObtenirDemandeAideUseCase(_sl()));
    _sl.registerLazySingleton(() => SoumettreDemandeAideUseCase(_sl()));
    _sl.registerLazySingleton(() => EvaluerDemandeAideUseCase(_sl()));
    _sl.registerLazySingleton(() => RechercherDemandesAideUseCase(_sl()));
    _sl.registerLazySingleton(() => ObtenirDemandesUrgentesUseCase(_sl()));
    _sl.registerLazySingleton(() => ObtenirMesDemandesUseCase(_sl()));
    _sl.registerLazySingleton(() => ValiderDemandeAideUseCase());
    _sl.registerLazySingleton(() => CalculerPrioriteDemandeUseCase());

    // Use Cases - Propositions d'aide
    _sl.registerLazySingleton(() => CreerPropositionAideUseCase(_sl()));
    _sl.registerLazySingleton(() => MettreAJourPropositionAideUseCase(_sl()));
    _sl.registerLazySingleton(() => ObtenirPropositionAideUseCase(_sl()));
    _sl.registerLazySingleton(() => ChangerStatutPropositionUseCase(_sl()));
    _sl.registerLazySingleton(() => RechercherPropositionsAideUseCase(_sl()));
    _sl.registerLazySingleton(() => ObtenirPropositionsActivesUseCase(_sl()));
    _sl.registerLazySingleton(() => ObtenirMeilleuresPropositionsUseCase(_sl()));
    _sl.registerLazySingleton(() => ObtenirMesPropositionsUseCase(_sl()));
    _sl.registerLazySingleton(() => ValiderPropositionAideUseCase());
    _sl.registerLazySingleton(() => CalculerScorePropositionUseCase());

    // Use Cases - Matching
    _sl.registerLazySingleton(() => TrouverPropositionsCompatiblesUseCase(_sl()));
    _sl.registerLazySingleton(() => TrouverDemandesCompatiblesUseCase(_sl()));
    _sl.registerLazySingleton(() => RechercherProposantsFinanciersUseCase(_sl()));
    _sl.registerLazySingleton(() => CalculerScoreCompatibiliteUseCase());
    _sl.registerLazySingleton(() => EffectuerMatchingIntelligentUseCase(
      trouverPropositionsCompatibles: _sl(),
      calculerScoreCompatibilite: _sl(),
    ));
    _sl.registerLazySingleton(() => AnalyserTendancesMatchingUseCase());

    // Use Cases - Évaluations
    _sl.registerLazySingleton(() => CreerEvaluationUseCase(_sl()));
    _sl.registerLazySingleton(() => MettreAJourEvaluationUseCase(_sl()));
    _sl.registerLazySingleton(() => ObtenirEvaluationUseCase(_sl()));
    _sl.registerLazySingleton(() => ObtenirEvaluationsDemandeUseCase(_sl()));
    _sl.registerLazySingleton(() => ObtenirEvaluationsPropositionUseCase(_sl()));
    _sl.registerLazySingleton(() => SignalerEvaluationUseCase(_sl()));
    _sl.registerLazySingleton(() => CalculerMoyenneDemandeUseCase(_sl()));
    _sl.registerLazySingleton(() => CalculerMoyennePropositionUseCase(_sl()));
    _sl.registerLazySingleton(() => ValiderEvaluationUseCase());
    _sl.registerLazySingleton(() => CalculerScoreQualiteEvaluationUseCase());
    _sl.registerLazySingleton(() => AnalyserTendancesEvaluationUseCase());

    // Use Cases - Statistiques
    _sl.registerLazySingleton(() => ObtenirStatistiquesSolidariteUseCase(_sl()));
    _sl.registerLazySingleton(() => CalculerKPIsPerformanceUseCase());
    _sl.registerLazySingleton(() => GenererRapportActiviteUseCase());

    // Repository
    _sl.registerLazySingleton<SolidariteRepository>(
      () => SolidariteRepositoryImpl(
        remoteDataSource: _sl(),
        localDataSource: _sl(),
        networkInfo: _sl(),
      ),
    );

    // Data Sources
    _sl.registerLazySingleton<SolidariteRemoteDataSource>(
      () => SolidariteRemoteDataSourceImpl(apiClient: _sl()),
    );

    _sl.registerLazySingleton<SolidariteLocalDataSource>(
      () => SolidariteLocalDataSourceImpl(sharedPreferences: _sl()),
    );

    // ============================================================================
    // Core (si pas déjà enregistrés)
    // ============================================================================
    
    // Ces services sont normalement enregistrés dans le core injection container
    // Nous les enregistrons ici seulement s'ils ne sont pas déjà disponibles
    
    if (!_sl.isRegistered<ApiClient>()) {
      _sl.registerLazySingleton<ApiClient>(() => ApiClientImpl());
    }

    if (!_sl.isRegistered<NetworkInfo>()) {
      _sl.registerLazySingleton<NetworkInfo>(() => NetworkInfoImpl());
    }

    if (!_sl.isRegistered<SharedPreferences>()) {
      final sharedPreferences = await SharedPreferences.getInstance();
      _sl.registerLazySingleton<SharedPreferences>(() => sharedPreferences);
    }
  }

  /// Nettoie toutes les dépendances du module solidarité
  static Future<void> dispose() async {
    // Use Cases - Demandes d'aide
    _sl.unregister<CreerDemandeAideUseCase>();
    _sl.unregister<MettreAJourDemandeAideUseCase>();
    _sl.unregister<ObtenirDemandeAideUseCase>();
    _sl.unregister<SoumettreDemandeAideUseCase>();
    _sl.unregister<EvaluerDemandeAideUseCase>();
    _sl.unregister<RechercherDemandesAideUseCase>();
    _sl.unregister<ObtenirDemandesUrgentesUseCase>();
    _sl.unregister<ObtenirMesDemandesUseCase>();
    _sl.unregister<ValiderDemandeAideUseCase>();
    _sl.unregister<CalculerPrioriteDemandeUseCase>();

    // Use Cases - Propositions d'aide
    _sl.unregister<CreerPropositionAideUseCase>();
    _sl.unregister<MettreAJourPropositionAideUseCase>();
    _sl.unregister<ObtenirPropositionAideUseCase>();
    _sl.unregister<ChangerStatutPropositionUseCase>();
    _sl.unregister<RechercherPropositionsAideUseCase>();
    _sl.unregister<ObtenirPropositionsActivesUseCase>();
    _sl.unregister<ObtenirMeilleuresPropositionsUseCase>();
    _sl.unregister<ObtenirMesPropositionsUseCase>();
    _sl.unregister<ValiderPropositionAideUseCase>();
    _sl.unregister<CalculerScorePropositionUseCase>();

    // Use Cases - Matching
    _sl.unregister<TrouverPropositionsCompatiblesUseCase>();
    _sl.unregister<TrouverDemandesCompatiblesUseCase>();
    _sl.unregister<RechercherProposantsFinanciersUseCase>();
    _sl.unregister<CalculerScoreCompatibiliteUseCase>();
    _sl.unregister<EffectuerMatchingIntelligentUseCase>();
    _sl.unregister<AnalyserTendancesMatchingUseCase>();

    // Use Cases - Évaluations
    _sl.unregister<CreerEvaluationUseCase>();
    _sl.unregister<MettreAJourEvaluationUseCase>();
    _sl.unregister<ObtenirEvaluationUseCase>();
    _sl.unregister<ObtenirEvaluationsDemandeUseCase>();
    _sl.unregister<ObtenirEvaluationsPropositionUseCase>();
    _sl.unregister<SignalerEvaluationUseCase>();
    _sl.unregister<CalculerMoyenneDemandeUseCase>();
    _sl.unregister<CalculerMoyennePropositionUseCase>();
    _sl.unregister<ValiderEvaluationUseCase>();
    _sl.unregister<CalculerScoreQualiteEvaluationUseCase>();
    _sl.unregister<AnalyserTendancesEvaluationUseCase>();

    // Use Cases - Statistiques
    _sl.unregister<ObtenirStatistiquesSolidariteUseCase>();
    _sl.unregister<CalculerKPIsPerformanceUseCase>();
    _sl.unregister<GenererRapportActiviteUseCase>();

    // Repository et Data Sources
    _sl.unregister<SolidariteRepository>();
    _sl.unregister<SolidariteRemoteDataSource>();
    _sl.unregister<SolidariteLocalDataSource>();
  }

  /// Obtient une instance d'un service enregistré
  static T get<T extends Object>() => _sl.get<T>();

  /// Vérifie si un service est enregistré
  static bool isRegistered<T extends Object>() => _sl.isRegistered<T>();

  /// Réinitialise complètement le container
  static Future<void> reset() async {
    await dispose();
    await init();
  }

  /// Obtient des statistiques sur les services enregistrés
  static Map<String, dynamic> getStats() {
    return {
      'totalServices': _sl.allReadySync().length,
      'solidariteServices': {
        'useCases': {
          'demandes': 10,
          'propositions': 10,
          'matching': 6,
          'evaluations': 11,
          'statistiques': 3,
        },
        'repositories': 1,
        'dataSources': 2,
      },
      'isInitialized': _sl.isRegistered<SolidariteRepository>(),
    };
  }

  /// Valide que tous les services critiques sont enregistrés
  static bool validateConfiguration() {
    try {
      // Vérifier les services critiques
      final criticalServices = [
        SolidariteRepository,
        SolidariteRemoteDataSource,
        SolidariteLocalDataSource,
        CreerDemandeAideUseCase,
        CreerPropositionAideUseCase,
        CreerEvaluationUseCase,
        ObtenirStatistiquesSolidariteUseCase,
      ];

      for (final serviceType in criticalServices) {
        if (!_sl.isRegistered(instance: serviceType)) {
          return false;
        }
      }

      return true;
    } catch (e) {
      return false;
    }
  }

  /// Effectue un test de santé des services
  static Future<Map<String, bool>> healthCheck() async {
    final results = <String, bool>{};

    try {
      // Test du repository
      final repository = _sl.get<SolidariteRepository>();
      results['repository'] = repository != null;

      // Test des data sources
      final remoteDataSource = _sl.get<SolidariteRemoteDataSource>();
      results['remoteDataSource'] = remoteDataSource != null;

      final localDataSource = _sl.get<SolidariteLocalDataSource>();
      results['localDataSource'] = localDataSource != null;

      // Test des use cases critiques
      final creerDemandeUseCase = _sl.get<CreerDemandeAideUseCase>();
      results['creerDemandeUseCase'] = creerDemandeUseCase != null;

      final creerPropositionUseCase = _sl.get<CreerPropositionAideUseCase>();
      results['creerPropositionUseCase'] = creerPropositionUseCase != null;

      final creerEvaluationUseCase = _sl.get<CreerEvaluationUseCase>();
      results['creerEvaluationUseCase'] = creerEvaluationUseCase != null;

      // Test des services de base
      results['networkInfo'] = _sl.isRegistered<NetworkInfo>();
      results['apiClient'] = _sl.isRegistered<ApiClient>();
      results['sharedPreferences'] = _sl.isRegistered<SharedPreferences>();

    } catch (e) {
      results['error'] = false;
    }

    return results;
  }
}

/// Extension pour faciliter l'accès aux services depuis les widgets
extension SolidariteServiceLocator on GetIt {
  // Use Cases - Demandes d'aide
  CreerDemandeAideUseCase get creerDemandeAide => get<CreerDemandeAideUseCase>();
  MettreAJourDemandeAideUseCase get mettreAJourDemandeAide => get<MettreAJourDemandeAideUseCase>();
  ObtenirDemandeAideUseCase get obtenirDemandeAide => get<ObtenirDemandeAideUseCase>();
  SoumettreDemandeAideUseCase get soumettreDemandeAide => get<SoumettreDemandeAideUseCase>();
  EvaluerDemandeAideUseCase get evaluerDemandeAide => get<EvaluerDemandeAideUseCase>();
  RechercherDemandesAideUseCase get rechercherDemandesAide => get<RechercherDemandesAideUseCase>();
  ObtenirDemandesUrgentesUseCase get obtenirDemandesUrgentes => get<ObtenirDemandesUrgentesUseCase>();
  ObtenirMesDemandesUseCase get obtenirMesdemandes => get<ObtenirMesDemandesUseCase>();
  ValiderDemandeAideUseCase get validerDemandeAide => get<ValiderDemandeAideUseCase>();
  CalculerPrioriteDemandeUseCase get calculerPrioriteDemande => get<CalculerPrioriteDemandeUseCase>();

  // Use Cases - Propositions d'aide
  CreerPropositionAideUseCase get creerPropositionAide => get<CreerPropositionAideUseCase>();
  MettreAJourPropositionAideUseCase get mettreAJourPropositionAide => get<MettreAJourPropositionAideUseCase>();
  ObtenirPropositionAideUseCase get obtenirPropositionAide => get<ObtenirPropositionAideUseCase>();
  ChangerStatutPropositionUseCase get changerStatutProposition => get<ChangerStatutPropositionUseCase>();
  RechercherPropositionsAideUseCase get rechercherPropositionsAide => get<RechercherPropositionsAideUseCase>();
  ObtenirPropositionsActivesUseCase get obtenirPropositionsActives => get<ObtenirPropositionsActivesUseCase>();
  ObtenirMeilleuresPropositionsUseCase get obtenirMeilleuresPropositions => get<ObtenirMeilleuresPropositionsUseCase>();
  ObtenirMesPropositionsUseCase get obtenirMesPropositions => get<ObtenirMesPropositionsUseCase>();
  ValiderPropositionAideUseCase get validerPropositionAide => get<ValiderPropositionAideUseCase>();
  CalculerScorePropositionUseCase get calculerScoreProposition => get<CalculerScorePropositionUseCase>();

  // Use Cases - Matching
  TrouverPropositionsCompatiblesUseCase get trouverPropositionsCompatibles => get<TrouverPropositionsCompatiblesUseCase>();
  TrouverDemandesCompatiblesUseCase get trouverDemandesCompatibles => get<TrouverDemandesCompatiblesUseCase>();
  RechercherProposantsFinanciersUseCase get rechercherProposantsFinanciers => get<RechercherProposantsFinanciersUseCase>();
  CalculerScoreCompatibiliteUseCase get calculerScoreCompatibilite => get<CalculerScoreCompatibiliteUseCase>();
  EffectuerMatchingIntelligentUseCase get effectuerMatchingIntelligent => get<EffectuerMatchingIntelligentUseCase>();
  AnalyserTendancesMatchingUseCase get analyserTendancesMatching => get<AnalyserTendancesMatchingUseCase>();

  // Use Cases - Évaluations
  CreerEvaluationUseCase get creerEvaluation => get<CreerEvaluationUseCase>();
  MettreAJourEvaluationUseCase get mettreAJourEvaluation => get<MettreAJourEvaluationUseCase>();
  ObtenirEvaluationUseCase get obtenirEvaluation => get<ObtenirEvaluationUseCase>();
  ObtenirEvaluationsDemandeUseCase get obtenirEvaluationsDemande => get<ObtenirEvaluationsDemandeUseCase>();
  ObtenirEvaluationsPropositionUseCase get obtenirEvaluationsProposition => get<ObtenirEvaluationsPropositionUseCase>();
  SignalerEvaluationUseCase get signalerEvaluation => get<SignalerEvaluationUseCase>();
  CalculerMoyenneDemandeUseCase get calculerMoyenneDemande => get<CalculerMoyenneDemandeUseCase>();
  CalculerMoyennePropositionUseCase get calculerMoyenneProposition => get<CalculerMoyennePropositionUseCase>();
  ValiderEvaluationUseCase get validerEvaluation => get<ValiderEvaluationUseCase>();
  CalculerScoreQualiteEvaluationUseCase get calculerScoreQualiteEvaluation => get<CalculerScoreQualiteEvaluationUseCase>();
  AnalyserTendancesEvaluationUseCase get analyserTendancesEvaluation => get<AnalyserTendancesEvaluationUseCase>();

  // Use Cases - Statistiques
  ObtenirStatistiquesSolidariteUseCase get obtenirStatistiquesSolidarite => get<ObtenirStatistiquesSolidariteUseCase>();
  CalculerKPIsPerformanceUseCase get calculerKPIsPerformance => get<CalculerKPIsPerformanceUseCase>();
  GenererRapportActiviteUseCase get genererRapportActivite => get<GenererRapportActiviteUseCase>();

  // Repository
  SolidariteRepository get solidariteRepository => get<SolidariteRepository>();
}