import 'package:dartz/dartz.dart';
import '../../../../core/error/failures.dart';
import '../../../../core/usecases/usecase.dart';
import '../entities/notification.dart';
import '../entities/preferences_notification.dart';
import '../repositories/notifications_repository.dart';

/// Use case pour obtenir les préférences de notification
class ObtenirPreferencesUseCase implements UseCase<PreferencesNotificationEntity, String> {
  final NotificationsRepository repository;

  ObtenirPreferencesUseCase(this.repository);

  @override
  Future<Either<Failure, PreferencesNotificationEntity>> call(String utilisateurId) async {
    return await repository.obtenirPreferences(utilisateurId);
  }
}

/// Use case pour mettre à jour les préférences de notification
class MettreAJourPreferencesUseCase implements UseCase<void, PreferencesNotificationEntity> {
  final NotificationsRepository repository;

  MettreAJourPreferencesUseCase(this.repository);

  @override
  Future<Either<Failure, void>> call(PreferencesNotificationEntity preferences) async {
    return await repository.mettreAJourPreferences(preferences);
  }
}

/// Use case pour réinitialiser les préférences
class ReinitialiserPreferencesUseCase implements UseCase<PreferencesNotificationEntity, String> {
  final NotificationsRepository repository;

  ReinitialiserPreferencesUseCase(this.repository);

  @override
  Future<Either<Failure, PreferencesNotificationEntity>> call(String utilisateurId) async {
    return await repository.reinitialiserPreferences(utilisateurId);
  }
}

/// Use case pour activer/désactiver un type de notification
class ToggleTypeNotificationUseCase implements UseCase<void, ToggleTypeNotificationParams> {
  final NotificationsRepository repository;

  ToggleTypeNotificationUseCase(this.repository);

  @override
  Future<Either<Failure, void>> call(ToggleTypeNotificationParams params) async {
    return await repository.toggleTypeNotification(
      params.utilisateurId,
      params.type,
      params.active,
    );
  }
}

/// Paramètres pour activer/désactiver un type de notification
class ToggleTypeNotificationParams {
  final String utilisateurId;
  final TypeNotification type;
  final bool active;

  const ToggleTypeNotificationParams({
    required this.utilisateurId,
    required this.type,
    required this.active,
  });

  @override
  String toString() {
    return 'ToggleTypeNotificationParams{utilisateurId: $utilisateurId, type: $type, active: $active}';
  }
}

/// Use case pour activer/désactiver un canal de notification
class ToggleCanalNotificationUseCase implements UseCase<void, ToggleCanalNotificationParams> {
  final NotificationsRepository repository;

  ToggleCanalNotificationUseCase(this.repository);

  @override
  Future<Either<Failure, void>> call(ToggleCanalNotificationParams params) async {
    return await repository.toggleCanalNotification(
      params.utilisateurId,
      params.canal,
      params.active,
    );
  }
}

/// Paramètres pour activer/désactiver un canal de notification
class ToggleCanalNotificationParams {
  final String utilisateurId;
  final CanalNotification canal;
  final bool active;

  const ToggleCanalNotificationParams({
    required this.utilisateurId,
    required this.canal,
    required this.active,
  });

  @override
  String toString() {
    return 'ToggleCanalNotificationParams{utilisateurId: $utilisateurId, canal: $canal, active: $active}';
  }
}

/// Use case pour configurer le mode silencieux
class ConfigurerModeSilencieuxUseCase implements UseCase<void, ConfigurerModeSilencieuxParams> {
  final NotificationsRepository repository;

  ConfigurerModeSilencieuxUseCase(this.repository);

  @override
  Future<Either<Failure, void>> call(ConfigurerModeSilencieuxParams params) async {
    return await repository.configurerModeSilencieux(
      params.utilisateurId,
      params.active,
      heureDebut: params.heureDebut,
      heureFin: params.heureFin,
      jours: params.jours,
    );
  }
}

/// Paramètres pour configurer le mode silencieux
class ConfigurerModeSilencieuxParams {
  final String utilisateurId;
  final bool active;
  final String? heureDebut;
  final String? heureFin;
  final Set<int>? jours;

