import 'dart:convert';
import 'package:afterwork/core/constants/urls.dart';
import 'package:afterwork/data/models/event_model.dart';
import 'package:http/http.dart' as http;
import '../../core/errors/exceptions.dart';

/// Source de données pour les événements distants.
class EventRemoteDataSource {
  final http.Client client;

  EventRemoteDataSource(this.client);

  /// Récupérer tous les événements depuis l'API.
  Future<List<EventModel>> getAllEvents() async {
    print('Récupération de tous les événements depuis ${Urls.baseUrl}/events');

    final response = await client.get(Uri.parse('${Urls.baseUrl}/events'));

    print('Statut de la réponse: ${response.statusCode}');

    if (response.statusCode == 200) {
      final List<dynamic> jsonResponse = json.decode(response.body);
      print('Réponse JSON reçue: $jsonResponse');
      return jsonResponse.map((event) => EventModel.fromJson(event)).toList();
    } else {
      print('Erreur lors de la récupération des événements: ${response.body}');
      throw ServerException();
    }
  }

  /// Récupérer les événements créés par un utilisateur spécifique et ses amis.
  /// Cette méthode envoie une requête POST au serveur pour obtenir la liste des événements créés
  /// par l'utilisateur spécifié et ses amis, en utilisant l'identifiant de l'utilisateur.
  ///
  /// [userId] : L'identifiant de l'utilisateur pour lequel récupérer les événements.
  /// Retourne une liste de modèles d'événements [EventModel].
  Future<List<EventModel>> getEventsCreatedByUserAndFriends(String userId) async {
    // Log de début de la méthode pour signaler l'initialisation de la récupération des événements
    print('[LOG] Démarrage de la récupération des événements créés par l\'utilisateur ID: $userId et ses amis.');

    // Construction de l'URL de l'API pour la requête POST
    final url = Uri.parse('${Urls.baseUrl}/events/created-by-user-and-friends');
    print('[LOG] URL construite pour la requête: $url');

    // Création de l'en-tête de la requête, spécifiant que le contenu est en JSON
    final headers = {'Content-Type': 'application/json'};
    print('[LOG] En-têtes de la requête: $headers');

    // Construction du corps de la requête en JSON, incluant l'identifiant de l'utilisateur
    final body = jsonEncode({'userId': userId});
    print('[LOG] Corps de la requête JSON: $body');

    // Envoi de la requête POST au serveur pour récupérer les événements
    final response = await client.post(url, headers: headers, body: body);
    print('[LOG] Requête POST envoyée au serveur.');

    // Vérification et log de l'état de la réponse reçue
    print('[LOG] Statut de la réponse HTTP: ${response.statusCode}');

    // Gestion de la réponse en fonction du code de statut
    if (response.statusCode == 200) {
      // Déchiffrement du JSON reçu si le code de statut est 200 (OK)
      final List<dynamic> jsonResponse = json.decode(response.body);
      print('[LOG] Réponse JSON complète reçue (taille: ${jsonResponse.length}) :');

      // Affichage détaillé de chaque événement
      for (var i = 0; i < jsonResponse.length; i++) {
        final event = jsonResponse[i];
        print('[LOG] Événement $i :');
        print('  - ID: ${event['id']}');
        print('  - Titre: ${event['title']}');
        print('  - Description: ${event['description']}');
        print('  - Date de début: ${event['startDate']}');
        print('  - Date de fin: ${event['endDate']}');
        print('  - Localisation: ${event['location']}');
        print('  - Catégorie: ${event['category']}');
        print('  - Lien: ${event['link']}');
        print('  - URL de l\'image: ${event['imageUrl']}');
        print('  - Statut: ${event['status']}');
      }

      // Transformation du JSON en une liste d'objets EventModel
      List<EventModel> events = jsonResponse.map((event) => EventModel.fromJson(event)).toList();
      print('[LOG] Conversion JSON -> List<EventModel> réussie. Nombre d\'événements: ${events.length}');

      // Retourne la liste d'événements si tout s'est bien passé
      return events;
    } else {
      // Log et gestion de l'erreur en cas de statut HTTP autre que 200
      print('[ERROR] Erreur lors de la récupération des événements: ${response.body}');
      throw ServerException('[ERROR] Échec de récupération des événements créés par l\'utilisateur $userId et ses amis.');
    }
  }


  /// Créer un nouvel événement via l'API.
  Future<EventModel> createEvent(EventModel event) async {
    print('Création d\'un nouvel événement avec les données: ${event.toJson()}');

    final response = await client.post(
      Uri.parse(Urls.createEvent),
      headers: {'Content-Type': 'application/json'},
      body: jsonEncode(event.toJson()),
    );

    print('Statut de la réponse: ${response.statusCode}');

    if (response.statusCode == 201) {
      print('Événement créé avec succès');
      return EventModel.fromJson(json.decode(response.body));
    } else {
      print('Erreur lors de la création de l\'événement: ${response.body}');
      throw ServerException();
    }
  }

