import 'dart:async';
import 'package:flutter/foundation.dart';
import 'package:connectivity_plus/connectivity_plus.dart';
import 'package:geosector_app/core/repositories/user_repository.dart';

class SyncService {
  final UserRepository _userRepository;
  
  StreamSubscription? _connectivitySubscription;
  Timer? _periodicSyncTimer;
  
  bool _isSyncing = false;
  final Duration _syncInterval = const Duration(minutes: 15);

  SyncService({
    required UserRepository userRepository,
  }) : _userRepository = userRepository {
    _initConnectivityListener();
    _initPeriodicSync();
  }

  // Initialiser l'écouteur de connectivité
  void _initConnectivityListener() {
    _connectivitySubscription = Connectivity()
        .onConnectivityChanged
        .listen((List<ConnectivityResult> results) {
      // Vérifier si la liste contient au moins un type de connexion autre que 'none'
      if (results.any((result) => result != ConnectivityResult.none)) {
        // Lorsque la connexion est rétablie, déclencher une synchronisation
        syncAll();
      }
    });
  }

  // Initialiser la synchronisation périodique
  void _initPeriodicSync() {
    _periodicSyncTimer = Timer.periodic(_syncInterval, (timer) {
      syncAll();
    });
  }

  // Synchroniser toutes les données
  Future<void> syncAll() async {
    if (_isSyncing) return;
    
    _isSyncing = true;
    
    try {
      // Synchroniser les utilisateurs
      await _userRepository.syncAllUsers();
    } catch (e) {
      // Gérer les erreurs de synchronisation
      debugPrint('Erreur lors de la synchronisation: $e');
    } finally {
      _isSyncing = false;
    }
  }

  // Synchroniser uniquement les données d'un utilisateur spécifique
  Future<void> syncUserData(int userId) async {
    try {
      // Cette méthode pourrait être étendue à l'avenir pour synchroniser d'autres données utilisateur
      await _userRepository.refreshFromServer();
    } catch (e) {
      debugPrint('Erreur lors de la synchronisation des données utilisateur: $e');
    }
  }

  // Forcer le rafraîchissement depuis le serveur
  Future<void> forceRefresh() async {
    if (_isSyncing) return;
    
    _isSyncing = true;
    
    try {
      // Rafraîchir depuis le serveur
      await _userRepository.refreshFromServer();
    } catch (e) {
      debugPrint('Erreur lors du rafraîchissement forcé: $e');
    } finally {
      _isSyncing = false;
    }
  }

  // Obtenir l'état de synchronisation
  Map<String, dynamic> getSyncStatus() {
    return {
      'isSyncing': _isSyncing,
    };
  }

  // Nettoyer les ressources
  void dispose() {
    _connectivitySubscription?.cancel();
    _periodicSyncTimer?.cancel();
  }
}