EM2_ERP/em2rp/lib/providers/users_provider.dart

import 'package:flutter/material.dart';
import '../models/user_model.dart';
import '../services/user_service.dart';
import 'package:cloud_firestore/cloud_firestore.dart';
import 'package:firebase_auth/firebase_auth.dart';
import 'package:provider/provider.dart';
import 'package:em2rp/providers/local_user_provider.dart';

class UsersProvider with ChangeNotifier {
  final UserService _userService;
  final FirebaseFirestore _firestore = FirebaseFirestore.instance;
  final FirebaseAuth _auth = FirebaseAuth.instance;
  List<UserModel> _users = [];
  bool _isLoading = false;

  List<UserModel> get users => _users;
  bool get isLoading => _isLoading;

  UsersProvider(this._userService);

  /// Récupération de tous les utilisateurs
  Future<void> fetchUsers() async {
    _isLoading = true;
    notifyListeners();

    try {
      final snapshot = await _firestore.collection('users').get();
      _users = snapshot.docs
          .map((doc) => UserModel.fromMap(doc.data(), doc.id))
          .toList();
    } catch (e) {
      print('Error fetching users: $e');
    }

    _isLoading = false;
    notifyListeners();
  }

  /// Mise à jour d'un utilisateur
  Future<void> updateUser(UserModel user, {String? roleId}) async {
    try {
      await _firestore.collection('users').doc(user.uid).update({
        'firstName': user.firstName,
        'lastName': user.lastName,
        'email': user.email,
        'phoneNumber': user.phoneNumber,
        'role': roleId != null
            ? _firestore.collection('roles').doc(roleId)
            : user.role,
        'profilePhotoUrl': user.profilePhotoUrl,
      });

      final index = _users.indexWhere((u) => u.uid == user.uid);
      if (index != -1) {
        _users[index] = user;
        notifyListeners();
      }
    } catch (e) {
      print('Error updating user: $e');
      rethrow;
    }
  }

  /// Suppression d'un utilisateur
  Future<void> deleteUser(String uid) async {
    try {
      await _firestore.collection('users').doc(uid).delete();
      _users.removeWhere((user) => user.uid == uid);
      notifyListeners();
    } catch (e) {
      print('Error deleting user: $e');
      rethrow;
    }
  }

  /// Réinitialisation du mot de passe
  Future<void> resetPassword(String email) async {
    await _userService.resetPassword(email);
  }

  Future<void> createUserWithEmailInvite(BuildContext context, UserModel user,
      {String? roleId}) async {
    String? authUid;

    try {
      // Vérifier l'état de l'authentification
      final currentUser = _auth.currentUser;
      print('Current user: ${currentUser?.email}');

      if (currentUser == null) {
        throw Exception('Aucun utilisateur connecté');
      }

      // Vérifier la permission via le provider
      final localUserProvider =
          Provider.of<LocalUserProvider>(context, listen: false);
      if (!localUserProvider.hasPermission('add_user')) {
        throw Exception(
            'Vous n\'avez pas la permission de créer des utilisateurs');
      }

      try {
        // Créer l'utilisateur dans Firebase Authentication
        final userCredential = await _auth.createUserWithEmailAndPassword(
          email: user.email,
          password: 'TemporaryPassword123!', // Mot de passe temporaire
        );

        authUid = userCredential.user!.uid;
        print('User created in Auth with UID: $authUid');

        // Créer le document dans Firestore avec l'UID de Auth comme ID
        await _firestore.collection('users').doc(authUid).set({
          'uid': authUid,
          'firstName': user.firstName,
          'lastName': user.lastName,
          'email': user.email,
          'phoneNumber': user.phoneNumber,
          'role': roleId != null
              ? _firestore.collection('roles').doc(roleId)
              : user.role,
          'profilePhotoUrl': user.profilePhotoUrl,
          'createdAt': FieldValue.serverTimestamp(),
        });

        print('User document created in Firestore with Auth UID');

        // Envoyer un email de réinitialisation de mot de passe
        await _auth.sendPasswordResetEmail(
          email: user.email,
          actionCodeSettings: ActionCodeSettings(
            url: 'http://app.em2events.fr/finishSignUp?email=${user.email}',
            handleCodeInApp: true,
            androidPackageName: 'com.em2rp.app',
            androidInstallApp: true,
            androidMinimumVersion: '12',
          ),
        );

        print('Password reset email sent');

        // Ajouter l'utilisateur à la liste locale
        final newUser = UserModel(
          uid: authUid,
          firstName: user.firstName,
          lastName: user.lastName,
          email: user.email,
          phoneNumber: user.phoneNumber,
          role: roleId ?? user.role,
          profilePhotoUrl: user.profilePhotoUrl,
        );
        _users.add(newUser);
        notifyListeners();
      } catch (e) {
        // En cas d'erreur, supprimer l'utilisateur Auth si créé
        if (authUid != null) {
          try {
            await _auth.currentUser?.delete();
          } catch (deleteError) {
            print('Warning: Could not delete Auth user: $deleteError');
          }
        }
        rethrow;
      }
    } catch (e) {
      print('Error creating user: $e');
      rethrow;
    }
  }
}