  const ConfigurerModeSilencieuxParams({
    required this.utilisateurId,
    required this.active,
    this.heureDebut,
    this.heureFin,
    this.jours,
  });

  ConfigurerModeSilencieuxParams copyWith({
    String? utilisateurId,
    bool? active,
    String? heureDebut,
    String? heureFin,
    Set<int>? jours,
  }) {
    return ConfigurerModeSilencieuxParams(
      utilisateurId: utilisateurId ?? this.utilisateurId,
      active: active ?? this.active,
      heureDebut: heureDebut ?? this.heureDebut,
      heureFin: heureFin ?? this.heureFin,
      jours: jours ?? this.jours,
    );
  }

  @override
  String toString() {
    return 'ConfigurerModeSilencieuxParams{utilisateurId: $utilisateurId, active: $active, heureDebut: $heureDebut, heureFin: $heureFin, jours: $jours}';
  }
}

/// Use case pour enregistrer le token FCM
class EnregistrerTokenFCMUseCase implements UseCase<void, EnregistrerTokenFCMParams> {
  final NotificationsRepository repository;

  EnregistrerTokenFCMUseCase(this.repository);

  @override
  Future<Either<Failure, void>> call(EnregistrerTokenFCMParams params) async {
    return await repository.enregistrerTokenFCM(
      params.utilisateurId,
      params.token,
      params.plateforme,
    );
  }
}

/// Paramètres pour enregistrer le token FCM
class EnregistrerTokenFCMParams {
  final String utilisateurId;
  final String token;
  final String plateforme;

  const EnregistrerTokenFCMParams({
    required this.utilisateurId,
    required this.token,
    required this.plateforme,
  });

  @override
  String toString() {
    return 'EnregistrerTokenFCMParams{utilisateurId: $utilisateurId, token: $token, plateforme: $plateforme}';
  }
}

/// Use case pour supprimer le token FCM
class SupprimerTokenFCMUseCase implements UseCase<void, String> {
  final NotificationsRepository repository;

  SupprimerTokenFCMUseCase(this.repository);

  @override
  Future<Either<Failure, void>> call(String utilisateurId) async {
    return await repository.supprimerTokenFCM(utilisateurId);
  }
}

/// Use case pour s'abonner à un topic
class AbonnerAuTopicUseCase implements UseCase<void, AbonnerAuTopicParams> {
  final NotificationsRepository repository;

  AbonnerAuTopicUseCase(this.repository);

  @override
  Future<Either<Failure, void>> call(AbonnerAuTopicParams params) async {
    return await repository.abonnerAuTopic(
      params.utilisateurId,
      params.topic,
    );
  }
}

/// Paramètres pour s'abonner à un topic
class AbonnerAuTopicParams {
  final String utilisateurId;
  final String topic;

  const AbonnerAuTopicParams({
    required this.utilisateurId,
    required this.topic,
  });

  @override
  String toString() {
    return 'AbonnerAuTopicParams{utilisateurId: $utilisateurId, topic: $topic}';
  }
}

/// Use case pour se désabonner d'un topic
class DesabonnerDuTopicUseCase implements UseCase<void, DesabonnerDuTopicParams> {
  final NotificationsRepository repository;

  DesabonnerDuTopicUseCase(this.repository);

  @override
  Future<Either<Failure, void>> call(DesabonnerDuTopicParams params) async {
    return await repository.desabonnerDuTopic(
      params.utilisateurId,
      params.topic,
    );
  }
}

/// Paramètres pour se désabonner d'un topic
class DesabonnerDuTopicParams {
  final String utilisateurId;
  final String topic;

  const DesabonnerDuTopicParams({
    required this.utilisateurId,
    required this.topic,
  });

  @override
  String toString() {
    return 'DesabonnerDuTopicParams{utilisateurId: $utilisateurId, topic: $topic}';
  }
}

/// Use case pour obtenir les topics auxquels l'utilisateur est abonné
class ObtenirTopicsAbornesUseCase implements UseCase<List<String>, String> {
  final NotificationsRepository repository;

  ObtenirTopicsAbornesUseCase(this.repository);

  @override
  Future<Either<Failure, List<String>>> call(String utilisateurId) async {
    return await repository.obtenirTopicsAbornes(utilisateurId);
  }
}

