import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import 'package:cloud_functions/cloud_functions.dart';
import 'package:cloud_firestore/cloud_firestore.dart';
import 'package:em2rp/models/event_model.dart';
import 'package:em2rp/models/equipment_model.dart';
import 'package:em2rp/models/container_model.dart';
import 'package:em2rp/providers/equipment_provider.dart';
import 'package:em2rp/providers/container_provider.dart';
import 'package:em2rp/providers/event_provider.dart';
import 'package:em2rp/providers/local_user_provider.dart';
import 'package:em2rp/services/data_service.dart';
import 'package:em2rp/services/api_service.dart';
import 'package:em2rp/services/qr_code_processing_service.dart';
import 'package:em2rp/services/audio_feedback_service.dart';
import 'package:em2rp/services/equipment_service.dart';
import 'package:em2rp/views/widgets/equipment/equipment_checklist_item.dart' show EquipmentChecklistItem, ChecklistStep;
import 'package:em2rp/views/widgets/equipment/container_checklist_item.dart';
import 'package:em2rp/views/widgets/common/qr_code_scanner_dialog.dart';
import 'package:em2rp/views/widgets/event_preparation/code_not_found_dialog.dart';
import 'package:em2rp/views/widgets/event_preparation/add_equipment_to_event_dialog.dart';
import 'package:em2rp/utils/debug_log.dart';
import 'package:em2rp/views/widgets/equipment/missing_equipment_dialog.dart';
import 'package:em2rp/utils/colors.dart';

/// Type d'étape de préparation
enum PreparationStep {
  preparation,    // Préparation dépôt
  loadingOutbound, // Chargement aller
  unloadingReturn, // Chargement retour (déchargement)
  return_,        // Retour dépôt
}

/// Page de préparation ou de retour d'un événement
class EventPreparationPage extends StatefulWidget {
  final EventModel initialEvent;

  const EventPreparationPage({
    super.key,
    required this.initialEvent,
  });

  @override
  State<EventPreparationPage> createState() => _EventPreparationPageState();
}

class _EventPreparationPageState extends State<EventPreparationPage> with SingleTickerProviderStateMixin {
  late AnimationController _animationController;
  late final DataService _dataService;
  late final QRCodeProcessingService _qrCodeService;

  Map<String, EquipmentModel> _equipmentCache = {};
  Map<String, ContainerModel> _containerCache = {};
  Map<String, int> _returnedQuantities = {};

  // État local des validations (non sauvegardé jusqu'à la validation finale)
  Map<String, bool> _localValidationState = {};

  // Gestion des quantités par étape
  Map<String, int> _quantitiesAtPreparation = {};
  Map<String, int> _quantitiesAtLoading = {};
  Map<String, int> _quantitiesAtUnloading = {};
  Map<String, int> _quantitiesAtReturn = {};

  bool _isLoading = true;
  bool _isValidating = false;
  bool _showSuccessAnimation = false;
  bool _loadSimultaneously = false; // Checkbox "charger en même temps"

  // Stockage de l'événement actuel
  late EventModel _currentEvent;

  // 🆕 Pour la saisie manuelle de codes
  final TextEditingController _manualCodeController = TextEditingController();
  final FocusNode _manualCodeFocusNode = FocusNode();

  // Détermine l'étape actuelle selon le statut de l'événement
  PreparationStep get _currentStep {
    final prep = _currentEvent.preparationStatus ?? PreparationStatus.notStarted;
    final loading = _currentEvent.loadingStatus ?? LoadingStatus.notStarted;
    final unloading = _currentEvent.unloadingStatus ?? UnloadingStatus.notStarted;
    final returnStatus = _currentEvent.returnStatus ?? ReturnStatus.notStarted;

    // Logique stricte : on avance étape par étape
    // 1. Préparation dépôt
    if (prep != PreparationStatus.completed) {
      return PreparationStep.preparation;
    }

    // 2. Chargement aller (après préparation complète)
    if (loading != LoadingStatus.completed) {
      return PreparationStep.loadingOutbound;
    }

    // 3. Chargement retour (après chargement aller complet)
    if (unloading != UnloadingStatus.completed) {
      return PreparationStep.unloadingReturn;
    }

    // 4. Retour dépôt (après déchargement complet)
    if (returnStatus != ReturnStatus.completed) {
      return PreparationStep.return_;
    }

    // Tout est terminé, par défaut on retourne à la préparation
    return PreparationStep.preparation;
  }

