EM2_ERP/em2rp/lib/providers/equipment_provider.dart

import 'package:flutter/foundation.dart';
import 'package:em2rp/models/equipment_model.dart';
import 'package:em2rp/services/data_service.dart';
import 'package:em2rp/services/api_service.dart';

class EquipmentProvider extends ChangeNotifier {
  final DataService _dataService = DataService(FirebaseFunctionsApiService());

  List<EquipmentModel> _equipment = [];
  List<String> _models = [];
  List<String> _brands = [];

  EquipmentCategory? _selectedCategory;
  EquipmentStatus? _selectedStatus;
  String? _selectedModel;
  String _searchQuery = '';
  bool _isLoading = false;

  // Getters
  List<EquipmentModel> get equipment => _filteredEquipment;
  List<String> get models => _models;
  List<String> get brands => _brands;
  EquipmentCategory? get selectedCategory => _selectedCategory;
  EquipmentStatus? get selectedStatus => _selectedStatus;
  String? get selectedModel => _selectedModel;
  String get searchQuery => _searchQuery;
  bool get isLoading => _isLoading;

  /// Charger tous les équipements via l'API
  Future<void> loadEquipments() async {
    print('[EquipmentProvider] Starting to load equipments...');
    _isLoading = true;
    notifyListeners();

    try {
      print('[EquipmentProvider] Calling getEquipments API...');
      final equipmentsData = await _dataService.getEquipments();
      print('[EquipmentProvider] Received ${equipmentsData.length} equipments from API');

      _equipment = equipmentsData.map((data) {
        return EquipmentModel.fromMap(data, data['id'] as String);
      }).toList();
      print('[EquipmentProvider] Mapped ${_equipment.length} equipment models');

      // Extraire les modèles et marques uniques
      _extractUniqueValues();

      _isLoading = false;
      notifyListeners();
      print('[EquipmentProvider] Equipment loading complete');
    } catch (e) {
      print('[EquipmentProvider] Error loading equipments: $e');
      _isLoading = false;
      notifyListeners();
      rethrow;
    }
  }

  /// Extraire modèles et marques uniques
  void _extractUniqueValues() {
    final modelSet = <String>{};
    final brandSet = <String>{};

    for (final eq in _equipment) {
      if (eq.model != null && eq.model!.isNotEmpty) {
        modelSet.add(eq.model!);
      }
      if (eq.brand != null && eq.brand!.isNotEmpty) {
        brandSet.add(eq.brand!);
      }
    }

    _models = modelSet.toList()..sort();
    _brands = brandSet.toList()..sort();
  }

  /// Obtenir les équipements filtrés
  List<EquipmentModel> get _filteredEquipment {
    var filtered = _equipment;

    if (_selectedCategory != null) {
      filtered = filtered.where((eq) => eq.category == _selectedCategory).toList();
    }

    if (_selectedStatus != null) {
      filtered = filtered.where((eq) => eq.status == _selectedStatus).toList();
    }

    if (_selectedModel != null && _selectedModel!.isNotEmpty) {
      filtered = filtered.where((eq) => eq.model == _selectedModel).toList();
    }

    if (_searchQuery.isNotEmpty) {
      final query = _searchQuery.toLowerCase();
      filtered = filtered.where((eq) {
        return eq.name.toLowerCase().contains(query) ||
               eq.id.toLowerCase().contains(query) ||
               (eq.model?.toLowerCase().contains(query) ?? false) ||
               (eq.brand?.toLowerCase().contains(query) ?? false);
      }).toList();
    }

    return filtered;
  }

  /// Définir le filtre de catégorie
  void setSelectedCategory(EquipmentCategory? category) {
    _selectedCategory = category;
    notifyListeners();
  }

  /// Définir le filtre de statut
  void setSelectedStatus(EquipmentStatus? status) {
    _selectedStatus = status;
    notifyListeners();
  }

  /// Définir le filtre de modèle
  void setSelectedModel(String? model) {
    _selectedModel = model;
    notifyListeners();
  }

  /// Définir la requête de recherche
  void setSearchQuery(String query) {
    _searchQuery = query;
    notifyListeners();
  }

  /// Réinitialiser tous les filtres
  void clearFilters() {
    _selectedCategory = null;
    _selectedStatus = null;
    _selectedModel = null;
    _searchQuery = '';
    notifyListeners();
  }

  /// Recharger les équipements
  Future<void> refresh() async {
    await loadEquipments();
  }

  // === MÉTHODES STREAM (COMPATIBILITÉ) ===

  /// Stream des équipements (pour compatibilité avec ancien code)
  Stream<List<EquipmentModel>> get equipmentStream async* {
    yield _equipment;
  }

  /// Supprimer un équipement
  Future<void> deleteEquipment(String equipmentId) async {
    try {
      await _dataService.deleteEquipment(equipmentId);
      await loadEquipments(); // Recharger la liste
    } catch (e) {
      print('Error deleting equipment: $e');
      rethrow;
    }
  }

  /// Ajouter un équipement
  Future<void> addEquipment(EquipmentModel equipment) async {
    try {
      await _dataService.createEquipment(equipment.id, equipment.toMap());
      await loadEquipments(); // Recharger la liste
    } catch (e) {
      print('Error adding equipment: $e');
      rethrow;
    }
  }

  /// Mettre à jour un équipement
  Future<void> updateEquipment(EquipmentModel equipment) async {
    try {
      await _dataService.updateEquipment(equipment.id, equipment.toMap());
      await loadEquipments(); // Recharger la liste
    } catch (e) {
      print('Error updating equipment: $e');
      rethrow;
    }
  }

  /// Charger les marques
  Future<void> loadBrands() async {
    // Les marques sont déjà chargées avec loadEquipments
    _extractUniqueValues();
  }

  /// Charger les modèles
  Future<void> loadModels() async {
    // Les modèles sont déjà chargés avec loadEquipments
    _extractUniqueValues();
  }

  /// Charger les modèles d'une marque spécifique
  Future<List<String>> loadModelsByBrand(String brand) async {
    // Filtrer les modèles par marque
    final modelsByBrand = _equipment
        .where((eq) => eq.brand == brand && eq.model != null)
        .map((eq) => eq.model!)
        .toSet()
        .toList();
    return modelsByBrand;
  }

  /// Calculer le statut réel d'un équipement (compatibilité)
  Future<EquipmentStatus> calculateRealStatus(EquipmentModel equipment) async {
    // Pour l'instant, retourner le statut stocké
    // TODO: Implémenter le calcul réel si nécessaire
    return equipment.status;
  }
}