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

/// Service pour calculer dynamiquement le statut réel d'un équipement
/// basé sur les événements en cours
class EquipmentStatusCalculator {
  final ApiService _apiService = apiService;

  /// Cache des statuts pour éviter de multiples requêtes
  Map<String, EquipmentStatus>? _cachedStatuses;
  DateTime? _cacheTime;
  static const _cacheDuration = Duration(minutes: 1);

  /// Instance statique pour permettre l'invalidation depuis n'importe où
  static final EquipmentStatusCalculator _instance = EquipmentStatusCalculator._internal();

  factory EquipmentStatusCalculator() {
    return _instance;
  }

  EquipmentStatusCalculator._internal();

  /// Calcule le statut réel d'un équipement basé sur les événements
  Future<EquipmentStatus> calculateRealStatus(EquipmentModel equipment) async {
    print('[StatusCalculator] Calculating status for: ${equipment.id}');

    try {
      final statuses = await calculateMultipleStatuses([equipment]);
      return statuses[equipment.id] ?? equipment.status;
    } catch (e) {
      print('[StatusCalculator] Error calculating status: $e');
      return equipment.status;
    }
  }

  /// Calcule les statuts pour une liste d'équipements (optimisé)
  Future<Map<String, EquipmentStatus>> calculateMultipleStatuses(
    List<EquipmentModel> equipments,
  ) async {
    try {
      final equipmentIds = equipments.map((e) => e.id).toList();

      final response = await _apiService.call('calculateEquipmentStatuses', {
        'equipmentIds': equipmentIds,
      });

      final statusesMap = response['statuses'] as Map<String, dynamic>?;
      if (statusesMap == null) {
        throw Exception('Invalid response from calculateEquipmentStatuses');
      }

      final statuses = <String, EquipmentStatus>{};
      statusesMap.forEach((equipmentId, statusString) {
        if (statusString != null) {
          statuses[equipmentId] = equipmentStatusFromString(statusString as String);
        }
      });

      // Mise en cache
      _cachedStatuses = statuses;
      _cacheTime = DateTime.now();

      return statuses;
    } catch (e) {
      print('[StatusCalculator] Error calculating multiple statuses: $e');
      // En cas d'erreur, retourner les statuts actuels
      final fallbackStatuses = <String, EquipmentStatus>{};
      for (var equipment in equipments) {
        fallbackStatuses[equipment.id] = equipment.status;
      }
      return fallbackStatuses;
    }
  }

  /// Invalide le cache (à appeler après une modification d'événement)
  void invalidateCache() {
    _cachedStatuses = null;
    _cacheTime = null;
  }

  /// Invalide le cache de l'instance globale (méthode statique)
  static void invalidateGlobalCache() {
    _instance.invalidateCache();
  }
}