  @override
  void initState() {
    super.initState();
    _currentEvent = widget.initialEvent;
    _dataService = DataService(FirebaseFunctionsApiService());
    _qrCodeService = QRCodeProcessingService();
    _animationController = AnimationController(
      vsync: this,
      duration: const Duration(milliseconds: 500),
    );

    // Vérification de sécurité et chargement après le premier frame
    WidgetsBinding.instance.addPostFrameCallback((_) {
      if (_isCurrentStepCompleted()) {
        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(
            content: Text('Cette étape est déjà terminée'),
            backgroundColor: Colors.orange,
          ),
        );
        Navigator.of(context).pop();
        return;
      }

      // Charger les équipements après le premier frame pour éviter setState pendant build
      _loadEquipmentAndContainers();
    });
  }

  /// Vérifie si l'étape actuelle est déjà complétée
  bool _isCurrentStepCompleted() {
    switch (_currentStep) {
      case PreparationStep.preparation:
        return (_currentEvent.preparationStatus ?? PreparationStatus.notStarted) == PreparationStatus.completed;
      case PreparationStep.loadingOutbound:
        return (_currentEvent.loadingStatus ?? LoadingStatus.notStarted) == LoadingStatus.completed;
      case PreparationStep.unloadingReturn:
        return (_currentEvent.unloadingStatus ?? UnloadingStatus.notStarted) == UnloadingStatus.completed;
      case PreparationStep.return_:
        return (_currentEvent.returnStatus ?? ReturnStatus.notStarted) == ReturnStatus.completed;
    }
  }

  @override
  void dispose() {
    _animationController.dispose();
    _manualCodeController.dispose();
    _manualCodeFocusNode.dispose();
    super.dispose();
  }

  Future<void> _loadEquipmentAndContainers() async {
    setState(() => _isLoading = true);

    try {
      // 🔧 FIX: Utiliser getEventWithDetails pour charger toutes les données d'un coup
      DebugLog.info('[EventPreparationPage] Loading event with details: ${_currentEvent.id}');

      final result = await _dataService.getEventWithDetails(_currentEvent.id);
      final equipmentsMap = result['equipments'] as Map<String, dynamic>;
      final containersMap = result['containers'] as Map<String, dynamic>;

      DebugLog.info('[EventPreparationPage] Loaded ${equipmentsMap.length} equipments and ${containersMap.length} containers with details');

      // Remplir les caches
      _equipmentCache.clear();
      _containerCache.clear();

      // Remplir le cache d'équipements
      equipmentsMap.forEach((id, data) {
        try {
          final equipment = EquipmentModel.fromMap(data as Map<String, dynamic>, id);
          _equipmentCache[id] = equipment;
        } catch (e) {
          DebugLog.error('[EventPreparationPage] Error parsing equipment $id', e);
        }
      });

      // Remplir le cache de containers
      containersMap.forEach((id, data) {
        try {
          final container = ContainerModel.fromMap(data as Map<String, dynamic>, id);
          _containerCache[id] = container;
        } catch (e) {
          DebugLog.error('[EventPreparationPage] Error parsing container $id', e);
        }
      });

      // Initialiser les états de validation et quantités pour chaque équipement assigné
      for (var eq in _currentEvent.assignedEquipment) {
        final equipmentItem = _equipmentCache[eq.equipmentId];

        // S'assurer que l'équipement est dans le cache (même si inconnu)
        if (equipmentItem == null) {
          _equipmentCache[eq.equipmentId] = EquipmentModel(
            id: eq.equipmentId,
            name: 'Équipement inconnu',
            category: EquipmentCategory.other,
            status: EquipmentStatus.available,
            maintenanceIds: [],
            createdAt: DateTime.now(),
            updatedAt: DateTime.now(),
          );
        }

        // Initialiser l'état local de validation depuis l'événement
        switch (_currentStep) {
          case PreparationStep.preparation:
            _localValidationState[eq.equipmentId] = eq.isPrepared;
            break;
          case PreparationStep.loadingOutbound:
            _localValidationState[eq.equipmentId] = eq.isLoaded;
            break;
          case PreparationStep.unloadingReturn:
            _localValidationState[eq.equipmentId] = eq.isUnloaded;
            break;
          case PreparationStep.return_:
            _localValidationState[eq.equipmentId] = eq.isReturned;
            break;
        }

        if ((_currentStep == PreparationStep.return_ ||
             _currentStep == PreparationStep.unloadingReturn) &&
            (equipmentItem?.hasQuantity ?? false)) {
          _returnedQuantities[eq.equipmentId] = eq.quantityAtReturn ?? eq.quantity;
        }
      }

      // S'assurer que les containers assignés sont dans le cache (même si inconnus)
      for (var containerId in _currentEvent.assignedContainers) {
        if (!_containerCache.containsKey(containerId)) {
          _containerCache[containerId] = ContainerModel(
            id: containerId,
            name: 'Conteneur inconnu',
            type: ContainerType.flightCase,
            status: EquipmentStatus.available,
            equipmentIds: [],
            updatedAt: DateTime.now(),
            createdAt: DateTime.now(),
          );
        }
      }
    } catch (e) {
      DebugLog.error('[EventPreparationPage] Error', e);
    } finally {
      setState(() => _isLoading = false);
    }
  }

  /// Basculer l'état de validation d'un équipement (état local uniquement)
  Future<void> _toggleEquipmentValidation(String equipmentId) async {
    final currentState = _localValidationState[equipmentId] ?? false;

    // Si on veut valider (passer de false à true) et que c'était manquant avant
    if (!currentState && _wasMissingAtPreviousStep(equipmentId)) {
      final confirmed = await _confirmValidationIfWasMissingBefore(equipmentId);
      if (!confirmed) {
        return; // Annulation, ne rien faire
      }
    }

    setState(() {
      _localValidationState[equipmentId] = !currentState;
    });
  }

  /// Marquer TOUT comme validé et enregistrer (bouton "Tout confirmer")
  Future<void> _validateAllAndConfirm() async {
    // Marquer tout comme validé localement
    setState(() {
      for (var eq in _currentEvent.assignedEquipment) {
        _localValidationState[eq.equipmentId] = true;
      }
    });

    // Puis enregistrer
    await _confirmCurrentState();
  }

  /// Enregistrer l'état actuel TEL QUEL (cochés = validés, non cochés = manquants)
  Future<void> _confirmCurrentState() async {
    setState(() => _isValidating = true);

    try {
      // Déterminer les manquants = équipements NON validés
      final Map<String, bool> missingAtThisStep = {};
      for (var eq in _currentEvent.assignedEquipment) {
        final isValidated = _localValidationState[eq.equipmentId] ?? false;
        missingAtThisStep[eq.equipmentId] = !isValidated; // Manquant si pas validé
      }

      // Préparer la liste des équipements avec leur nouvel état
      final updatedEquipment = _currentEvent.assignedEquipment.map((eq) {
        final isValidated = _localValidationState[eq.equipmentId] ?? false;
        final isMissing = missingAtThisStep[eq.equipmentId] ?? false;

        // Récupérer les quantités selon l'étape
        final qtyAtPrep = _quantitiesAtPreparation[eq.equipmentId];
        final qtyAtLoad = _quantitiesAtLoading[eq.equipmentId];
        final qtyAtUnload = _quantitiesAtUnloading[eq.equipmentId];
        final qtyAtRet = _quantitiesAtReturn[eq.equipmentId];

        switch (_currentStep) {
          case PreparationStep.preparation:
            if (_loadSimultaneously) {
              return eq.copyWith(
                isPrepared: isValidated,
                isLoaded: isValidated,
                isMissingAtPreparation: isMissing,
                isMissingAtLoading: isMissing, // Propager
                quantityAtPreparation: qtyAtPrep,
                quantityAtLoading: qtyAtPrep, // Même quantité
              );
            }
            return eq.copyWith(
              isPrepared: isValidated,
              isMissingAtPreparation: isMissing,
              quantityAtPreparation: qtyAtPrep,
            );

          case PreparationStep.loadingOutbound:
            return eq.copyWith(
              isLoaded: isValidated,
              isMissingAtLoading: isMissing,
              quantityAtLoading: qtyAtLoad,
            );

          case PreparationStep.unloadingReturn:
            if (_loadSimultaneously) {
              return eq.copyWith(
                isUnloaded: isValidated,
                isReturned: isValidated,
                isMissingAtUnloading: isMissing,
                isMissingAtReturn: isMissing, // Propager
                quantityAtUnloading: qtyAtUnload,
                quantityAtReturn: qtyAtRet ?? qtyAtUnload,
              );
            }
            return eq.copyWith(
              isUnloaded: isValidated,
              isMissingAtUnloading: isMissing,
              quantityAtUnloading: qtyAtUnload,
            );

          case PreparationStep.return_:
            return eq.copyWith(
              isReturned: isValidated,
              isMissingAtReturn: isMissing,
              quantityAtReturn: qtyAtRet,
            );
        }
      }).toList();

      // Mettre à jour Firestore selon l'étape
      final updateData = <String, dynamic>{
        'assignedEquipment': updatedEquipment.map((e) => e.toMap()).toList(),
      };

      // Ajouter les statuts selon l'étape et la checkbox
      String validationType = 'CHECK';
      switch (_currentStep) {
        case PreparationStep.preparation:
          updateData['preparationStatus'] = preparationStatusToString(PreparationStatus.completed);
          validationType = 'CHECK_OUT';
          if (_loadSimultaneously) {
            updateData['loadingStatus'] = loadingStatusToString(LoadingStatus.completed);
            validationType = 'LOADING';
          }
          break;

        case PreparationStep.loadingOutbound:
          updateData['loadingStatus'] = loadingStatusToString(LoadingStatus.completed);
          validationType = 'LOADING';
          break;

        case PreparationStep.unloadingReturn:
          updateData['unloadingStatus'] = unloadingStatusToString(UnloadingStatus.completed);
          validationType = 'UNLOADING';
          if (_loadSimultaneously) {
            updateData['returnStatus'] = returnStatusToString(ReturnStatus.completed);
            validationType = 'CHECK_IN';
          }
          break;

        case PreparationStep.return_:
          updateData['returnStatus'] = returnStatusToString(ReturnStatus.completed);
          validationType = 'CHECK_IN';
          break;
      }

      // Sauvegarder dans Firestore via l'API
      await _dataService.updateEventEquipment(
        eventId: _currentEvent.id,
        assignedEquipment: updatedEquipment.map((e) => e.toMap()).toList(),
        preparationStatus: updateData['preparationStatus'],
        loadingStatus: updateData['loadingStatus'],
        unloadingStatus: updateData['unloadingStatus'],
        returnStatus: updateData['returnStatus'],
      );

      // Mettre à jour les statuts des équipements si nécessaire
      if (_currentStep == PreparationStep.preparation ||
          (_currentStep == PreparationStep.unloadingReturn && _loadSimultaneously)) {
        await _updateEquipmentStatuses(updatedEquipment);
      }

      // NOUVEAU: Appeler la Cloud Function pour traiter la validation
      // et créer les alertes automatiquement
      try {
        DebugLog.info('[EventPreparationPage] Appel processEquipmentValidation');

        final equipmentList = updatedEquipment.map((eq) {
          final equipment = _equipmentCache[eq.equipmentId];
          return {
            'equipmentId': eq.equipmentId,
            'name': equipment?.name ?? 'Équipement inconnu',
            'status': _determineEquipmentStatus(eq),
            'quantity': _getQuantityForStep(eq),
            'expectedQuantity': eq.quantity,
            'isMissingAtPreparation': eq.isMissingAtPreparation,
            'isMissingAtReturn': eq.isMissingAtReturn,
          };
        }).toList();

        final result = await FirebaseFunctions.instanceFor(region: 'us-central1')
            .httpsCallable('processEquipmentValidation')
            .call({
          'eventId': _currentEvent.id,
          'equipmentList': equipmentList,
          'validationType': validationType,
        });

        final alertsCreated = result.data['alertsCreated'] ?? 0;
        if (alertsCreated > 0) {
          DebugLog.info('[EventPreparationPage] $alertsCreated alertes créées automatiquement');
        }
      } catch (e) {
        DebugLog.error('[EventPreparationPage] Erreur appel processEquipmentValidation', e);
        // Ne pas bloquer la validation si les alertes échouent
      }

      // Recharger l'événement depuis le provider
      final eventProvider = context.read<EventProvider>();
      // Recharger la liste des événements pour rafraîchir les données
      final userId = context.read<LocalUserProvider>().uid;
      if (userId != null) {
        await eventProvider.loadUserEvents(userId, canViewAllEvents: true);
      }

      setState(() => _showSuccessAnimation = true);
      _animationController.forward();

      await Future.delayed(const Duration(milliseconds: 500));

      if (mounted) {
        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(
            content: Text(_getSuccessMessage()),
            backgroundColor: Colors.green,
          ),
        );

        await Future.delayed(const Duration(seconds: 2));
        Navigator.of(context).pop(true);
      }
    } catch (e) {
      if (mounted) {
        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(
            content: Text('Erreur : $e'),
            backgroundColor: Colors.red,
          ),
        );
      }
    } finally {
      if (mounted) setState(() => _isValidating = false);
    }
  }

  Future<void> _updateEquipmentStatuses(List<EventEquipment> equipment) async {
    for (var eq in equipment) {
      try {
        final equipmentData = _equipmentCache[eq.equipmentId];
        if (equipmentData == null) continue;

        // Déterminer le nouveau statut
        EquipmentStatus newStatus;
        if (eq.isReturned) {
          newStatus = EquipmentStatus.available;
        } else if (eq.isPrepared || eq.isLoaded) {
          newStatus = EquipmentStatus.inUse;
        } else {
          continue; // Pas de changement
        }

        // Ne mettre à jour que les équipements non quantifiables
        if (!equipmentData.hasQuantity) {
          await _dataService.updateEquipmentStatusOnly(
            equipmentId: eq.equipmentId,
            status: equipmentStatusToString(newStatus),
          );
        }

        // Gérer les stocks pour les consommables
        if (equipmentData.hasQuantity && eq.isReturned && eq.quantityAtReturn != null) {
          final currentAvailable = equipmentData.availableQuantity ?? 0;
          await _dataService.updateEquipmentStatusOnly(
            equipmentId: eq.equipmentId,
            availableQuantity: currentAvailable + eq.quantityAtReturn!,
          );
        }
      } catch (e) {
        // Erreur silencieuse pour ne pas bloquer le processus
      }
    }
  }

  String _getSuccessMessage() {
    switch (_currentStep) {
      case PreparationStep.preparation:
        return _loadSimultaneously
            ? 'Préparation dépôt et chargement aller validés !'
            : 'Préparation dépôt validée !';
      case PreparationStep.loadingOutbound:
        return 'Chargement aller validé !';
      case PreparationStep.unloadingReturn:
        return _loadSimultaneously
            ? 'Chargement retour et retour dépôt validés !'
            : 'Chargement retour validé !';
      case PreparationStep.return_:
        return 'Retour dépôt validé !';
    }
  }

  String _getStepTitle() {
    switch (_currentStep) {
      case PreparationStep.preparation:
        return 'Préparation dépôt';
      case PreparationStep.loadingOutbound:
        return 'Chargement aller';
      case PreparationStep.unloadingReturn:
        return 'Chargement retour';
      case PreparationStep.return_:
        return 'Retour dépôt';
    }
  }

  String _getValidateAllButtonText() {
    if (_loadSimultaneously) {
      return _currentStep == PreparationStep.preparation
          ? 'Tout confirmer comme préparé et chargé'
          : 'Tout confirmer comme déchargé et retourné';
    }

    switch (_currentStep) {
      case PreparationStep.preparation:
        return 'Tout confirmer comme préparé';
      case PreparationStep.loadingOutbound:
        return 'Tout confirmer comme chargé';
      case PreparationStep.unloadingReturn:
        return 'Tout confirmer comme déchargé';
      case PreparationStep.return_:
        return 'Tout confirmer comme retourné';
    }
  }

  bool _isStepCompleted() {
    return _currentEvent.assignedEquipment.every((eq) {
      return _localValidationState[eq.equipmentId] ?? false;
    });
  }

  double _getProgress() {
    if (_currentEvent.assignedEquipment.isEmpty) return 0;
    return _getValidatedCount() / _currentEvent.assignedEquipment.length;
  }

  int _getValidatedCount() {
    return _currentEvent.assignedEquipment.where((eq) {
      return _localValidationState[eq.equipmentId] ?? false;
    }).length;
  }

  ChecklistStep _getChecklistStep() {
    switch (_currentStep) {
      case PreparationStep.preparation:
        return ChecklistStep.preparation;
      case PreparationStep.loadingOutbound:
        return ChecklistStep.loading;
      case PreparationStep.unloadingReturn:
        return ChecklistStep.unloading;
      case PreparationStep.return_:
        return ChecklistStep.return_;
    }
  }

  // ========================================================================
  // 🆕 NOUVELLES MÉTHODES POUR LE SCAN QR ET LA SAISIE MANUELLE
  // ========================================================================

  /// Ouvrir le scanner QR en mode multi-scan
  Future<void> _openQRScanner() async {
    await showDialog(
      context: context,
      builder: (context) => QRCodeScannerDialog(
        multiScanMode: true,
        onCodeScanned: _handleScannedCode,
      ),
    );
  }

  /// Traiter un code (scanné ou saisi manuellement)
  Future<void> _handleScannedCode(String code) async {
    final result = await _qrCodeService.processCode(
      code: code.trim(),
      event: _currentEvent,
      step: _currentStep,
      equipmentCache: _equipmentCache,
      containerCache: _containerCache,
      validationState: _localValidationState,
      currentQuantities: _getCurrentQuantitiesMap(),
    );

    if (result.success) {
      // ✅ Succès : mettre à jour l'état
      setState(() {
        if (result.updatedValidationState != null) {
          _localValidationState.addAll(result.updatedValidationState!);
        }
        if (result.updatedQuantities != null) {
          _updateQuantitiesMap(result.updatedQuantities!);
        }
      });

      // 🔊 Jouer le feedback sonore et haptique
      await AudioFeedbackService.playFullFeedback(isSuccess: true);

      // Feedback visuel
      _showSuccessFeedback(result.message ?? 'Code traité avec succès');

    } else if (result.codeNotFoundInEvent) {
      // 🔍 Code non trouvé dans l'événement → proposer de l'ajouter
      await _handleCodeNotFoundInEvent(code.trim());

    } else {
      // ❌ Erreur (ex: quantité déjà atteinte, déjà coché)
      await AudioFeedbackService.playFullFeedback(isSuccess: false);
      _showErrorFeedback(result.message ?? 'Erreur lors du traitement');
    }
  }

  /// Gérer un code non trouvé dans l'événement
  Future<void> _handleCodeNotFoundInEvent(String code) async {
    // Afficher le dialog de confirmation
    final shouldSearch = await showDialog<bool>(
      context: context,
      builder: (context) => CodeNotFoundDialog(scannedCode: code),
    );

    if (shouldSearch != true) return;

    // Afficher le dialog de chargement
    showDialog(
      context: context,
      barrierDismissible: false,
      builder: (context) => const AddEquipmentToEventDialog(
        state: AddEquipmentState.loading,
      ),
    );

    try {
      // Identifier le type selon le préfixe
      final isContainer = code.startsWith('BOX_');

      if (isContainer) {
        await _addContainerToEvent(code);
      } else {
        await _addEquipmentToEvent(code);
      }

      // 🔊 Bip de succès
      await AudioFeedbackService.playFullFeedback(isSuccess: true);

    } catch (e) {
      DebugLog.error('[EventPreparationPage] Error adding item to event', e);

      // Fermer le dialog de chargement et afficher l'erreur
      if (mounted) Navigator.of(context).pop();

      await showDialog(
        context: context,
        builder: (context) => AddEquipmentToEventDialog(
          state: AddEquipmentState.error,
          errorMessage: e.toString(),
        ),
      );

      // 🔊 Bip d'erreur
      await AudioFeedbackService.playFullFeedback(isSuccess: false);
    }
  }

  /// Ajouter un équipement à l'événement
  Future<void> _addEquipmentToEvent(String equipmentId) async {
    // Rechercher l'équipement dans la base de données
    final equipmentProvider = context.read<EquipmentProvider>();
    await equipmentProvider.ensureLoaded();

    // Chercher d'abord dans le cache
    EquipmentModel? equipment = equipmentProvider.allEquipment
        .cast<EquipmentModel?>()
        .firstWhere(
          (eq) => eq?.id == equipmentId,
          orElse: () => null,
        );

    // Si pas dans le cache, charger depuis Firestore
    if (equipment == null) {
      final equipmentService = EquipmentService();
      equipment = await equipmentService.getEquipmentById(equipmentId);
    }

    if (equipment == null) {
      throw Exception('Équipement non trouvé dans la base de données');
    }

    // Ajouter l'équipement à l'événement
    final newEventEquipment = EventEquipment(
      equipmentId: equipmentId,
      quantity: 1,
    );

    final updatedEquipment = List<EventEquipment>.from(_currentEvent.assignedEquipment)
      ..add(newEventEquipment);

    await _dataService.updateEvent(_currentEvent.id, {
      'assignedEquipment': updatedEquipment.map((e) => e.toMap()).toList(),
    });

    // Mettre à jour l'état local
    setState(() {
      _currentEvent = _currentEvent.copyWith(
        assignedEquipment: updatedEquipment,
      );
      _equipmentCache[equipmentId] = equipment!;
      _localValidationState[equipmentId] = false;
    });

    // Fermer le dialog de chargement et afficher le succès
    if (mounted) Navigator.of(context).pop();

    await showDialog(
      context: context,
      builder: (context) => AddEquipmentToEventDialog(
        state: AddEquipmentState.success,
        itemName: equipment!.name,
      ),
    );
  }

  /// Ajouter un container à l'événement
  Future<void> _addContainerToEvent(String containerId) async {
    // Rechercher le container dans la base de données
    final containerProvider = context.read<ContainerProvider>();
    await containerProvider.ensureLoaded();

    final container = await containerProvider.getContainerById(containerId);

    if (container == null) {
      throw Exception('Container non trouvé dans la base de données');
    }

    // Ajouter le container à l'événement
    final updatedContainers = List<String>.from(_currentEvent.assignedContainers)
      ..add(containerId);

    await _dataService.updateEvent(_currentEvent.id, {
      'assignedContainers': updatedContainers,
    });

    // Mettre à jour l'état local
    setState(() {
      _currentEvent = _currentEvent.copyWith(
        assignedContainers: updatedContainers,
      );
      _containerCache[containerId] = container;
    });

    // Fermer le dialog de chargement et afficher le succès
    if (mounted) Navigator.of(context).pop();

    await showDialog(
      context: context,
      builder: (context) => AddEquipmentToEventDialog(
        state: AddEquipmentState.success,
        itemName: 'Container ${container.name}',
      ),
    );
  }

  /// Traiter la saisie manuelle d'un code
  Future<void> _handleManualCodeEntry(String code) async {
    if (code.trim().isEmpty) return;

    await _handleScannedCode(code.trim());

    // Effacer le champ après traitement
    _manualCodeController.clear();
  }

  /// Obtenir les quantités actuelles selon l'étape
  Map<String, int> _getCurrentQuantitiesMap() {
    switch (_currentStep) {
      case PreparationStep.preparation:
        return _quantitiesAtPreparation;
      case PreparationStep.loadingOutbound:
        return _quantitiesAtLoading;
      case PreparationStep.unloadingReturn:
        return _quantitiesAtUnloading;
      case PreparationStep.return_:
        return _quantitiesAtReturn;
    }
  }

  /// Mettre à jour les quantités selon l'étape
  void _updateQuantitiesMap(Map<String, int> quantities) {
    switch (_currentStep) {
      case PreparationStep.preparation:
        _quantitiesAtPreparation.addAll(quantities);
        break;
      case PreparationStep.loadingOutbound:
        _quantitiesAtLoading.addAll(quantities);
        break;
      case PreparationStep.unloadingReturn:
        _quantitiesAtUnloading.addAll(quantities);
        break;
      case PreparationStep.return_:
        _quantitiesAtReturn.addAll(quantities);
        break;
    }
  }

  /// Obtenir la quantité requise selon l'étape (nouvelle logique)
  int _getTargetQuantity(EventEquipment eventEquipment) {
    switch (_currentStep) {
      case PreparationStep.preparation:
        return eventEquipment.quantity; // Quantité initiale
      case PreparationStep.loadingOutbound:
        return eventEquipment.quantityAtPreparation ?? eventEquipment.quantity;
      case PreparationStep.unloadingReturn:
        return eventEquipment.quantityAtLoading ??
            eventEquipment.quantityAtPreparation ??
            eventEquipment.quantity;
      case PreparationStep.return_:
        return eventEquipment.quantityAtUnloading ??
            eventEquipment.quantityAtLoading ??
            eventEquipment.quantityAtPreparation ??
            eventEquipment.quantity;
    }
  }

  /// Afficher un message de succès
  void _showSuccessFeedback(String message) {
    if (!mounted) return;
    ScaffoldMessenger.of(context).showSnackBar(
      SnackBar(
        content: Row(
          children: [
            const Icon(Icons.check_circle, color: Colors.white),
            const SizedBox(width: 12),
            Expanded(child: Text(message)),
          ],
        ),
        backgroundColor: Colors.green,
        duration: const Duration(seconds: 2),
      ),
    );
  }

  /// Afficher un message d'erreur
  void _showErrorFeedback(String message) {
    if (!mounted) return;
    ScaffoldMessenger.of(context).showSnackBar(
      SnackBar(
        content: Row(
          children: [
            const Icon(Icons.error, color: Colors.white),
            const SizedBox(width: 12),
            Expanded(child: Text(message)),
          ],
        ),
        backgroundColor: Colors.orange,
        duration: const Duration(seconds: 3),
      ),
    );
  }

  // ========================================================================
  // FIN DES NOUVELLES MÉTHODES
  // ========================================================================

  Future<void> _confirm() async {
    // Vérifier s'il y a des équipements manquants (non cochés localement)
    final missingEquipmentIds = _currentEvent.assignedEquipment
        .where((eq) => !(_localValidationState[eq.equipmentId] ?? false))
        .map((eq) => eq.equipmentId)
        .toList();

    if (missingEquipmentIds.isEmpty) {
      // Tout est validé, confirmer directement
      await _confirmCurrentState();
    } else {
      // Afficher le dialog des manquants
      final missingEquipmentModels = missingEquipmentIds
          .map((id) => _equipmentCache[id])
          .whereType<EquipmentModel>()
          .toList();

      final missingEventEquipment = _currentEvent.assignedEquipment
          .where((eq) => missingEquipmentIds.contains(eq.equipmentId))
          .toList();

      final action = await showDialog<String>(
        context: context,
        builder: (context) => MissingEquipmentDialog(
          missingEquipment: missingEquipmentModels,
          eventEquipment: missingEventEquipment,
          isReturnMode: _currentStep == PreparationStep.return_ ||
                        _currentStep == PreparationStep.unloadingReturn,
        ),
      );

      if (action == 'confirm_anyway') {
        // Confirmer malgré les manquants (enregistrer l'état actuel TEL QUEL)
        await _confirmCurrentState();
      } else if (action == 'mark_as_validated') {
        // Marquer les manquants comme validés localement
        for (var equipmentId in missingEquipmentIds) {
          _localValidationState[equipmentId] = true;
        }
        setState(() {});
        // Puis confirmer
        await _confirmCurrentState();
      }
      // Si 'return_to_list', ne rien faire
    }
  }

  /// Valider tous les enfants d'un container
  void _validateAllContainerChildren(String containerId) {
    final container = _containerCache[containerId];
    if (container == null) return;

    setState(() {
      for (final equipmentId in container.equipmentIds) {
        if (_equipmentCache.containsKey(equipmentId)) {
          _localValidationState[equipmentId] = true;
        }
      }
    });
  }

  /// Mettre à jour la quantité d'un équipement à l'étape actuelle
  void _updateEquipmentQuantity(String equipmentId, int newQuantity) {
    setState(() {
      switch (_currentStep) {
        case PreparationStep.preparation:
          _quantitiesAtPreparation[equipmentId] = newQuantity;
          break;
        case PreparationStep.loadingOutbound:
          _quantitiesAtLoading[equipmentId] = newQuantity;
          break;
        case PreparationStep.unloadingReturn:
          _quantitiesAtUnloading[equipmentId] = newQuantity;
          break;
        case PreparationStep.return_:
          _quantitiesAtReturn[equipmentId] = newQuantity;
          break;
      }
    });
  }

  /// Vérifier si un équipement était manquant à l'étape précédente
  bool _wasMissingAtPreviousStep(String equipmentId) {
    final eq = _currentEvent.assignedEquipment.firstWhere(
      (e) => e.equipmentId == equipmentId,
      orElse: () => EventEquipment(equipmentId: equipmentId),
    );

    switch (_currentStep) {
      case PreparationStep.preparation:
        return false; // Pas d'étape avant
      case PreparationStep.loadingOutbound:
        return eq.isMissingAtPreparation;
      case PreparationStep.unloadingReturn:
        return eq.isMissingAtLoading;
      case PreparationStep.return_:
        return eq.isMissingAtUnloading;
    }
  }

  /// Afficher pop-up de confirmation si l'équipement était manquant avant
  Future<bool> _confirmValidationIfWasMissingBefore(String equipmentId) async {
    if (!_wasMissingAtPreviousStep(equipmentId)) {
      return true; // Pas de problème, continuer
    }

    final equipment = _equipmentCache[equipmentId];
    final result = await showDialog<bool>(
      context: context,
      builder: (context) => AlertDialog(
        title: const Row(
          children: [
            Icon(Icons.warning_amber, color: Colors.orange),
            SizedBox(width: 8),
            Text('Confirmation'),
          ],
        ),
        content: Text(
          'L\'équipement "${equipment?.name ?? equipmentId}" était manquant à l\'étape précédente.\n\n'
          'Êtes-vous sûr de le marquer comme présent maintenant ?',
        ),
        actions: [
          TextButton(
            onPressed: () => Navigator.of(context).pop(false),
            child: const Text('Annuler'),
          ),
          ElevatedButton(
            onPressed: () => Navigator.of(context).pop(true),
            style: ElevatedButton.styleFrom(
              backgroundColor: Colors.orange,
            ),
            child: const Text('Confirmer'),
          ),
        ],
      ),
    );

    return result ?? false;
  }

  /// Détermine le statut d'un équipement selon l'étape actuelle
  String _determineEquipmentStatus(EventEquipment eq) {
    // Vérifier d'abord si l'équipement est perdu (LOST)
    if (_shouldMarkAsLost(eq)) {
      return 'LOST';
    }

    // Vérifier si manquant à l'étape actuelle
    if (_isMissingAtCurrentStep(eq)) {
      return 'MISSING';
    }

    // Vérifier les quantités
    final currentQty = _getQuantityForStep(eq);
    if (currentQty != null && currentQty < eq.quantity) {
      return 'QUANTITY_MISMATCH';
    }

    return 'AVAILABLE';
  }

  /// Vérifie si un équipement doit être marqué comme LOST
  bool _shouldMarkAsLost(EventEquipment eq) {
    // Seulement aux étapes de retour
    if (_currentStep != PreparationStep.return_ &&
        !(_currentStep == PreparationStep.unloadingReturn && _loadSimultaneously)) {
      return false;
    }

    // Si manquant maintenant mais PAS manquant à la préparation = LOST
    return eq.isMissingAtReturn && !eq.isMissingAtPreparation;
  }

  /// Vérifie si un équipement est manquant à l'étape actuelle
  bool _isMissingAtCurrentStep(EventEquipment eq) {
    switch (_currentStep) {
      case PreparationStep.preparation:
        return eq.isMissingAtPreparation;
      case PreparationStep.loadingOutbound:
        return eq.isMissingAtLoading;
      case PreparationStep.unloadingReturn:
        return eq.isMissingAtUnloading;
      case PreparationStep.return_:
        return eq.isMissingAtReturn;
    }
  }

  /// Récupère la quantité pour l'étape actuelle
  int? _getQuantityForStep(EventEquipment eq) {
    switch (_currentStep) {
      case PreparationStep.preparation:
        return eq.quantityAtPreparation;
      case PreparationStep.loadingOutbound:
        return eq.quantityAtLoading;
      case PreparationStep.unloadingReturn:
        return eq.quantityAtUnloading;
      case PreparationStep.return_:
        return eq.quantityAtReturn;
    }
  }


  @override
  Widget build(BuildContext context) {
    final allValidated = _isStepCompleted();
    final stepTitle = _getStepTitle();

    return Scaffold(
      appBar: AppBar(
        title: Text(stepTitle),
        backgroundColor: AppColors.bleuFonce,
      ),
      body: Stack(
        children: [
          _isLoading
              ? const Center(child: CircularProgressIndicator())
              : Column(
                  children: [
                    Container(
                      padding: const EdgeInsets.all(16),
                      color: Colors.grey.shade100,
                      child: Column(
                        crossAxisAlignment: CrossAxisAlignment.stretch,
                        children: [
                          Text(
                            _currentEvent.name,
                            style: const TextStyle(
                              fontSize: 20,
                              fontWeight: FontWeight.bold,
                            ),
                          ),
                          const SizedBox(height: 8),
                          Row(
                            children: [
                              Expanded(
                                child: LinearProgressIndicator(
                                  value: _getProgress(),
                                  backgroundColor: Colors.grey.shade300,
                                  valueColor: AlwaysStoppedAnimation<Color>(
                                    allValidated ? Colors.green : AppColors.bleuFonce,
                                  ),
                                ),
                              ),
                              const SizedBox(width: 12),
                              Text(
                                '${_getValidatedCount()}/${_currentEvent.assignedEquipment.length}',
                                style: const TextStyle(
                                  fontWeight: FontWeight.bold,
                                  fontSize: 16,
                                ),
                              ),
                            ],
                          ),
                          const SizedBox(height: 12),

                          // Checkbox "charger en même temps" (uniquement pour préparation ou chargement retour)
                          if (_currentStep == PreparationStep.preparation ||
                              _currentStep == PreparationStep.unloadingReturn)
                            CheckboxListTile(
                              value: _loadSimultaneously,
                              onChanged: (value) {
                                setState(() {
                                  _loadSimultaneously = value ?? false;
                                });
                              },
                              title: Text(
                                _currentStep == PreparationStep.preparation
                                    ? 'Charger en même temps (chargement aller)'
                                    : 'Confirmer le retour en même temps (retour dépôt)',
                                style: const TextStyle(
                                  fontSize: 14,
                                  fontWeight: FontWeight.w500,
                                ),
                              ),
                              dense: true,
                              contentPadding: EdgeInsets.zero,
                            ),

                          // 🆕 Champ de saisie manuelle de code
                          const SizedBox(height: 16),
                          TextField(
                            controller: _manualCodeController,
                            focusNode: _manualCodeFocusNode,
                            decoration: InputDecoration(
                              labelText: 'Saisie manuelle d\'un code',
                              hintText: 'Entrez un ID d\'équipement ou container',
                              prefixIcon: const Icon(Icons.keyboard, color: AppColors.bleuFonce),
                              suffixIcon: _manualCodeController.text.isNotEmpty
                                  ? IconButton(
                                      icon: const Icon(Icons.clear),
                                      onPressed: () {
                                        _manualCodeController.clear();
                                        setState(() {});
                                      },
                                    )
                                  : null,
                              border: OutlineInputBorder(
                                borderRadius: BorderRadius.circular(8),
                              ),
                              focusedBorder: OutlineInputBorder(
                                borderRadius: BorderRadius.circular(8),
                                borderSide: const BorderSide(color: AppColors.bleuFonce, width: 2),
                              ),
                              contentPadding: const EdgeInsets.symmetric(horizontal: 16, vertical: 12),
                            ),
                            onSubmitted: _handleManualCodeEntry,
                            onChanged: (value) => setState(() {}),
                            textInputAction: TextInputAction.done,
                          ),

                          // 🆕 Bouton Scanner QR Code
                          const SizedBox(height: 12),
                          ElevatedButton.icon(
                            onPressed: _openQRScanner,
                            icon: const Icon(Icons.qr_code_scanner),
                            label: const Text('Scanner QR Code'),
                            style: ElevatedButton.styleFrom(
                              backgroundColor: Colors.blue[700],
                              padding: const EdgeInsets.symmetric(vertical: 12),
                            ),
                          ),

                          const SizedBox(height: 8),
                          ElevatedButton.icon(
                            onPressed: allValidated ? null : _validateAllAndConfirm,
                            icon: const Icon(Icons.check_circle_outline),
                            label: Text(
                              allValidated
                                  ? 'Tout est validé !'
                                  : _getValidateAllButtonText(),
                            ),
                            style: ElevatedButton.styleFrom(
                              backgroundColor: allValidated ? Colors.green : AppColors.bleuFonce,
                              padding: const EdgeInsets.symmetric(vertical: 12),
                            ),
                          ),
                        ],
                      ),
                    ),
                    Expanded(
                      child: ListView(
                        padding: const EdgeInsets.all(16),
                        children: _buildChecklistItems(),
                      ),
                    ),
                  ],
                ),
          if (_showSuccessAnimation)
            Center(
              child: ScaleTransition(
                scale: _animationController,
                child: Container(
                  padding: const EdgeInsets.all(32),
                  decoration: const BoxDecoration(
                    color: Colors.green,
                    shape: BoxShape.circle,
                  ),
                  child: const Icon(
                    Icons.check,
                    size: 64,
                    color: Colors.white,
                  ),
                ),
              ),
            ),
        ],
      ),
      bottomNavigationBar: Container(
        padding: const EdgeInsets.all(16),
        decoration: BoxDecoration(
          color: Colors.white,
          boxShadow: [
            BoxShadow(
              color: Colors.black.withValues(alpha: 0.1),
              blurRadius: 4,
              offset: const Offset(0, -2),
            ),
          ],
        ),
        child: ElevatedButton(
          onPressed: _isValidating ? null : _confirm,
          style: ElevatedButton.styleFrom(
            backgroundColor: allValidated ? Colors.green : AppColors.rouge,
            padding: const EdgeInsets.symmetric(vertical: 16),
            shape: RoundedRectangleBorder(
              borderRadius: BorderRadius.circular(8),
            ),
          ),
          child: _isValidating
              ? const SizedBox(
                  height: 20,
                  width: 20,
                  child: CircularProgressIndicator(
                    strokeWidth: 2,
                    valueColor: AlwaysStoppedAnimation<Color>(Colors.white),
                  ),
                )
              : Text(
                  'Confirmer ${_getStepTitle().toLowerCase()}',
                  style: const TextStyle(
                    fontSize: 18,
                    fontWeight: FontWeight.bold,
                  ),
                ),
        ),
      ),
    );
  }

  /// Construit la liste des items de checklist en groupant par containers
  List<Widget> _buildChecklistItems() {
    final List<Widget> items = [];

    // Set pour tracker les équipements déjà affichés dans un container
    final Set<String> equipmentIdsInContainers = {};

    // Map des EventEquipment par ID pour accès rapide
    final Map<String, EventEquipment> eventEquipmentsMap = {
      for (var eq in _currentEvent.assignedEquipment) eq.equipmentId: eq,
    };

    // 1. Afficher les containers avec leurs enfants
    for (final containerId in _currentEvent.assignedContainers) {
      final container = _containerCache[containerId];
      if (container == null) continue;

      // Récupérer les équipements enfants de ce container
      final List<EquipmentModel> childEquipments = [];
      for (final equipmentId in container.equipmentIds) {
        final equipment = _equipmentCache[equipmentId];
        if (equipment != null && eventEquipmentsMap.containsKey(equipmentId)) {
          childEquipments.add(equipment);
          equipmentIdsInContainers.add(equipmentId);
        }
      }

      if (childEquipments.isEmpty) continue;

      // Vérifier si tous les enfants sont validés
      final allChildrenValidated = childEquipments.every(
        (eq) => _localValidationState[eq.id] ?? false,
      );

      // Map des états de validation des enfants
      final Map<String, bool> childValidationStates = {
        for (var eq in childEquipments) eq.id: _localValidationState[eq.id] ?? false,
      };

      // Map des enfants manquants à l'étape précédente
      final Map<String, bool> wasMissingBeforeMap = {
        for (var eq in childEquipments) eq.id: _wasMissingAtPreviousStep(eq.id),
      };

      items.add(
        ContainerChecklistItem(
          container: container,
          childEquipments: childEquipments,
          eventEquipmentsMap: eventEquipmentsMap,
          step: _getChecklistStep(),
          isValidated: allChildrenValidated,
          childValidationStates: childValidationStates,
          onToggleContainer: () => _validateAllContainerChildren(containerId),
          onToggleChild: (equipmentId) => _toggleEquipmentValidation(equipmentId),
          onQuantityChanged: (equipmentId, qty) => _updateEquipmentQuantity(equipmentId, qty),
          wasMissingBeforeMap: wasMissingBeforeMap,
        ),
      );
    }

    // 2. Afficher les équipements standalone (pas dans un container)
    for (final eventEquipment in _currentEvent.assignedEquipment) {
      // Skip si déjà affiché dans un container
      if (equipmentIdsInContainers.contains(eventEquipment.equipmentId)) {
        continue;
      }

      final equipment = _equipmentCache[eventEquipment.equipmentId];
      if (equipment == null) continue;

      items.add(
        EquipmentChecklistItem(
          equipment: equipment,
          eventEquipment: eventEquipment,
          step: _getChecklistStep(),
          isValidated: _localValidationState[equipment.id] ?? false,
          onToggle: () => _toggleEquipmentValidation(equipment.id),
          onQuantityChanged: (qty) => _updateEquipmentQuantity(equipment.id, qty),
          isChild: false, // Équipement standalone (pas indenté)
          wasMissingBefore: _wasMissingAtPreviousStep(equipment.id),
        ),
      );
    }

    return items;
  }
}