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;
      // On charge tous les events pour les users non-admins aussi
      eventsSnapshot = await _firestore.collection('events').get();

      print('Found ${eventsSnapshot.docs.length} events for user');

      // On filtre côté client si l'utilisateur n'est pas admin
      final allEvents = eventsSnapshot.docs.map((doc) {
        print('Event data: ${doc.data()}');
        return EventModel.fromMap(doc.data() as Map<String, dynamic>, doc.id);
      }).toList();
      if (canViewAllEvents) {
        _events = allEvents;
      } else {
        final userRef = _firestore.collection('users').doc(userId);
        _events = allEvents
            .where((e) => e.workforce.any((ref) => ref.id == userRef.id))
            .toList();
      }

      print('Parsed ${_events.length} events');

      _isLoading = false;
      notifyListeners();
    } catch (e) {
      print('Error loading events: $e');
      _isLoading = false;
      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();
  }
}