/// BLoC pour la gestion des paramètres système (Clean Architecture)
library system_settings_bloc;

import 'package:dio/dio.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:injectable/injectable.dart';
import '../../domain/usecases/get_settings.dart';
import '../../domain/usecases/update_settings.dart';
import '../../domain/usecases/get_cache_stats.dart';
import '../../domain/usecases/clear_cache.dart' as uc;
import '../../domain/usecases/reset_settings.dart';
import '../../domain/repositories/system_config_repository.dart';
import 'system_settings_event.dart';
import 'system_settings_state.dart';

@injectable
class SystemSettingsBloc extends Bloc<SystemSettingsEvent, SystemSettingsState> {
  final GetSettings _getSettings;
  final UpdateSettings _updateSettings;
  final GetCacheStats _getCacheStats;
  final uc.ClearCache _clearCache;
  final ResetSettings _resetSettings;
  final ISystemConfigRepository _repository; // Pour méthodes non-couvertes (metrics, test DB, test email)

  SystemSettingsBloc(
    this._getSettings,
    this._updateSettings,
    this._getCacheStats,
    this._clearCache,
    this._resetSettings,
    this._repository,
  ) : super(SystemSettingsInitial()) {
    on<LoadSystemConfig>(_onLoadSystemConfig);
    on<UpdateSystemConfig>(_onUpdateSystemConfig);
    on<LoadCacheStats>(_onLoadCacheStats);
    on<LoadSystemMetrics>(_onLoadSystemMetrics);
    on<ClearCache>(_onClearCache);
    on<TestDatabaseConnection>(_onTestDatabaseConnection);
    on<TestEmailConfiguration>(_onTestEmailConfiguration);
    on<ResetSystemConfig>(_onResetSystemConfig);
  }

  Future<void> _onLoadSystemConfig(
    LoadSystemConfig event,
    Emitter<SystemSettingsState> emit,
  ) async {
    emit(SystemSettingsLoading());
    try {
      final config = await _getSettings(); // ✅ Use case
      emit(SystemConfigLoaded(config));
    } catch (e) {
      if (e is DioException && e.type == DioExceptionType.cancel) return;
      emit(SystemSettingsError('Erreur de chargement: ${e.toString()}'));
    }
  }

  Future<void> _onUpdateSystemConfig(
    UpdateSystemConfig event,
    Emitter<SystemSettingsState> emit,
  ) async {
    emit(SystemSettingsLoading());
    try {
      final config = await _updateSettings(event.config); // ✅ Use case
      emit(SystemConfigLoaded(config));
      emit(const SystemSettingsSuccess('Configuration mise à jour'));
    } catch (e) {
      if (e is DioException && e.type == DioExceptionType.cancel) return;
      emit(SystemSettingsError('Erreur de mise à jour: ${e.toString()}'));
    }
  }

  Future<void> _onLoadCacheStats(
    LoadCacheStats event,
    Emitter<SystemSettingsState> emit,
  ) async {
    emit(SystemSettingsLoading());
    try {
      final stats = await _getCacheStats(); // ✅ Use case
      emit(CacheStatsLoaded(stats));
    } catch (e) {
      if (e is DioException && e.type == DioExceptionType.cancel) return;
      emit(SystemSettingsError('Erreur de chargement: ${e.toString()}'));
    }
  }

  Future<void> _onLoadSystemMetrics(
    LoadSystemMetrics event,
    Emitter<SystemSettingsState> emit,
  ) async {
    emit(SystemSettingsLoading());
    try {
      final metrics = await _repository.getMetrics();
      emit(SystemMetricsLoaded(metrics));
    } catch (e) {
      emit(SystemSettingsError('Erreur de chargement des métriques: ${e.toString()}'));
    }
  }

  Future<void> _onClearCache(
    ClearCache event,
    Emitter<SystemSettingsState> emit,
  ) async {
    emit(SystemSettingsLoading());
    try {
      await _clearCache(); // ✅ Use case
      emit(const SystemSettingsSuccess('Cache vidé avec succès'));
    } catch (e) {
      if (e is DioException && e.type == DioExceptionType.cancel) return;
      emit(SystemSettingsError('Erreur: ${e.toString()}'));
    }
  }

  Future<void> _onTestDatabaseConnection(
    TestDatabaseConnection event,
    Emitter<SystemSettingsState> emit,
  ) async {
    emit(SystemSettingsLoading());
    try {
      final result = await _repository.testDatabase();
      final success = result['success'] as bool? ?? false;
      final message = result['message'] as String? ?? 'Test terminé';
      if (success) {
        emit(SystemSettingsSuccess(message));
      } else {
        emit(SystemSettingsError(message));
      }
    } catch (e) {
      if (e is DioException && e.type == DioExceptionType.cancel) return;
      emit(SystemSettingsError('Erreur de test: ${e.toString()}'));
    }
  }

  Future<void> _onTestEmailConfiguration(
    TestEmailConfiguration event,
    Emitter<SystemSettingsState> emit,
  ) async {
    emit(SystemSettingsLoading());
    try {
      final result = await _repository.testEmail();
      final success = result['success'] as bool? ?? false;
      final message = result['message'] as String? ?? 'Test terminé';
      if (success) {
        emit(SystemSettingsSuccess(message));
      } else {
        emit(SystemSettingsError(message));
      }
    } catch (e) {
      if (e is DioException && e.type == DioExceptionType.cancel) return;
      emit(SystemSettingsError('Erreur de test: ${e.toString()}'));
    }
  }

  /// Réinitialise la configuration système aux valeurs par défaut
  Future<void> _onResetSystemConfig(
    ResetSystemConfig event,
    Emitter<SystemSettingsState> emit,
  ) async {
    emit(SystemSettingsLoading());
    try {
      final config = await _resetSettings(); // ✅ Use case
      emit(SystemConfigLoaded(config));
      emit(const SystemSettingsSuccess('Configuration réinitialisée'));
    } catch (e) {
      if (e is DioException && e.type == DioExceptionType.cancel) return;
      emit(SystemSettingsError('Erreur de réinitialisation: ${e.toString()}'));
    }
  }
}