  /// Récupérer un événement spécifique par son ID.
  Future<EventModel> getEventById(String id) async {
    print('Récupération de l\'événement avec l\'ID: $id');

    final response = await client.get(Uri.parse('${Urls.getEventById}/$id'));

    print('Statut de la réponse: ${response.statusCode}');

    if (response.statusCode == 200) {
      print('Événement récupéré avec succès');
      return EventModel.fromJson(json.decode(response.body));
    } else {
      print('Erreur lors de la récupération de l\'événement: ${response.body}');
      throw ServerException();
    }
  }

  /// Mettre à jour un événement existant.
  Future<EventModel> updateEvent(String id, EventModel event) async {
    print('Mise à jour de l\'événement avec l\'ID: $id, données: ${event.toJson()}');

    final response = await client.put(
      Uri.parse('${Urls.updateEvent}/$id'),
      headers: {'Content-Type': 'application/json'},
      body: jsonEncode(event.toJson()),
    );

    print('Statut de la réponse: ${response.statusCode}');

    if (response.statusCode == 200) {
      print('Événement mis à jour avec succès');
      return EventModel.fromJson(json.decode(response.body));
    } else {
      print('Erreur lors de la mise à jour de l\'événement: ${response.body}');
      throw ServerException();
    }
  }

  /// Supprimer un événement par son ID.
  Future<void> deleteEvent(String id) async {
    print('Suppression de l\'événement avec l\'ID: $id');

    final response = await client.delete(Uri.parse('${Urls.deleteEvent}/$id'));

    print('Statut de la réponse: ${response.statusCode}');

    if (response.statusCode != 204) {
      print('Erreur lors de la suppression de l\'événement: ${response.body}');
      throw ServerException();
    } else {
      print('Événement supprimé avec succès');
    }
  }

  /// Participer à un événement.
  Future<EventModel> participateInEvent(String eventId, String userId) async {
    print('Participation à l\'événement avec l\'ID: $eventId, utilisateur: $userId');

    final response = await client.post(
      Uri.parse('${Urls.addParticipant}/$eventId/participate'),
      headers: {'Content-Type': 'application/json'},
      body: jsonEncode({'userId': userId}),
    );

    print('Statut de la réponse: ${response.statusCode}');

    if (response.statusCode == 200) {
      print('Participation réussie');
      return EventModel.fromJson(json.decode(response.body));
    } else {
      print('Erreur lors de la participation à l\'événement: ${response.body}');
      throw ServerException();
    }
  }

  /// Réagir à un événement.
  Future<void> reactToEvent(String eventId, String userId) async {
    print('Réaction à l\'événement avec l\'ID: $eventId, utilisateur: $userId');

    final response = await client.post(
      Uri.parse('${Urls.baseUrl}/$eventId/react'),
      headers: {'Content-Type': 'application/json'},
      body: jsonEncode({'userId': userId}),
    );

    print('Statut de la réponse: ${response.statusCode}');

    if (response.statusCode != 200) {
      print('Erreur lors de la réaction à l\'événement: ${response.body}');
      throw ServerException();
    } else {
      print('Réaction réussie');
    }
  }

  /// Fermer un événement.
  Future<void> closeEvent(String eventId) async {
    print('Fermeture de l\'événement avec l\'ID: $eventId');

    final response = await client.post(
      Uri.parse('${Urls.closeEvent}/$eventId/close'),
      headers: {'Content-Type': 'application/json'},
    );

    print('Statut de la réponse: ${response.statusCode}');

    if (response.statusCode == 200) {
      print('Événement fermé avec succès');
    } else if (response.statusCode == 400) {
      // Si le serveur retourne une erreur 400, vérifiez le corps du message
      final responseBody = json.decode(response.body);
      final errorMessage = responseBody['message'] ?? 'Erreur inconnue';
      print('Erreur lors de la fermeture de l\'événement: $errorMessage');
      throw ServerExceptionWithMessage(errorMessage); // Utiliser la nouvelle exception ici
    } else {
      print('Erreur lors de la fermeture de l\'événement: ${response.body}');
      throw ServerExceptionWithMessage('Une erreur est survenue lors de la fermeture de l\'événement.');
    }
  }

  /// Rouvrir un événement.
  Future<void> reopenEvent(String eventId) async {
    print('Réouverture de l\'événement avec l\'ID: $eventId');

    final response = await client.post(
      Uri.parse('${Urls.reopenEvent}/$eventId/reopen'),
      headers: {'Content-Type': 'application/json'},
    );

    print('Statut de la réponse: ${response.statusCode}');

    if (response.statusCode == 200) {
      print('Événement rouvert avec succès');
    } else if (response.statusCode == 400) {
      // Si le serveur retourne une erreur 400, vérifiez le corps du message
      final responseBody = json.decode(response.body);
      final errorMessage = responseBody['message'] ?? 'Erreur inconnue';
      print('Erreur lors de la réouverture de l\'événement: $errorMessage');
      throw ServerExceptionWithMessage(errorMessage);
    } else {
      print('Erreur lors de la réouverture de l\'événement: ${response.body}');
      throw ServerExceptionWithMessage('Une erreur est survenue lors de la réouverture de l\'événement.');
    }
  }

}