import 'package:flutter_riverpod/flutter_riverpod.dart';
import '../../database/database.dart';
import '../../features/records/records_service.dart';
import '../auth/auth_providers.dart';
import '../github/github_auth_service.dart';
import '../github/github_sync_service.dart';
import 'firebase_sync_provider.dart';
import 'github_sync_provider.dart';
import 'r2_upload_service.dart';
import 'sync_bundle_worker.dart';
import 'sync_manager.dart';
import 'sync_models.dart';
import 'sync_outbox.dart';

/// Provider for the Cloudflare R2 Upload Service
final r2UploadServiceProvider = Provider<R2UploadService>((ref) {
  return R2UploadService();
});

/// Provider for the background bundle generation worker
final syncBundleWorkerProvider = Provider<SyncBundleWorker>((ref) {
  final db = ref.watch(databaseProvider);
  return SyncBundleWorker(db);
});

/// Provider for the local SyncOutbox backed by SharedPreferences
final syncOutboxProvider = Provider<SyncOutbox>((ref) {
  final prefs = ref.watch(sharedPreferencesProvider);
  return SyncOutbox(prefs);
});

/// Provider for the Firebase + Cloudflare R2 Cloud Sync Provider
final firebaseSyncProvider = Provider<FirebaseSyncProvider>((ref) {
  final db = ref.watch(databaseProvider);
  final authService = ref.watch(authServiceProvider);
  final bundleWorker = ref.watch(syncBundleWorkerProvider);
  final r2Service = ref.watch(r2UploadServiceProvider);
  return FirebaseSyncProvider(
    db: db,
    authService: authService,
    r2UploadService: r2Service,
    bundleWorker: bundleWorker,
  );
});

/// Provider for the GitHub Sync Provider wrapper
final githubSyncProvider = Provider<GitHubSyncProvider>((ref) {
  final service = ref.watch(githubSyncServiceProvider);
  final auth = ref.watch(githubAuthServiceProvider);
  return GitHubSyncProvider(service: service, auth: auth);
});

/// Primary ChangeNotifierProvider for the SyncManager
final syncManagerProvider = ChangeNotifierProvider<SyncManager>((ref) {
  final outbox = ref.watch(syncOutboxProvider);
  final firebaseProvider = ref.watch(firebaseSyncProvider);
  final gitHubProvider = ref.watch(githubSyncProvider);

  final manager = SyncManager(
    outbox,
    initialProviders: [firebaseProvider, gitHubProvider],
    defaultProviderId: 'firebase',
  );

  return manager;
});

/// Reactive snapshot of the overall synchronization state
final syncStateProvider = Provider<SyncManagerState>((ref) {
  final manager = ref.watch(syncManagerProvider);
  return manager.currentState;
});

/// Reactive count of currently pending synchronization items
final pendingSyncCountProvider = Provider<int>((ref) {
  return ref.watch(syncStateProvider).pendingCount;
});

/// Reactive boolean indicating if background synchronization is actively running
final isSyncProcessingProvider = Provider<bool>((ref) {
  return ref.watch(syncStateProvider).isProcessing;
});