EM2_ERP/em2rp/lib/providers/maintenance_provider.dart

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

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

  List<MaintenanceModel> _maintenances = [];
  bool _isLoading = false;

  // Getters
  List<MaintenanceModel> get maintenances => _maintenances;
  bool get isLoading => _isLoading;

  /// Charger toutes les maintenances
  Future<void> loadMaintenances({String? equipmentId}) async {
    _isLoading = true;
    notifyListeners();

    try {
      if (equipmentId != null) {
        _maintenances = await _service.getMaintenancesByEquipment(equipmentId);
      } else {
        _maintenances = await _service.getAllMaintenances();
      }

      _isLoading = false;
      notifyListeners();
    } catch (e) {
      DebugLog.error('[MaintenanceProvider] Error loading maintenances', e);
      _isLoading = false;
      notifyListeners();
      rethrow;
    }
  }

  /// Récupérer les maintenances pour un équipement spécifique
  Future<List<MaintenanceModel>> getMaintenances(String equipmentId) async {
    return await _service.getMaintenancesByEquipment(equipmentId);
  }

  /// Récupérer toutes les maintenances
  Future<List<MaintenanceModel>> getAllMaintenances() async {
    return await _service.getAllMaintenances();
  }

  /// Créer une nouvelle maintenance
  Future<void> createMaintenance(MaintenanceModel maintenance) async {
    try {
      await _service.createMaintenance(maintenance);
      await loadMaintenances(); // Recharger après création
    } catch (e) {
      DebugLog.error('[MaintenanceProvider] 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);
      await loadMaintenances(); // Recharger après mise à jour
    } catch (e) {
      DebugLog.error('[MaintenanceProvider] Error updating maintenance', e);
      rethrow;
    }
  }

  /// Supprimer une maintenance
  Future<void> deleteMaintenance(String id) async {
    try {
      await _service.deleteMaintenance(id);
      await loadMaintenances(); // Recharger après suppression
    } catch (e) {
      DebugLog.error('[MaintenanceProvider] 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) {
      DebugLog.error('[MaintenanceProvider] 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);
      await loadMaintenances(); // Recharger après complétion
    } catch (e) {
      DebugLog.error('[MaintenanceProvider] Error completing maintenance', e);
      rethrow;
    }
  }

  /// Vérifier les maintenances à venir
  Future<void> checkUpcomingMaintenances() async {
    try {
      await _service.checkUpcomingMaintenances();
    } catch (e) {
      DebugLog.error('[MaintenanceProvider] Error checking upcoming maintenances', e);
      rethrow;
    }
  }

  /// Récupérer les maintenances en retard
  List<MaintenanceModel> get overdueMaintenances {
    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();
  }

  /// Obtenir les maintenances pour un équipement spécifique (depuis le cache local)
  List<MaintenanceModel> getForEquipment(String equipmentId) {
    return _maintenances.where((m) =>
      m.equipmentIds.contains(equipmentId)
    ).toList();
  }
}