EM2_ERP/em2rp/lib/services/container_service.dart

import 'package:cloud_firestore/cloud_firestore.dart';
import 'package:em2rp/models/container_model.dart';
import 'package:em2rp/models/equipment_model.dart';
import 'package:em2rp/services/api_service.dart';

class ContainerService {
  final FirebaseFirestore _firestore = FirebaseFirestore.instance;
  final ApiService _apiService = apiService;

  // Collection references
  CollectionReference get _containersCollection => _firestore.collection('containers');
  CollectionReference get _equipmentCollection => _firestore.collection('equipments');

  // ============================================================================
  // CRUD Operations - Utilise le backend sécurisé
  // ============================================================================

  /// Créer un nouveau container (via Cloud Function)
  Future<void> createContainer(ContainerModel container) async {
    try {
      await _apiService.call('createContainer', container.toMap()..['id'] = container.id);
    } catch (e) {
      print('Error creating container: $e');
      rethrow;
    }
  }

  /// Mettre à jour un container (via Cloud Function)
  Future<void> updateContainer(String id, Map<String, dynamic> data) async {
    try {
      await _apiService.call('updateContainer', {
        'containerId': id,
        'data': data,
      });
    } catch (e) {
      print('Error updating container: $e');
      rethrow;
    }
  }

  /// Supprimer un container (via Cloud Function)
  Future<void> deleteContainer(String id) async {
    try {
      await _apiService.call('deleteContainer', {'containerId': id});
      // Note: La Cloud Function gère maintenant la mise à jour des équipements
    } catch (e) {
      print('Error deleting container: $e');
      rethrow;
    }
  }

  /// Récupérer un container par ID
  Future<ContainerModel?> getContainerById(String id) async {
    try {
      final doc = await _containersCollection.doc(id).get();
      if (doc.exists) {
        return ContainerModel.fromMap(doc.data() as Map<String, dynamic>, doc.id);
      }
      return null;
    } catch (e) {
      print('Error getting container: $e');
      rethrow;
    }
  }

  /// Récupérer tous les containers
  Stream<List<ContainerModel>> getContainers({
    ContainerType? type,
    EquipmentStatus? status,
    String? searchQuery,
  }) {
    try {
      Query query = _containersCollection;

      // Filtre par type
      if (type != null) {
        query = query.where('type', isEqualTo: containerTypeToString(type));
      }

      // Filtre par statut
      if (status != null) {
        query = query.where('status', isEqualTo: equipmentStatusToString(status));
      }

      return query.snapshots().map((snapshot) {
        List<ContainerModel> containerList = snapshot.docs
            .map((doc) => ContainerModel.fromMap(doc.data() as Map<String, dynamic>, doc.id))
            .toList();

        // Filtre par recherche texte (côté client)
        if (searchQuery != null && searchQuery.isNotEmpty) {
          final lowerSearch = searchQuery.toLowerCase();
          containerList = containerList.where((container) {
            return container.name.toLowerCase().contains(lowerSearch) ||
                   container.id.toLowerCase().contains(lowerSearch);
          }).toList();
        }

        return containerList;
      });
    } catch (e) {
      print('Error getting containers: $e');
      rethrow;
    }
  }

  /// Ajouter un équipement à un container
  Future<Map<String, dynamic>> addEquipmentToContainer({
    required String containerId,
    required String equipmentId,
    String? userId,
  }) async {
    try {
      // Récupérer le container
      final container = await getContainerById(containerId);
      if (container == null) {
        return {'success': false, 'message': 'Container non trouvé'};
      }

      // Vérifier si l'équipement n'est pas déjà dans ce container
      if (container.equipmentIds.contains(equipmentId)) {
        return {'success': false, 'message': 'Cet équipement est déjà dans ce container'};
      }

      // Récupérer l'équipement pour vérifier s'il est déjà dans d'autres containers
      final equipmentDoc = await _equipmentCollection.doc(equipmentId).get();
      if (!equipmentDoc.exists) {
        return {'success': false, 'message': 'Équipement non trouvé'};
      }

      final equipment = EquipmentModel.fromMap(
        equipmentDoc.data() as Map<String, dynamic>,
        equipmentDoc.id,
      );

      // Avertir si l'équipement est déjà dans d'autres containers
      List<String> otherContainers = [];
      if (equipment.parentBoxIds.isNotEmpty) {
        for (final boxId in equipment.parentBoxIds) {
          final box = await getContainerById(boxId);
          if (box != null) {
            otherContainers.add(box.name);
          }
        }
      }

      // Mettre à jour le container
      final updatedEquipmentIds = [...container.equipmentIds, equipmentId];
      await updateContainer(containerId, {
        'equipmentIds': updatedEquipmentIds,
      });

      // Mettre à jour l'équipement
      final updatedParentBoxIds = [...equipment.parentBoxIds, containerId];
      await _equipmentCollection.doc(equipmentId).update({
        'parentBoxIds': updatedParentBoxIds,
        'updatedAt': Timestamp.fromDate(DateTime.now()),
      });

      // Ajouter une entrée dans l'historique
      await _addHistoryEntry(
        containerId: containerId,
        action: 'equipment_added',
        equipmentId: equipmentId,
        newValue: equipmentId,
        userId: userId,
      );

      return {
        'success': true,
        'message': 'Équipement ajouté avec succès',
        'warnings': otherContainers.isNotEmpty
            ? 'Attention : cet équipement est également dans les boites suivants : ${otherContainers.join(", ")}'
            : null,
      };
    } catch (e) {
      print('Error adding equipment to container: $e');
      return {'success': false, 'message': 'Erreur: $e'};
    }
  }

