EM2_ERP/em2rp/lib/services/event_preparation_service.dart

import 'package:em2rp/services/equipment_status_calculator.dart';
import 'package:em2rp/services/api_service.dart';

class EventPreparationService {
  final ApiService _apiService = apiService;

  /// Retourne true si l'équipement était absent du flux événementiel.
  ///
  /// Cas typique: matériel jamais emporté au départ, donc absent au retour,
  /// mais qui ne doit jamais être classé en [LOST].
  static bool isEquipmentNotTakenToEvent({
    required bool isMissingAtReturn,
    required bool isLoaded,
    required bool isMissingAtLoading,
    int? quantityAtLoading,
  }) {
    if (!isMissingAtReturn) {
      return false;
    }

    final loadedQuantity = quantityAtLoading ?? 0;
    return !isLoaded || isMissingAtLoading || loadedQuantity <= 0;
  }

  /// Retourne true uniquement si l'équipement doit être classé perdu.
  static bool shouldMarkEquipmentAsLost({
    required bool isReturnValidationStep,
    required bool isMissingAtReturn,
    required bool isLoaded,
    required bool isMissingAtLoading,
    int? quantityAtLoading,
  }) {
    if (!isReturnValidationStep || !isMissingAtReturn) {
      return false;
    }

    return !isEquipmentNotTakenToEvent(
      isMissingAtReturn: isMissingAtReturn,
      isLoaded: isLoaded,
      isMissingAtLoading: isMissingAtLoading,
      quantityAtLoading: quantityAtLoading,
    );
  }

  // === PRÉPARATION ===

   /// Valider un équipement individuel en préparation
  Future<void> validateEquipmentPreparation(String eventId, String equipmentId) async {
    try {
      await _apiService.call('validateEquipmentPreparation', {
        'eventId': eventId,
        'equipmentId': equipmentId,
      });
    } catch (e) {
      print('Error validating equipment preparation: $e');
      rethrow;
    }
  }

  /// Valider tous les équipements en préparation
  Future<void> validateAllPreparation(String eventId) async {
    try {
      await _apiService.call('validateAllPreparation', {
        'eventId': eventId,
      });

      // Invalider le cache des statuts d'équipement
      EquipmentStatusCalculator.invalidateGlobalCache();
    } catch (e) {
      print('Error validating all preparation: $e');
      rethrow;
    }
  }

  // Ces méthodes ne sont plus utilisées et devraient être remplacées par des Cloud Functions
  // si nécessaire dans le futur

  /*
  @Deprecated('Use Cloud Functions instead')
  Future<void> completePreparationWithMissing(
    String eventId,
    List<String> missingEquipmentIds,
  ) async {
    throw UnimplementedError('This method is deprecated. Use Cloud Functions instead.');
  }
  */

  // === RETOUR ===


    /// Valider le retour d'un équipement individuel
  Future<void> validateEquipmentReturn(
    String eventId,
    String equipmentId, {
    int? returnedQuantity,
  }) async {
    try {
      await _apiService.call('validateEquipmentReturn', {
        'eventId': eventId,
        'equipmentId': equipmentId,
        if (returnedQuantity != null) 'returnedQuantity': returnedQuantity,
      });
    } catch (e) {
      print('Error validating equipment return: $e');
      rethrow;
    }
  }

  /// Valider tous les retours
  Future<void> validateAllReturn(
    String eventId, [
    Map<String, int>? returnedQuantities,
  ]) async {
    try {
      await _apiService.call('validateAllReturn', {
        'eventId': eventId,
        if (returnedQuantities != null) 'returnedQuantities': returnedQuantities,
      });

      // Invalider le cache des statuts d'équipement
      EquipmentStatusCalculator.invalidateGlobalCache();
    } catch (e) {
      print('Error validating all return: $e');
      rethrow;
    }
  }

  /*
  @Deprecated('Use Cloud Functions instead')
  Future<void> completeReturnWithMissing(
    String eventId,
    List<String> missingEquipmentIds,
  ) async {
    throw UnimplementedError('This method is deprecated. Use Cloud Functions instead.');
  }

  // Les méthodes helper suivantes étaient uniquement utilisées par les méthodes deprecated ci-dessus.
  // Elles ont été supprimées car elles accédaient directement à Firestore.
  // Si ces fonctionnalités sont nécessaires à l'avenir, elles doivent être implémentées
  // via des Cloud Functions pour respecter l'architecture.
  */
}