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.
/// Chaque action est loguée pour faciliter la traçabilité et le débogage.
class UserRemoteDataSource {
  final http.Client client;

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

  /// Authentifie un utilisateur avec l'email et le mot de passe en clair.
  /// Si l'authentification réussit, retourne un objet `UserModel`.
  Future<UserModel> authenticateUser(String email, String password) async {
    print("Tentative d'authentification pour l'email : $email");

    try {
      // Requête POST avec l'email et le mot de passe en clair
      final response = await client.post(
        Uri.parse('${Urls.baseUrl}/users/authenticate'),
        headers: {'Content-Type': 'application/json'},
        body: jsonEncode({
          'email': email,
          'motDePasse': password, // Le mot de passe est envoyé en clair pour le moment
        }),
      );

      print("Réponse du serveur pour l'authentification : ${response.statusCode} - ${response.body}");

      if (response.statusCode == 200) {
        // Si l'authentification réussit, retourne l'utilisateur
        return UserModel.fromJson(jsonDecode(response.body));
      } else if (response.statusCode == 401) {
        // Gestion des erreurs d'authentification
        throw UnauthorizedException();
      } else {
        throw ServerException();
      }
    } catch (e) {
      print("Erreur d'authentification : $e");
      throw Exception("Erreur lors de l'authentification : $e");
    }
  }

  /// Récupère un utilisateur par son identifiant et logue les étapes.
  Future<UserModel> getUser(String id) async {
    print("Tentative de récupération de l'utilisateur avec l'ID : $id");

    try {
      final response = await client.get(Uri.parse('${Urls.baseUrl}/users/$id'));
      print("Réponse du serveur pour getUser : ${response.statusCode} - ${response.body}");

      if (response.statusCode == 200) {
        return UserModel.fromJson(json.decode(response.body));
      } else if (response.statusCode == 404) {
        print("Utilisateur non trouvé.");
        throw UserNotFoundException();
      } else {
        throw ServerException();
      }
    } catch (e) {
      print("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 et logue les détails de la requête.
  Future<UserModel> createUser(UserModel user) async {
    print("Création d'un nouvel utilisateur : ${user.toJson()}");

    try {
      final response = await client.post(
        Uri.parse('${Urls.baseUrl}/users'),
        headers: {'Content-Type': 'application/json'},
        body: jsonEncode(user.toJson()),
      );
      print("Réponse du serveur pour createUser : ${response.statusCode} - ${response.body}");

      if (response.statusCode == 201) {
        return UserModel.fromJson(json.decode(response.body));
      } else if (response.statusCode == 409) {
        // Gestion des conflits (utilisateur déjà existant)
        throw ConflictException();
      } else {
        throw ServerException();
      }
    } catch (e) {
      print("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 et logue les étapes.
  Future<UserModel> updateUser(UserModel user) async {
    print("Mise à jour de l'utilisateur : ${user.toJson()}");

    try {
      final response = await client.put(
        Uri.parse('${Urls.baseUrl}/users/${user.userId}'),
        headers: {'Content-Type': 'application/json'},
        body: jsonEncode(user.toJson()),
      );
      print("Réponse du serveur pour updateUser : ${response.statusCode} - ${response.body}");

      if (response.statusCode == 200) {
        return UserModel.fromJson(json.decode(response.body));
      } else if (response.statusCode == 404) {
        // Gestion des cas où l'utilisateur n'est pas trouvé
        throw UserNotFoundException();
      } else {
        throw ServerException();
      }
    } catch (e) {
      print("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 et logue chaque étape.
  Future<void> deleteUser(String id) async {
    print("Tentative de suppression de l'utilisateur avec l'ID : $id");

    try {
      final response = await client.delete(Uri.parse('${Urls.baseUrl}/users/$id'));
      print("Réponse du serveur pour deleteUser : ${response.statusCode} - ${response.body}");

      if (response.statusCode != 204) {
        print("Erreur lors de la suppression de l'utilisateur.");
        throw ServerException();
      } else {
        print("Utilisateur supprimé avec succès.");
      }
    } catch (e) {
      print("Erreur lors de la suppression de l'utilisateur : $e");
      throw Exception("Erreur lors de la suppression de l'utilisateur : $e");
    }
  }
}