afterwork/lib/data/datasources/user_remote_data_source.dart

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

/// Classe pour gérer les opérations API pour les utilisateurs.
/// Toutes les actions sont loguées pour faciliter la traçabilité et le débogage.
class UserRemoteDataSource {
  // Client HTTP injecté pour réaliser les appels réseau
  final http.Client client;

  /// Constructeur avec injection du client HTTP
  UserRemoteDataSource(this.client);

  /// Authentifie un utilisateur avec l'email et le mot de passe.
  /// Si l'authentification réussit, retourne un objet `UserModel`.
  /// Les erreurs sont gérées et toutes les actions sont loguées.
  Future<UserModel> authenticateUser(String email, String password) async {
    print("[LOG] Tentative d'authentification pour l'email : $email");

    try {
      // Préparation des données d'authentification à envoyer
      final Map<String, dynamic> body = {
        'email': email,
        'motDePasse': password,
      };

      print("[DEBUG] Données envoyées pour authentification : $body");

      // Envoi de la requête HTTP POST pour authentifier l'utilisateur
      final response = await client.post(
        Uri.parse('${Urls.baseUrl}/users/authenticate'),
        headers: {'Content-Type': 'application/json'},
        body: jsonEncode(body),
      );

      // Log de la réponse reçue du serveur
      print("[LOG] Réponse du serveur : ${response.statusCode} - ${response.body}");

      if (response.statusCode == 200) {
        final userData = jsonDecode(response.body);

        if (userData['userId'] != null && userData['userId'].isNotEmpty) {
          print("[LOG] Utilisateur authentifié avec succès. ID: ${userData['userId']}");
          return UserModel.fromJson(userData);
        } else {
          print("[ERROR] L'ID utilisateur est manquant dans la réponse.");
          throw Exception("ID utilisateur manquant.");
        }
      } else if (response.statusCode == 401) {
        print("[ERROR] Authentification échouée : Mot de passe incorrect.");
        throw UnauthorizedException("Mot de passe incorrect.");
      } else {
        print("[ERROR] Erreur du serveur. Code : ${response.statusCode}");
        throw ServerExceptionWithMessage("Erreur inattendue : ${response.body}");
      }
    } catch (e) {
      print("[ERROR] Erreur lors de l'authentification : $e");
      throw Exception("Erreur lors de l'authentification : $e");
    }
  }

  /// Récupère un utilisateur par son identifiant.
  /// Les erreurs et les succès sont logués pour un suivi complet.
  Future<UserModel> getUser(String id) async {
    print("[LOG] Tentative de récupération de l'utilisateur avec l'ID : $id");

    try {
      // Envoi de la requête GET pour obtenir l'utilisateur par son ID
      final response = await client.get(Uri.parse('${Urls.baseUrl}/users/$id'));
      print("[LOG] Réponse du serveur pour getUser : ${response.statusCode} - ${response.body}");

      if (response.statusCode == 200) {
        // Utilisateur trouvé, retour de l'objet UserModel
        return UserModel.fromJson(json.decode(response.body));
      }
      // Gestion du cas où l'utilisateur n'est pas trouvé
      else if (response.statusCode == 404) {
        print("[ERROR] Utilisateur non trouvé.");
        throw UserNotFoundException();
      }
      // Gestion des autres erreurs serveur
      else {
        print("[ERROR] Erreur du serveur lors de la récupération de l'utilisateur.");
        throw ServerException();
      }
    } catch (e) {
      print("[ERROR] Erreur lors de la récupération de l'utilisateur : $e");
      throw Exception("Erreur lors de la récupération de l'utilisateur : $e");
    }
  }

  /// Crée un nouvel utilisateur dans le backend.
  /// Toutes les actions, succès ou erreurs sont logués pour un suivi précis.
  Future<UserModel> createUser(UserModel user) async {
    print("[LOG] Création d'un nouvel utilisateur : ${user.toJson()}");

    try {
      // Envoi de la requête POST pour créer un nouvel utilisateur
      final response = await client.post(
        Uri.parse('${Urls.baseUrl}/users'),
        headers: {'Content-Type': 'application/json'},
        body: jsonEncode(user.toJson()), // Conversion du modèle utilisateur en JSON
      );
      print("[LOG] Réponse du serveur pour createUser : ${response.statusCode} - ${response.body}");

      if (response.statusCode == 201) {
        // Utilisateur créé avec succès
        return UserModel.fromJson(json.decode(response.body));
      }
      // Gestion des conflits (ex: utilisateur déjà existant)
      else if (response.statusCode == 409) {
        print("[ERROR] Conflit lors de la création de l'utilisateur : Utilisateur déjà existant.");
        throw ConflictException();
      }
      // Gestion des autres erreurs serveur
      else {
        print("[ERROR] Erreur du serveur lors de la création de l'utilisateur.");
        throw ServerException();
      }
    } catch (e) {
      print("[ERROR] Erreur lors de la création de l'utilisateur : $e");
      throw Exception("Erreur lors de la création de l'utilisateur : $e");
    }
  }

  /// Met à jour un utilisateur existant.
  /// Chaque étape est loguée pour faciliter le débogage.
  Future<UserModel> updateUser(UserModel user) async {
    print("[LOG] Mise à jour de l'utilisateur : ${user.toJson()}");

    try {
      // Envoi de la requête PUT pour mettre à jour un utilisateur
      final response = await client.put(
        Uri.parse('${Urls.baseUrl}/users/${user.userId}'),
        headers: {'Content-Type': 'application/json'},
        body: jsonEncode(user.toJson()), // Conversion du modèle utilisateur en JSON
      );
      print("[LOG] Réponse du serveur pour updateUser : ${response.statusCode} - ${response.body}");

      if (response.statusCode == 200) {
        // Mise à jour réussie
        return UserModel.fromJson(json.decode(response.body));
      }
      // Gestion du cas où l'utilisateur n'est pas trouvé
      else if (response.statusCode == 404) {
        print("[ERROR] Utilisateur non trouvé.");
        throw UserNotFoundException();
      }
      // Gestion des autres erreurs serveur
      else {
        print("[ERROR] Erreur du serveur lors de la mise à jour de l'utilisateur.");
        throw ServerException();
      }
    } catch (e) {
      print("[ERROR] Erreur lors de la mise à jour de l'utilisateur : $e");
      throw Exception("Erreur lors de la mise à jour de l'utilisateur : $e");
    }
  }

  /// Supprime un utilisateur par son identifiant.
  /// Les erreurs et succès sont logués pour garantir un suivi complet.
  Future<void> deleteUser(String id) async {
    print("[LOG] Tentative de suppression de l'utilisateur avec l'ID : $id");

    try {
      // Envoi de la requête DELETE pour supprimer un utilisateur
      final response = await client.delete(Uri.parse('${Urls.baseUrl}/users/$id'));
      print("[LOG] Réponse du serveur pour deleteUser : ${response.statusCode} - ${response.body}");

      // Vérification du succès de la suppression
      if (response.statusCode == 204) {
        print("[LOG] Utilisateur supprimé avec succès.");
      }
      // Gestion des autres erreurs serveur
      else {
        print("[ERROR] Erreur du serveur lors de la suppression de l'utilisateur.");
        throw ServerException();
      }
    } catch (e) {
      print("[ERROR] Erreur lors de la suppression de l'utilisateur : $e");
      throw Exception("Erreur lors de la suppression de l'utilisateur : $e");
    }
  }
}