  /// Retirer un équipement d'un container
  Future<void> removeEquipmentFromContainer({
    required String containerId,
    required String equipmentId,
    String? userId,
  }) async {
    try {
      // Récupérer le container
      final container = await getContainerById(containerId);
      if (container == null) throw Exception('Container non trouvé');

      // Mettre à jour le container
      final updatedEquipmentIds = container.equipmentIds.where((id) => id != equipmentId).toList();
      await updateContainer(containerId, {
        'equipmentIds': updatedEquipmentIds,
      });

      // Mettre à jour l'équipement
      final equipmentDoc = await _equipmentCollection.doc(equipmentId).get();
      if (equipmentDoc.exists) {
        final equipment = EquipmentModel.fromMap(
          equipmentDoc.data() as Map<String, dynamic>,
          equipmentDoc.id,
        );
        final updatedParentBoxIds = equipment.parentBoxIds.where((id) => id != containerId).toList();
        await _equipmentCollection.doc(equipmentId).update({
          'parentBoxIds': updatedParentBoxIds,
          'updatedAt': Timestamp.fromDate(DateTime.now()),
        });
      }

      // Ajouter une entrée dans l'historique
      await _addHistoryEntry(
        containerId: containerId,
        action: 'equipment_removed',
        equipmentId: equipmentId,
        previousValue: equipmentId,
        userId: userId,
      );
    } catch (e) {
      print('Error removing equipment from container: $e');
      rethrow;
    }
  }

  /// Vérifier la disponibilité d'un container et de son contenu pour un événement
  Future<Map<String, dynamic>> checkContainerAvailability({
    required String containerId,
    required DateTime startDate,
    required DateTime endDate,
    String? excludeEventId,
  }) async {
    try {
      final container = await getContainerById(containerId);
      if (container == null) {
        return {'available': false, 'message': 'Container non trouvé'};
      }

      // Vérifier le statut du container
      if (container.status != EquipmentStatus.available) {
        return {
          'available': false,
          'message': 'Container ${container.name} n\'est pas disponible (statut: ${container.status})',
        };
      }

      // Vérifier la disponibilité de chaque équipement dans le container
      List<String> unavailableEquipment = [];
      for (final equipmentId in container.equipmentIds) {
        final equipmentDoc = await _equipmentCollection.doc(equipmentId).get();
        if (equipmentDoc.exists) {
          final equipment = EquipmentModel.fromMap(
            equipmentDoc.data() as Map<String, dynamic>,
            equipmentDoc.id,
          );

          if (equipment.status != EquipmentStatus.available) {
            unavailableEquipment.add('${equipment.name} (${equipment.status})');
          }
        }
      }

      if (unavailableEquipment.isNotEmpty) {
        return {
          'available': false,
          'message': 'Certains équipements ne sont pas disponibles',
          'unavailableItems': unavailableEquipment,
        };
      }

      return {'available': true, 'message': 'Container et tout son contenu disponibles'};
    } catch (e) {
      print('Error checking container availability: $e');
      return {'available': false, 'message': 'Erreur: $e'};
    }
  }

  /// Récupérer les équipements d'un container
  Future<List<EquipmentModel>> getContainerEquipment(String containerId) async {
    try {
      final container = await getContainerById(containerId);
      if (container == null) return [];

      List<EquipmentModel> equipment = [];
      for (final equipmentId in container.equipmentIds) {
        final doc = await _equipmentCollection.doc(equipmentId).get();
        if (doc.exists) {
          equipment.add(EquipmentModel.fromMap(doc.data() as Map<String, dynamic>, doc.id));
        }
      }

      return equipment;
    } catch (e) {
      print('Error getting container equipment: $e');
      rethrow;
    }
  }

  /// Trouver tous les containers contenant un équipement spécifique
  Future<List<ContainerModel>> findContainersWithEquipment(String equipmentId) async {
    try {
      final snapshot = await _containersCollection
          .where('equipmentIds', arrayContains: equipmentId)
          .get();

      return snapshot.docs
          .map((doc) => ContainerModel.fromMap(doc.data() as Map<String, dynamic>, doc.id))
          .toList();
    } catch (e) {
      print('Error finding containers with equipment: $e');
      rethrow;
    }
  }

  /// Ajouter une entrée d'historique
  Future<void> _addHistoryEntry({
    required String containerId,
    required String action,
    String? equipmentId,
    String? previousValue,
    String? newValue,
    String? userId,
  }) async {
    try {
      final container = await getContainerById(containerId);
      if (container == null) return;

      final entry = ContainerHistoryEntry(
        timestamp: DateTime.now(),
        action: action,
        equipmentId: equipmentId,
        previousValue: previousValue,
        newValue: newValue,
        userId: userId,
      );

      final updatedHistory = [...container.history, entry];

      // Limiter l'historique aux 100 dernières entrées
      final limitedHistory = updatedHistory.length > 100
          ? updatedHistory.sublist(updatedHistory.length - 100)
          : updatedHistory;

      await updateContainer(containerId, {
        'history': limitedHistory.map((e) => e.toMap()).toList(),
      });
    } catch (e) {
      print('Error adding history entry: $e');
      // Ne pas throw pour éviter de bloquer l'opération principale
    }
  }

  /// Vérifier si un ID de container existe déjà
  Future<bool> checkContainerIdExists(String id) async {
    try {
      final doc = await _containersCollection.doc(id).get();
      return doc.exists;
    } catch (e) {
      print('Error checking container ID: $e');
      return false;
    }
  }
}