/// Use case pour configurer les préférences avancées
class ConfigurerPreferencesAvanceesUseCase implements UseCase<void, ConfigurerPreferencesAvanceesParams> {
  final NotificationsRepository repository;

  ConfigurerPreferencesAvanceesUseCase(this.repository);

  @override
  Future<Either<Failure, void>> call(ConfigurerPreferencesAvanceesParams params) async {
    // Récupération des préférences actuelles
    final preferencesResult = await repository.obtenirPreferences(params.utilisateurId);
    
    return preferencesResult.fold(
      (failure) => Left(failure),
      (preferences) async {
        // Mise à jour des préférences avec les nouveaux paramètres
        final preferencesModifiees = preferences.copyWith(
          vibrationActivee: params.vibrationActivee ?? preferences.vibrationActivee,
          sonActive: params.sonActive ?? preferences.sonActive,
          ledActivee: params.ledActivee ?? preferences.ledActivee,
          sonPersonnalise: params.sonPersonnalise ?? preferences.sonPersonnalise,
          patternVibrationPersonnalise: params.patternVibrationPersonnalise ?? preferences.patternVibrationPersonnalise,
          couleurLEDPersonnalisee: params.couleurLEDPersonnalisee ?? preferences.couleurLEDPersonnalisee,
          apercuEcranVerrouillage: params.apercuEcranVerrouillage ?? preferences.apercuEcranVerrouillage,
          dureeAffichageSecondes: params.dureeAffichageSecondes ?? preferences.dureeAffichageSecondes,
          frequenceRegroupementMinutes: params.frequenceRegroupementMinutes ?? preferences.frequenceRegroupementMinutes,
          maxNotificationsSimultanees: params.maxNotificationsSimultanees ?? preferences.maxNotificationsSimultanees,
          marquageLectureAutomatique: params.marquageLectureAutomatique ?? preferences.marquageLectureAutomatique,
          delaiMarquageLectureSecondes: params.delaiMarquageLectureSecondes ?? preferences.delaiMarquageLectureSecondes,
          archivageAutomatique: params.archivageAutomatique ?? preferences.archivageAutomatique,
          delaiArchivageHeures: params.delaiArchivageHeures ?? preferences.delaiArchivageHeures,
          dureeConservationJours: params.dureeConservationJours ?? preferences.dureeConservationJours,
        );
        
        return await repository.mettreAJourPreferences(preferencesModifiees);
      },
    );
  }
}

/// Paramètres pour configurer les préférences avancées
class ConfigurerPreferencesAvanceesParams {
  final String utilisateurId;
  final bool? vibrationActivee;
  final bool? sonActive;
  final bool? ledActivee;
  final String? sonPersonnalise;
  final List<int>? patternVibrationPersonnalise;
  final String? couleurLEDPersonnalisee;
  final bool? apercuEcranVerrouillage;
  final int? dureeAffichageSecondes;
  final int? frequenceRegroupementMinutes;
  final int? maxNotificationsSimultanees;
  final bool? marquageLectureAutomatique;
  final int? delaiMarquageLectureSecondes;
  final bool? archivageAutomatique;
  final int? delaiArchivageHeures;
  final int? dureeConservationJours;

  const ConfigurerPreferencesAvanceesParams({
    required this.utilisateurId,
    this.vibrationActivee,
    this.sonActive,
    this.ledActivee,
    this.sonPersonnalise,
    this.patternVibrationPersonnalise,
    this.couleurLEDPersonnalisee,
    this.apercuEcranVerrouillage,
    this.dureeAffichageSecondes,
    this.frequenceRegroupementMinutes,
    this.maxNotificationsSimultanees,
    this.marquageLectureAutomatique,
    this.delaiMarquageLectureSecondes,
    this.archivageAutomatique,
    this.delaiArchivageHeures,
    this.dureeConservationJours,
  });

  @override
  String toString() {
    return 'ConfigurerPreferencesAvanceesParams{utilisateurId: $utilisateurId, vibrationActivee: $vibrationActivee, sonActive: $sonActive, ledActivee: $ledActivee, ...}';
  }
}