import 'package:flutter/foundation.dart';
import 'package:em2rp/models/maintenance_model.dart';
import 'package:em2rp/services/maintenance_service.dart';

class MaintenanceProvider extends ChangeNotifier {
  final MaintenanceService _service = MaintenanceService();

  List<MaintenanceModel> _maintenances = [];

  // Getters
  List<MaintenanceModel> get maintenances => _maintenances;

  /// Stream des maintenances pour un équipement spécifique
  Stream<List<MaintenanceModel>> getMaintenancesStream(String equipmentId) {
    return _service.getMaintenances(equipmentId);
  }

  /// Stream de toutes les maintenances
  Stream<List<MaintenanceModel>> get allMaintenancesStream {
    return _service.getAllMaintenances();
  }

  /// Créer une nouvelle maintenance
  Future<void> createMaintenance(MaintenanceModel maintenance) async {
    try {
      await _service.createMaintenance(maintenance);
      notifyListeners();
    } catch (e) {
      print('Error creating maintenance: $e');
      rethrow;
    }
  }

  /// Mettre à jour une maintenance
  Future<void> updateMaintenance(String id, Map<String, dynamic> data) async {
    try {
      await _service.updateMaintenance(id, data);
      notifyListeners();
    } catch (e) {
      print('Error updating maintenance: $e');
      rethrow;
    }
  }

  /// Supprimer une maintenance
  Future<void> deleteMaintenance(String id) async {
    try {
      await _service.deleteMaintenance(id);
      notifyListeners();
    } catch (e) {
      print('Error deleting maintenance: $e');
      rethrow;
    }
  }

  /// Récupérer une maintenance par ID
  Future<MaintenanceModel?> getMaintenanceById(String id) async {
    try {
      return await _service.getMaintenanceById(id);
    } catch (e) {
      print('Error getting maintenance: $e');
      rethrow;
    }
  }

  /// Marquer une maintenance comme complétée
  Future<void> completeMaintenance(
    String id, {
    String? performedBy,
    double? cost,
  }) async {
    try {
      await _service.completeMaintenance(id, performedBy: performedBy, cost: cost);
      notifyListeners();
    } catch (e) {
      print('Error completing maintenance: $e');
      rethrow;
    }
  }

  /// Vérifier les maintenances à venir
  Future<void> checkUpcomingMaintenances() async {
    try {
      await _service.checkUpcomingMaintenances();
    } catch (e) {
      print('Error checking upcoming maintenances: $e');
      rethrow;
    }
  }

  /// Récupérer les maintenances en retard
  List<MaintenanceModel> get overdueMaintances {
    return _maintenances.where((m) => m.isOverdue).toList();
  }

  /// Récupérer les maintenances complétées
  List<MaintenanceModel> get completedMaintenances {
    return _maintenances.where((m) => m.isCompleted).toList();
  }

  /// Récupérer les maintenances à venir
  List<MaintenanceModel> get upcomingMaintenances {
    return _maintenances.where((m) => !m.isCompleted && !m.isOverdue).toList();
  }
}