import 'package:cloud_firestore/cloud_firestore.dart';
import 'package:flutter/material.dart';
import '../models/event_model.dart';

class EventProvider with ChangeNotifier {
  final FirebaseFirestore _firestore = FirebaseFirestore.instance;
  List<EventModel> _events = [];
  bool _isLoading = false;

  List<EventModel> get events => _events;
  bool get isLoading => _isLoading;

  // Récupérer les événements pour un utilisateur spécifique
  Future<void> loadUserEvents(String userId,
      {bool canViewAllEvents = false}) async {
    _isLoading = true;
    notifyListeners();

    try {
      print(
          'Loading events for user: $userId (canViewAllEvents: $canViewAllEvents)');

      QuerySnapshot eventsSnapshot = await _firestore.collection('events').get();
      print('Found ${eventsSnapshot.docs.length} events total');

      List<EventModel> allEvents = [];
      int failedCount = 0;

      // Parser chaque événement individuellement pour éviter qu'une erreur interrompe tout
      for (var doc in eventsSnapshot.docs) {
        try {
          final data = doc.data() as Map<String, dynamic>;
          print('Processing event ${doc.id}: ${data['Name'] ?? 'Unknown'}');

          final event = EventModel.fromMap(data, doc.id);
          allEvents.add(event);
        } catch (e) {
          print('Failed to parse event ${doc.id}: $e');
          failedCount++;
          // Continue avec les autres événements au lieu d'arrêter
        }
      }

      print('Successfully parsed ${allEvents.length} events, failed: $failedCount');

      // Filtrage amélioré pour les utilisateurs non-admin
      if (canViewAllEvents) {
        _events = allEvents;
        print('Admin user: showing all ${_events.length} events');
      } else {
        // Créer la référence utilisateur correctement
        final userDocRef = _firestore.collection('users').doc(userId);

        _events = allEvents.where((event) {
          // Vérifier si l'utilisateur est dans l'équipe de l'événement
          bool isInWorkforce = event.workforce.any((workforceRef) {
            return workforceRef.path == userDocRef.path;
          });

          if (isInWorkforce) {
            print('Event ${event.name} includes user ${userId}');
          }

          return isInWorkforce;
        }).toList();

        print('Non-admin user: showing ${_events.length} events out of ${allEvents.length}');
      }

      _isLoading = false;
      notifyListeners();

    } catch (e) {
      print('Error loading events: $e');
      _isLoading = false;
      _events = []; // S'assurer que la liste est vide en cas d'erreur
      notifyListeners();
      rethrow;
    }
  }

  // Récupérer un événement spécifique
  Future<EventModel?> getEvent(String eventId) async {
    try {
      final doc = await _firestore.collection('events').doc(eventId).get();
      if (doc.exists) {
        return EventModel.fromMap(doc.data()!, doc.id);
      }
      return null;
    } catch (e) {
      print('Error getting event: $e');
      rethrow;
    }
  }

  // Ajouter un nouvel événement
  Future<void> addEvent(EventModel event) async {
    try {
      final docRef = await _firestore.collection('events').add(event.toMap());
      final newEvent = EventModel.fromMap(event.toMap(), docRef.id);
      _events.add(newEvent);
      notifyListeners();
    } catch (e) {
      print('Error adding event: $e');
      rethrow;
    }
  }

  // Mettre à jour un événement
  Future<void> updateEvent(EventModel event) async {
    try {
      await _firestore.collection('events').doc(event.id).update(event.toMap());
      final index = _events.indexWhere((e) => e.id == event.id);
      if (index != -1) {
        _events[index] = event;
        notifyListeners();
      }
    } catch (e) {
      print('Error updating event: $e');
      rethrow;
    }
  }

  // Supprimer un événement
  Future<void> deleteEvent(String eventId) async {
    try {
      await _firestore.collection('events').doc(eventId).delete();
      _events.removeWhere((event) => event.id == eventId);
      notifyListeners();
    } catch (e) {
      print('Error deleting event: $e');
      rethrow;
    }
  }

  // Vider la liste des événements
  void clearEvents() {
    _events = [];
    notifyListeners();
  }
}