import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:worldhopper/models/server.dart';
import 'package:worldhopper/repositories/server_repository.dart';

/// Provider for ServerRepository instance
final serverRepositoryProvider = Provider<ServerRepository>((ref) {
  return ServerRepository();
});

/// Provider for the list of all servers
final serverListProvider = StreamProvider<List<Server>>((ref) async* {
  final repository = ref.watch(serverRepositoryProvider);

  // Initial load
  yield await repository.getAllServers();

  // We'll use a simple polling mechanism for now
  // In a production app, you might want to use a more sophisticated approach
  await for (final _ in Stream.periodic(const Duration(seconds: 1))) {
    yield await repository.getAllServers();
  }
});

/// Provider for a single server by ID
final serverProvider = FutureProvider.family<Server?, String>((ref, id) async {
  final repository = ref.watch(serverRepositoryProvider);
  return await repository.getServer(id);
});

/// Provider for server count
final serverCountProvider = FutureProvider<int>((ref) async {
  final repository = ref.watch(serverRepositoryProvider);
  return await repository.getServerCount();
});

/// Notifier for managing server operations
class ServerNotifier extends StateNotifier<AsyncValue<void>> {
  final ServerRepository _repository;

  ServerNotifier(this._repository) : super(const AsyncValue.data(null));

  /// Add a new server
  Future<void> addServer(Server server) async {
    state = const AsyncValue.loading();
    state = await AsyncValue.guard(() async {
      await _repository.addServer(server);
    });
  }

  /// Update an existing server
  Future<void> updateServer(Server server) async {
    state = const AsyncValue.loading();
    state = await AsyncValue.guard(() async {
      await _repository.updateServer(server);
    });
  }

  /// Delete a server
  Future<void> deleteServer(String id) async {
    state = const AsyncValue.loading();
    state = await AsyncValue.guard(() async {
      await _repository.deleteServer(id);
    });
  }

  /// Check if server exists
  Future<bool> serverExists(String url) async {
    return await _repository.serverExists(url);
  }
}

/// Provider for ServerNotifier
final serverNotifierProvider =
    StateNotifierProvider<ServerNotifier, AsyncValue<void>>((ref) {
  final repository = ref.watch(serverRepositoryProvider);
  return ServerNotifier(repository);
});