geo/app/lib/core/services/chat_manager.dart

import 'package:flutter/foundation.dart';
import 'package:geosector_app/chat/chat_module.dart';
import 'package:geosector_app/chat/services/chat_service.dart';
import 'package:geosector_app/core/services/api_service.dart';
import 'package:geosector_app/core/services/current_user_service.dart';
import 'package:geosector_app/core/services/current_amicale_service.dart';

/// Service singleton pour gérer le cycle de vie du module chat
/// Initialise le chat une seule fois au login et maintient les syncs en arrière-plan
class ChatManager {
  static ChatManager? _instance;
  static ChatManager get instance => _instance ??= ChatManager._();
  
  ChatManager._();
  
  bool _isInitialized = false;
  bool get isInitialized => _isInitialized;
  
  bool _isPaused = false;
  bool get isPaused => _isPaused;
  
  /// Initialiser le chat (appelé après login réussi)
  /// Cette méthode est idempotente - peut être appelée plusieurs fois sans effet
  Future<void> initializeChat() async {
    if (_isInitialized) {
      debugPrint('⚠️ Chat déjà initialisé - ignoré');
      return;
    }
    
    try {
      // Récupérer les informations de l'utilisateur connecté
      final currentUser = CurrentUserService.instance;
      final apiService = ApiService.instance;
      final currentAmicale = CurrentAmicaleService.instance.currentAmicale;
      
      if (currentUser.currentUser == null) {
        debugPrint('❌ Impossible d\'initialiser le chat - utilisateur non connecté');
        return;
      }
      
      debugPrint('🔄 Initialisation du chat pour ${currentUser.userName}...');
      
      // Initialiser le module chat
      await ChatModule.init(
        apiUrl: apiService.baseUrl,
        userId: currentUser.currentUser!.id,
        userName: currentUser.userName ?? currentUser.userEmail ?? 'Utilisateur',
        userRole: currentUser.currentUser!.role,
        userEntite: currentUser.fkEntite ?? currentAmicale?.id,
        authToken: currentUser.sessionId,
      );
      
      _isInitialized = true;
      debugPrint('✅ Chat initialisé avec succès - syncs démarrées toutes les 15 secondes');
    } catch (e) {
      debugPrint('❌ Erreur initialisation chat: $e');
      // Ne pas propager l'erreur pour ne pas bloquer l'app
      // Le chat sera simplement indisponible
      _isInitialized = false;
    }
  }
  
  /// Réinitialiser le chat (utile après changement d'amicale ou reconnexion)
  Future<void> reinitialize() async {
    debugPrint('🔄 Réinitialisation du chat...');
    dispose();
    await Future.delayed(const Duration(milliseconds: 100));
    await initializeChat();
  }
  
  /// Arrêter le chat (appelé au logout ou fermeture app)
  void dispose() {
    if (_isInitialized) {
      try {
        // Nettoyer le module chat ET le service
        ChatModule.cleanup();  // Reset le flag _isInitialized dans ChatModule
        _isInitialized = false;
        _isPaused = false;
        debugPrint('🛑 Chat arrêté - syncs stoppées et module réinitialisé');
      } catch (e) {
        debugPrint('⚠️ Erreur lors de l\'arrêt du chat: $e');
      }
    }
  }
  
  /// Mettre en pause les synchronisations (app en arrière-plan)
  void pauseSyncs() {
    if (_isInitialized && !_isPaused) {
      try {
        ChatService.instance.pauseSyncs();
        _isPaused = true;
        debugPrint('⏸️ Syncs chat mises en pause');
      } catch (e) {
        debugPrint('⚠️ Erreur lors de la pause du chat: $e');
      }
    }
  }
  
  /// Reprendre les synchronisations (app au premier plan)
  void resumeSyncs() {
    if (_isInitialized && _isPaused) {
      try {
        ChatService.instance.resumeSyncs();
        _isPaused = false;
        debugPrint('▶️ Syncs chat reprises');
      } catch (e) {
        debugPrint('⚠️ Erreur lors de la reprise du chat: $e');
      }
    }
  }
  
  /// Vérifier si le chat est prêt à être utilisé
  bool get isReady {
    if (!_isInitialized) return false;
    
    // Vérifier que l'utilisateur est toujours connecté
    final currentUser = CurrentUserService.instance;
    if (currentUser.currentUser == null) {
      debugPrint('⚠️ Chat initialisé mais utilisateur déconnecté');
      dispose();
      return false;
    }
    
    // Ne pas considérer comme prêt si en pause
    if (_isPaused) {
      debugPrint('⚠️ Chat en pause');
      return false;
    }
    
    return true;
  }
}