step

lib/shared/providers/backup_provider.dart

@@ -0,0 +1,8 @@
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import '../services/backup_service.dart';
+import 'premium_provider.dart';
+
+final backupServiceProvider = Provider<BackupService>((ref) {
+  final token = ref.watch(purchaseTokenProvider) ?? '';
+  return BackupService(token);
+});

lib/shared/providers/billing_provider.dart

@@ -1,8 +1,6 @@
 import 'package:flutter_riverpod/flutter_riverpod.dart';
-import '../../features/dashboard/provider.dart';
 import '../services/billing_service.dart';
 
 final billingServiceProvider = Provider<BillingService>((ref) {
-  final prefs = ref.watch(sharedPreferencesProvider);
-  return MockBillingService(prefs);
+  return PlayBillingService();
 });

lib/shared/providers/current_user_provider.dart

@@ -1,29 +1,27 @@
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import '../../features/dashboard/provider.dart';
 import '../models/user_model.dart';
+import '../services/premium_manager.dart';
+import 'billing_provider.dart';
 
 class CurrentUserNotifier extends Notifier<UserModel> {
-  static const _key = 'user_plan';
-
   @override
   UserModel build() {
     final prefs = ref.watch(sharedPreferencesProvider);
-    final planName = prefs.getString(_key);
-    final plan = UserPlan.values.firstWhere(
-      (e) => e.name == planName,
-      orElse: () => UserPlan.free,
-    );
-    return UserModel(plan: plan);
+    final billing = ref.watch(billingServiceProvider);
+    final manager = PremiumManager(prefs, billing);
+    return UserModel(plan: manager.currentPlan);
   }
 
   Future<void> setPlan(UserPlan plan) async {
-    final prefs = ref.read(sharedPreferencesProvider);
     state = UserModel(plan: plan);
-    await prefs.setString(_key, plan.name);
   }
 
-  Future<void> toggleVip() async {
-    await setPlan(state.isVip ? UserPlan.free : UserPlan.vip);
+  Future<void> refreshFromPremium() async {
+    final prefs = ref.read(sharedPreferencesProvider);
+    final billing = ref.read(billingServiceProvider);
+    final manager = PremiumManager(prefs, billing);
+    state = UserModel(plan: manager.currentPlan);
   }
 }
 

lib/shared/providers/google_drive_provider.dart

@@ -0,0 +1,18 @@
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:google_sign_in/google_sign_in.dart';
+import '../services/google_drive_service.dart';
+
+final googleDriveServiceProvider = Provider<GoogleDriveService>((ref) {
+  final signIn = GoogleSignIn(
+    scopes: [
+      'email',
+      'https://www.googleapis.com/auth/drive.appdata',
+    ],
+  );
+  return GoogleDriveService(signIn);
+});
+
+final googleDriveUserProvider = StreamProvider<GoogleSignInAccount?>((ref) {
+  final service = ref.watch(googleDriveServiceProvider);
+  return service.onUserChanged;
+});

lib/shared/providers/premium_provider.dart

@@ -0,0 +1,20 @@
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import '../../features/dashboard/provider.dart';
+import '../services/premium_manager.dart';
+import 'billing_provider.dart';
+
+final premiumManagerProvider = Provider<PremiumManager>((ref) {
+  final prefs = ref.watch(sharedPreferencesProvider);
+  final billing = ref.watch(billingServiceProvider);
+  return PremiumManager(prefs, billing);
+});
+
+final isPremiumProvider = Provider<bool>((ref) {
+  final manager = ref.watch(premiumManagerProvider);
+  return manager.isPremium;
+});
+
+final purchaseTokenProvider = Provider<String?>((ref) {
+  final manager = ref.watch(premiumManagerProvider);
+  return manager.purchaseToken;
+});

lib/shared/services/backup_service.dart

@@ -0,0 +1,72 @@
+import 'dart:convert';
+import 'dart:typed_data';
+
+class BackupData {
+  final String ownerPurchaseToken;
+  final DateTime createdAt;
+  final Map<String, dynamic> payload;
+
+  const BackupData({
+    required this.ownerPurchaseToken,
+    required this.createdAt,
+    required this.payload,
+  });
+
+  Map<String, dynamic> toJson() => {
+        'owner_purchase_token': ownerPurchaseToken,
+        'created_at': createdAt.toIso8601String(),
+        'payload': payload,
+      };
+
+  factory BackupData.fromJson(Map<String, dynamic> json) {
+    return BackupData(
+      ownerPurchaseToken: json['owner_purchase_token'] as String? ?? '',
+      createdAt: DateTime.tryParse(json['created_at'] as String? ?? '') ??
+          DateTime.now(),
+      payload: json['payload'] as Map<String, dynamic>? ?? {},
+    );
+  }
+}
+
+enum BackupVerifyResult { ok, tokenMismatch, noToken, invalidFormat }
+
+class BackupService {
+  String _currentPurchaseToken;
+
+  BackupService(this._currentPurchaseToken);
+
+  void updatePurchaseToken(String token) {
+    _currentPurchaseToken = token;
+  }
+
+  String get currentPurchaseToken => _currentPurchaseToken;
+
+  Uint8List createBackup(Map<String, dynamic> payload) {
+    final data = BackupData(
+      ownerPurchaseToken: _currentPurchaseToken,
+      createdAt: DateTime.now(),
+      payload: payload,
+    );
+    final json = jsonEncode(data.toJson());
+    return Uint8List.fromList(utf8.encode(json));
+  }
+
+  (BackupVerifyResult, BackupData?) verifyAndParse(Uint8List raw) {
+    try {
+      final json = jsonDecode(utf8.decode(raw)) as Map<String, dynamic>;
+      final data = BackupData.fromJson(json);
+
+      if (data.ownerPurchaseToken.isEmpty) {
+        return (BackupVerifyResult.noToken, null);
+      }
+
+      if (data.ownerPurchaseToken != _currentPurchaseToken) {
+        return (BackupVerifyResult.tokenMismatch, null);
+      }
+
+      return (BackupVerifyResult.ok, data);
+    } catch (e) {
+      return (BackupVerifyResult.invalidFormat, null);
+    }
+  }
+}

lib/shared/services/billing_service.dart

@@ -1,34 +1,192 @@
-import 'package:shared_preferences/shared_preferences.dart';
-import '../models/user_model.dart';
+import 'dart:async';
+import 'package:flutter/foundation.dart';
+import 'package:in_app_purchase/in_app_purchase.dart';
+
+class PurchaseResult {
+  final bool success;
+  final String? purchaseToken;
+  final String? error;
+
+  const PurchaseResult({this.success = false, this.purchaseToken, this.error});
+
+  factory PurchaseResult.ok(String token) =>
+      PurchaseResult(success: true, purchaseToken: token);
+
+  factory PurchaseResult.failed([String? error]) =>
+      PurchaseResult(success: false, error: error);
+}
 
 abstract class BillingService {
-  Future<bool> purchasePro();
-  Future<bool> restorePurchases();
-  Future<UserPlan> getCurrentPlan();
+  static const proProductId = 'casha_pro_lifetime';
+
+  Future<PurchaseResult> purchasePro();
+  Future<PurchaseResult> restorePurchases();
+  Future<PurchaseResult> queryPastPurchase();
+  Future<void> completePurchase(String purchaseToken);
+  Stream<List<PurchaseDetails>> get purchaseStream;
+  Future<void> dispose();
 }
 
-class MockBillingService implements BillingService {
-  static const _key = 'user_plan';
-  final SharedPreferences _prefs;
+class PlayBillingService implements BillingService {
+  final InAppPurchase _inAppPurchase = InAppPurchase.instance;
+  late final StreamSubscription<List<PurchaseDetails>> _sub;
+  final _controller = StreamController<List<PurchaseDetails>>.broadcast();
 
-  MockBillingService(this._prefs);
-
-  @override
-  Future<bool> purchasePro() async {
-    await Future.delayed(const Duration(seconds: 1));
-    await _prefs.setString(_key, 'vip');
-    return true;
+  PlayBillingService() {
+    _sub = _inAppPurchase.purchaseStream.listen((purchases) {
+      _controller.add(purchases);
+    });
   }
 
   @override
-  Future<bool> restorePurchases() async {
-    await Future.delayed(const Duration(seconds: 1));
-    return false;
+  Stream<List<PurchaseDetails>> get purchaseStream => _controller.stream;
+
+  @override
+  Future<PurchaseResult> purchasePro() async {
+    final available = await _inAppPurchase.isAvailable();
+    if (!available) {
+      return PurchaseResult.failed('Billing not available');
+    }
+
+    final response = await _inAppPurchase.queryProductDetails(
+      {BillingService.proProductId},
+    );
+    if (response.productDetails.isEmpty) {
+      return PurchaseResult.failed('Product not found');
+    }
+
+    final product = response.productDetails.first;
+    final purchaseParam = PurchaseParam(productDetails: product);
+
+    final started = await _inAppPurchase.buyNonConsumable(
+      purchaseParam: purchaseParam,
+    );
+    if (!started) {
+      return PurchaseResult.failed('Could not start purchase');
+    }
+
+    final completer = Completer<PurchaseResult>();
+    late StreamSubscription sub;
+    sub = purchaseStream.timeout(
+      const Duration(seconds: 60),
+      onTimeout: (sink) {
+        if (!completer.isCompleted) {
+          completer.complete(PurchaseResult.failed('Purchase timed out'));
+        }
+        sub.cancel();
+      },
+    ).listen((purchases) {
+      for (final p in purchases) {
+        if (p.productID == BillingService.proProductId &&
+            p.status == PurchaseStatus.purchased) {
+          if (!completer.isCompleted) {
+            completer.complete(PurchaseResult.ok(p.verificationData.serverVerificationData));
+          }
+          sub.cancel();
+          return;
+        }
+        if (p.status == PurchaseStatus.error) {
+          if (!completer.isCompleted) {
+            completer.complete(PurchaseResult.failed(p.error?.message));
+          }
+          sub.cancel();
+          return;
+        }
+      }
+    });
+
+    return completer.future;
   }
 
   @override
-  Future<UserPlan> getCurrentPlan() async {
-    final value = _prefs.getString(_key);
-    return value == 'vip' ? UserPlan.vip : UserPlan.free;
+  Future<PurchaseResult> restorePurchases() async {
+    final available = await _inAppPurchase.isAvailable();
+    if (!available) {
+      return PurchaseResult.failed('Billing not available');
+    }
+
+    await _inAppPurchase.restorePurchases();
+
+    final completer = Completer<PurchaseResult>();
+    late StreamSubscription sub;
+    sub = purchaseStream.timeout(
+      const Duration(seconds: 15),
+      onTimeout: (sink) {
+        if (!completer.isCompleted) {
+          completer.complete(PurchaseResult.failed('Restore timed out'));
+        }
+        sub.cancel();
+      },
+    ).listen((purchases) {
+      for (final p in purchases) {
+        if (p.productID == BillingService.proProductId &&
+            (p.status == PurchaseStatus.restored ||
+                p.status == PurchaseStatus.purchased)) {
+          if (!completer.isCompleted) {
+            completer.complete(PurchaseResult.ok(p.verificationData.serverVerificationData));
+          }
+          sub.cancel();
+          return;
+        }
+      }
+    });
+
+    return completer.future;
+  }
+
+  @override
+  Future<PurchaseResult> queryPastPurchase() async {
+    final available = await _inAppPurchase.isAvailable();
+    if (!available) {
+      return const PurchaseResult();
+    }
+
+    final response = await _inAppPurchase.queryProductDetails(
+      {BillingService.proProductId},
+    );
+    if (response.productDetails.isEmpty) {
+      return const PurchaseResult();
+    }
+
+    final completer = Completer<PurchaseResult>();
+    late StreamSubscription sub;
+    sub = purchaseStream.timeout(
+      const Duration(seconds: 10),
+      onTimeout: (sink) {
+        if (!completer.isCompleted) {
+          completer.complete(const PurchaseResult());
+        }
+        sub.cancel();
+      },
+    ).listen((purchases) {
+      for (final p in purchases) {
+        if (p.productID == BillingService.proProductId &&
+            (p.status == PurchaseStatus.restored ||
+                p.status == PurchaseStatus.purchased)) {
+          if (!completer.isCompleted) {
+            completer.complete(PurchaseResult.ok(p.verificationData.serverVerificationData));
+          }
+          sub.cancel();
+          return;
+        }
+      }
+    });
+
+    await _inAppPurchase.restorePurchases();
+
+    return completer.future;
+  }
+
+  @override
+  Future<void> completePurchase(String purchaseToken) async {
+    if (kDebugMode) {
+      print('completePurchase: $purchaseToken');
+    }
+  }
+
+  @override
+  Future<void> dispose() async {
+    await _sub.cancel();
+    await _controller.close();
   }
 }

lib/shared/services/google_auth_service.dart

@@ -4,7 +4,10 @@ import 'package:google_sign_in/google_sign_in.dart';
 class GoogleAuthService {
   final GoogleSignIn _googleSignIn;
 
-  GoogleAuthService() : _googleSignIn = GoogleSignIn(scopes: ['email']);
+  GoogleAuthService() : _googleSignIn = GoogleSignIn(scopes: [
+    'email',
+    'https://www.googleapis.com/auth/drive.appdata',
+  ]);
 
   GoogleSignInAccount? get currentUser => _googleSignIn.currentUser;
 

lib/shared/services/google_drive_service.dart

@@ -0,0 +1,147 @@
+import 'dart:typed_data';
+import 'package:googleapis/drive/v3.dart' as drive;
+import 'package:google_sign_in/google_sign_in.dart';
+import 'package:extension_google_sign_in_as_googleapis_auth/extension_google_sign_in_as_googleapis_auth.dart';
+
+class DriveBackupResult {
+  final bool success;
+  final String? error;
+  final String? fileId;
+  final DateTime? modifiedTime;
+
+  const DriveBackupResult({this.success = false, this.error, this.fileId, this.modifiedTime});
+
+  factory DriveBackupResult.ok(String fileId, DateTime modifiedTime) =>
+      DriveBackupResult(success: true, fileId: fileId, modifiedTime: modifiedTime);
+
+  factory DriveBackupResult.failed(String error) =>
+      DriveBackupResult(success: false, error: error);
+}
+
+class GoogleDriveService {
+  static const _fileName = 'casha_backup.json';
+  static const _appDataFolder = 'appDataFolder';
+
+  final GoogleSignIn _googleSignIn;
+
+  GoogleDriveService(this._googleSignIn);
+
+  GoogleSignInAccount? get currentUser => _googleSignIn.currentUser;
+  Stream<GoogleSignInAccount?> get onUserChanged => _googleSignIn.onCurrentUserChanged;
+
+  Future<void> signIn() async {
+    await _googleSignIn.signIn();
+  }
+
+  Future<void> signOut() async {
+    await _googleSignIn.signOut();
+  }
+
+  Future<drive.DriveApi?> _getDriveApi() async {
+    if (_googleSignIn.currentUser == null) return null;
+    final httpClient = await _googleSignIn.authenticatedClient();
+    if (httpClient == null) return null;
+    return drive.DriveApi(httpClient);
+  }
+
+  Future<String?> _findExistingFile(drive.DriveApi api) async {
+    final list = await api.files.list(
+      spaces: _appDataFolder,
+      q: "name = '$_fileName' and trashed = false",
+      $fields: 'files(id, name, modifiedTime)',
+    );
+    return list.files?.isNotEmpty == true ? list.files!.first.id : null;
+  }
+
+  Future<DriveBackupResult> uploadBackup(Uint8List data) async {
+    final api = await _getDriveApi();
+    if (api == null) {
+      return DriveBackupResult.failed('Not authenticated');
+    }
+
+    try {
+      final existingId = await _findExistingFile(api);
+
+      final media = drive.Media(
+        Stream<List<int>>.fromIterable([data.toList()]),
+        data.length,
+      );
+
+      if (existingId != null) {
+        final file = drive.File(
+          name: _fileName,
+          modifiedTime: DateTime.now(),
+        );
+        final updated = await api.files.update(
+          file,
+          existingId,
+          uploadMedia: media,
+          $fields: 'id, modifiedTime',
+        );
+        return DriveBackupResult.ok(
+          updated.id!,
+          updated.modifiedTime!,
+        );
+      } else {
+        final file = drive.File(
+          name: _fileName,
+          parents: [_appDataFolder],
+          modifiedTime: DateTime.now(),
+        );
+        final created = await api.files.create(
+          file,
+          uploadMedia: media,
+          $fields: 'id, modifiedTime',
+        );
+        return DriveBackupResult.ok(
+          created.id!,
+          created.modifiedTime!,
+        );
+      }
+    } catch (e) {
+      return DriveBackupResult.failed(e.toString());
+    }
+  }
+
+  Future<Uint8List?> downloadBackup() async {
+    final api = await _getDriveApi();
+    if (api == null) return null;
+
+    try {
+      final fileId = await _findExistingFile(api);
+      if (fileId == null) return null;
+
+      final media = await api.files.get(
+        fileId,
+        downloadOptions: drive.DownloadOptions.fullMedia,
+      ) as drive.Media;
+
+      final bytes = <int>[];
+      await for (final chunk in media.stream) {
+        bytes.addAll(chunk);
+      }
+      return Uint8List.fromList(bytes);
+    } catch (e) {
+      return null;
+    }
+  }
+
+  Future<DateTime?> getLastBackupTime() async {
+    final api = await _getDriveApi();
+    if (api == null) return null;
+
+    try {
+      final list = await api.files.list(
+        spaces: _appDataFolder,
+        q: "name = '$_fileName' and trashed = false",
+        $fields: 'files(id, name, modifiedTime)',
+      );
+      if (list.files?.isNotEmpty == true) {
+        return list.files!.first.modifiedTime;
+      }
+      return null;
+    } catch (e) {
+      return null;
+    }
+  }
+}

lib/shared/services/premium_manager.dart

@@ -0,0 +1,58 @@
+import 'package:shared_preferences/shared_preferences.dart';
+import '../models/user_model.dart';
+import 'billing_service.dart';
+
+class PremiumManager {
+  static const _keyIsPremium = 'is_premium';
+  static const _keyPurchaseToken = 'purchase_token';
+
+  final SharedPreferences _prefs;
+  final BillingService _billing;
+
+  PremiumManager(this._prefs, this._billing);
+
+  bool get isPremium => _prefs.getBool(_keyIsPremium) ?? false;
+  String? get purchaseToken => _prefs.getString(_keyPurchaseToken);
+
+  Future<void> _setPremium(bool value, String? token) async {
+    await _prefs.setBool(_keyIsPremium, value);
+    if (token != null) {
+      await _prefs.setString(_keyPurchaseToken, token);
+    } else if (!value) {
+      await _prefs.remove(_keyPurchaseToken);
+    }
+  }
+
+  Future<PurchaseResult> purchase() async {
+    final result = await _billing.purchasePro();
+    if (result.success && result.purchaseToken != null) {
+      await _setPremium(true, result.purchaseToken);
+      await _billing.completePurchase(result.purchaseToken!);
+    }
+    return result;
+  }
+
+  Future<PurchaseResult> restore() async {
+    final result = await _billing.restorePurchases();
+    if (result.success && result.purchaseToken != null) {
+      await _setPremium(true, result.purchaseToken);
+      await _billing.completePurchase(result.purchaseToken!);
+    }
+    return result;
+  }
+
+  Future<void> autoRestore() async {
+    if (isPremium) return;
+    final result = await _billing.queryPastPurchase();
+    if (result.success && result.purchaseToken != null) {
+      await _setPremium(true, result.purchaseToken);
+      await _billing.completePurchase(result.purchaseToken!);
+    }
+  }
+
+  UserPlan get currentPlan => isPremium ? UserPlan.vip : UserPlan.free;
+
+  Future<void> clear() async {
+    await _setPremium(false, null);
+  }
+}

lib/shared/widgets/backup_screen.dart

@@ -0,0 +1,360 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:go_router/go_router.dart';
+import '../../core/l10n/app_strings.dart';
+import '../../core/l10n/locale_provider.dart';
+import '../../core/services/haptic_service.dart';
+import '../providers/backup_provider.dart';
+import '../providers/google_drive_provider.dart';
+import '../providers/premium_provider.dart';
+import 'error_snackbar.dart';
+import '../services/backup_service.dart';
+
+class BackupScreen extends ConsumerStatefulWidget {
+  const BackupScreen({super.key});
+
+  @override
+  ConsumerState<BackupScreen> createState() => _BackupScreenState();
+}
+
+class _BackupScreenState extends ConsumerState<BackupScreen> {
+  bool _backingUp = false;
+  bool _restoring = false;
+  DateTime? _lastBackupTime;
+
+  @override
+  void initState() {
+    super.initState();
+    _loadLastBackupTime();
+  }
+
+  Future<void> _loadLastBackupTime() async {
+    final service = ref.read(googleDriveServiceProvider);
+    final time = await service.getLastBackupTime();
+    if (mounted) {
+      setState(() => _lastBackupTime = time);
+    }
+  }
+
+  Future<void> _handleBackup() async {
+    final s = ref.read(stringsProvider);
+    final driveService = ref.read(googleDriveServiceProvider);
+
+    if (driveService.currentUser == null) {
+      showErrorSnackbar(context, s.backupRequiresSignIn);
+      return;
+    }
+
+    HapticService.light();
+    setState(() => _backingUp = true);
+
+    try {
+      final backupService = ref.read(backupServiceProvider);
+      final payload = <String, dynamic>{
+        'version': 1,
+        'exported_at': DateTime.now().toIso8601String(),
+      };
+      final data = backupService.createBackup(payload);
+      final result = await driveService.uploadBackup(data);
+
+      if (result.success) {
+        setState(() => _lastBackupTime = result.modifiedTime);
+        HapticService.medium();
+        if (mounted) {
+          showSuccessSnackbar(context, s.backupSuccess);
+        }
+      } else {
+        if (mounted) {
+          showErrorSnackbar(context, result.error ?? s.backupRestoreFailed);
+        }
+      }
+    } catch (e) {
+      if (mounted) {
+        showErrorSnackbar(context, e.toString());
+      }
+    } finally {
+      if (mounted) setState(() => _backingUp = false);
+    }
+  }
+
+  Future<void> _handleRestore() async {
+    final s = ref.read(stringsProvider);
+    final driveService = ref.read(googleDriveServiceProvider);
+
+    if (driveService.currentUser == null) {
+      showErrorSnackbar(context, s.backupRequiresSignIn);
+      return;
+    }
+
+    HapticService.light();
+    setState(() => _restoring = true);
+
+    try {
+      final raw = await driveService.downloadBackup();
+      if (raw == null) {
+        if (mounted) {
+          showWarningSnackbar(context, s.backupNoFileFound);
+        }
+        return;
+      }
+
+      final backupService = ref.read(backupServiceProvider);
+      final (result, data) = backupService.verifyAndParse(raw);
+
+      switch (result) {
+        case BackupVerifyResult.ok:
+          HapticService.medium();
+          if (mounted) {
+            showSuccessSnackbar(context, s.backupRestoreSuccess);
+          }
+        case BackupVerifyResult.tokenMismatch:
+          if (mounted) {
+            showErrorSnackbar(context, s.backupTokenMismatch);
+          }
+        case BackupVerifyResult.noToken:
+          if (mounted) {
+            showErrorSnackbar(context, s.backupNoToken);
+          }
+        case BackupVerifyResult.invalidFormat:
+          if (mounted) {
+            showErrorSnackbar(context, s.backupInvalidFormat);
+          }
+      }
+    } catch (e) {
+      if (mounted) {
+        showErrorSnackbar(context, e.toString());
+      }
+    } finally {
+      if (mounted) setState(() => _restoring = false);
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final s = ref.watch(stringsProvider);
+    final isPremium = ref.watch(isPremiumProvider);
+    final driveUserAsync = ref.watch(googleDriveUserProvider);
+    final driveUser = driveUserAsync.value;
+    final colorScheme = Theme.of(context).colorScheme;
+
+    return Scaffold(
+      body: SafeArea(
+        child: Column(
+          children: [
+            Padding(
+              padding: const EdgeInsets.fromLTRB(8, 4, 16, 0),
+              child: Row(
+                children: [
+                  IconButton(
+                    icon: const Icon(Icons.arrow_back_rounded),
+                    onPressed: () => context.pop(),
+                  ),
+                  Text(
+                    s.backupTitle,
+                    style: Theme.of(context).textTheme.titleLarge?.copyWith(
+                          fontWeight: FontWeight.w800,
+                        ),
+                  ),
+                ],
+              ),
+            ),
+            Expanded(
+              child: SingleChildScrollView(
+                padding: const EdgeInsets.all(20),
+                child: Column(
+                  crossAxisAlignment: CrossAxisAlignment.start,
+                  children: [
+                    if (!isPremium) ...[
+                      _buildLockedState(context, s, colorScheme),
+                    ] else ...[
+                      _buildSyncStatus(context, s, colorScheme, driveUser),
+                      const SizedBox(height: 20),
+                      _buildBackupActions(context, s, colorScheme, driveUser),
+                      const SizedBox(height: 20),
+                      _buildLastBackup(context, s, colorScheme),
+                    ],
+                  ],
+                ),
+              ),
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+
+  Widget _buildLockedState(
+    BuildContext context,
+    AppStrings s,
+    ColorScheme colorScheme,
+  ) {
+    return Container(
+      width: double.infinity,
+      padding: const EdgeInsets.all(24),
+      decoration: BoxDecoration(
+        color: colorScheme.surface,
+        borderRadius: BorderRadius.circular(16),
+        border: Border.all(color: colorScheme.outlineVariant),
+      ),
+      child: Column(
+        children: [
+          Icon(Icons.lock_outline_rounded, size: 48, color: colorScheme.primary),
+          const SizedBox(height: 16),
+          Text(
+            s.backupRequiresPremium,
+            style: Theme.of(context).textTheme.titleMedium?.copyWith(
+                  fontWeight: FontWeight.w600,
+                ),
+            textAlign: TextAlign.center,
+          ),
+          const SizedBox(height: 16),
+          FilledButton(
+            onPressed: () => context.push('/pro'),
+            child: Text(s.proBuy),
+          ),
+        ],
+      ),
+    );
+  }
+
+  Widget _buildSyncStatus(
+    BuildContext context,
+    AppStrings s,
+    ColorScheme colorScheme,
+    dynamic driveUser,
+  ) {
+    return Container(
+      width: double.infinity,
+      padding: const EdgeInsets.all(16),
+      decoration: BoxDecoration(
+        color: colorScheme.surface,
+        borderRadius: BorderRadius.circular(16),
+        border: Border.all(color: colorScheme.outlineVariant),
+      ),
+      child: Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: [
+          Row(
+            children: [
+              Icon(
+                driveUser != null
+                    ? Icons.cloud_done_rounded
+                    : Icons.cloud_off_rounded,
+                color: driveUser != null ? colorScheme.primary : colorScheme.onSurface.withOpacity(0.4),
+                size: 24,
+              ),
+              const SizedBox(width: 12),
+              Expanded(
+                child: Text(
+                  driveUser != null
+                      ? s.proSyncEnabled
+                      : s.backupRequiresSignIn,
+                  style: Theme.of(context).textTheme.titleMedium?.copyWith(
+                        fontWeight: FontWeight.w600,
+                      ),
+                ),
+              ),
+            ],
+          ),
+          if (driveUser != null) ...[
+            const SizedBox(height: 8),
+            Text(
+              driveUser.email,
+              style: Theme.of(context).textTheme.bodySmall?.copyWith(
+                    color: colorScheme.onSurface.withOpacity(0.6),
+                  ),
+            ),
+          ],
+        ],
+      ),
+    );
+  }
+
+  Widget _buildBackupActions(
+    BuildContext context,
+    AppStrings s,
+    ColorScheme colorScheme,
+    dynamic driveUser,
+  ) {
+    final disabled = driveUser == null;
+    return Column(
+      children: [
+        SizedBox(
+          width: double.infinity,
+          child: FilledButton.icon(
+            onPressed: (disabled || _backingUp) ? null : _handleBackup,
+            icon: _backingUp
+                ? SizedBox(
+                    width: 18,
+                    height: 18,
+                    child: CircularProgressIndicator(
+                      strokeWidth: 2,
+                      color: colorScheme.onPrimary,
+                    ),
+                  )
+                : const Icon(Icons.backup_outlined),
+            label: Text(_backingUp ? s.backupCreating : s.backupCreate),
+            style: FilledButton.styleFrom(
+              padding: const EdgeInsets.symmetric(vertical: 14),
+              shape: RoundedRectangleBorder(
+                borderRadius: BorderRadius.circular(12),
+              ),
+            ),
+          ),
+        ),
+        const SizedBox(height: 12),
+        SizedBox(
+          width: double.infinity,
+          child: OutlinedButton.icon(
+            onPressed: (disabled || _restoring) ? null : _handleRestore,
+            icon: _restoring
+                ? SizedBox(
+                    width: 18,
+                    height: 18,
+                    child: CircularProgressIndicator(
+                      strokeWidth: 2,
+                      color: colorScheme.primary,
+                    ),
+                  )
+                : const Icon(Icons.restore_rounded),
+            label: Text(_restoring ? s.backupRestoring : s.backupRestore),
+            style: OutlinedButton.styleFrom(
+              padding: const EdgeInsets.symmetric(vertical: 14),
+              shape: RoundedRectangleBorder(
+                borderRadius: BorderRadius.circular(12),
+              ),
+            ),
+          ),
+        ),
+      ],
+    );
+  }
+
+  Widget _buildLastBackup(
+    BuildContext context,
+    AppStrings s,
+    ColorScheme colorScheme,
+  ) {
+    return Row(
+      children: [
+        Icon(
+          Icons.schedule_rounded,
+          size: 18,
+          color: colorScheme.onSurface.withOpacity(0.5),
+        ),
+        const SizedBox(width: 8),
+        Text(
+          '${s.backupLastBackup}: ${_lastBackupTime != null ? _formatDate(_lastBackupTime!) : s.backupNever}',
+          style: Theme.of(context).textTheme.bodySmall?.copyWith(
+                color: colorScheme.onSurface.withOpacity(0.5),
+              ),
+        ),
+      ],
+    );
+  }
+
+  String _formatDate(DateTime dt) {
+    final d = dt.toLocal();
+    return '${d.day.toString().padLeft(2, '0')}.${d.month.toString().padLeft(2, '0')}.${d.year} ${d.hour.toString().padLeft(2, '0')}:${d.minute.toString().padLeft(2, '0')}';
+  }
+}

lib/shared/widgets/pro_screen.dart

@@ -4,11 +4,9 @@ import 'package:go_router/go_router.dart';
 import '../../core/l10n/app_strings.dart';
 import '../../core/l10n/locale_provider.dart';
 import '../../core/services/haptic_service.dart';
-import '../feature_flags/feature_flags_provider.dart';
-import '../models/user_model.dart';
-import '../providers/billing_provider.dart';
 import '../providers/current_user_provider.dart';
-import '../providers/google_auth_provider.dart';
+import '../providers/google_drive_provider.dart';
+import '../providers/premium_provider.dart';
 import 'error_snackbar.dart';
 
 class ProScreen extends ConsumerStatefulWidget {
@@ -68,10 +66,9 @@ class _ProScreenState extends ConsumerState<ProScreen>
   @override
   Widget build(BuildContext context) {
     final s = ref.watch(stringsProvider);
-    final flags = ref.watch(featureFlagsProvider);
-    final isVip = flags.maxAccounts != 3;
-    final googleUserAsync = ref.watch(googleCurrentUserProvider);
-    final googleUser = googleUserAsync.value;
+    final isPremium = ref.watch(isPremiumProvider);
+    final driveUserAsync = ref.watch(googleDriveUserProvider);
+    final driveUser = driveUserAsync.value;
     final colorScheme = Theme.of(context).colorScheme;
 
     return Stack(
@@ -88,18 +85,18 @@ class _ProScreenState extends ConsumerState<ProScreen>
                       crossAxisAlignment: CrossAxisAlignment.start,
                       children: [
                         const SizedBox(height: 4),
-                        _buildHeroBanner(context, s, colorScheme, isVip),
+                        _buildHeroBanner(context, s, colorScheme, isPremium),
                         const SizedBox(height: 20),
                         _buildFeatureList(context, s, colorScheme),
                         const SizedBox(height: 16),
-                        if (isVip) ...[
-                          _buildProActiveSection(context, s, colorScheme, googleUser),
+                        if (isPremium) ...[
+                          _buildProActiveSection(context, s, colorScheme, driveUser),
                         ],
                       ],
                     ),
                   ),
                 ),
-                _buildBottomBar(context, s, colorScheme, isVip),
+                _buildBottomBar(context, s, colorScheme, isPremium),
               ],
             ),
           ),
@@ -476,17 +473,17 @@ class _ProScreenState extends ConsumerState<ProScreen>
     HapticService.light();
     setState(() => _purchasing = true);
     try {
-      final billing = ref.read(billingServiceProvider);
-      final success = await billing.purchasePro();
-      if (success) {
-        await ref.read(currentUserProvider.notifier).setPlan(UserPlan.vip);
+      final manager = ref.read(premiumManagerProvider);
+      final result = await manager.purchase();
+      if (result.success) {
+        await ref.read(currentUserProvider.notifier).refreshFromPremium();
         if (mounted) {
           _showSuccessOverlay();
           HapticService.medium();
         }
       } else {
         if (mounted) {
-          showErrorSnackbar(context, ref.read(stringsProvider).proPurchaseFailed);
+          showErrorSnackbar(context, result.error ?? ref.read(stringsProvider).proPurchaseFailed);
         }
       }
     } catch (e) {
@@ -502,10 +499,10 @@ class _ProScreenState extends ConsumerState<ProScreen>
     HapticService.light();
     setState(() => _restoring = true);
     try {
-      final billing = ref.read(billingServiceProvider);
-      final success = await billing.restorePurchases();
-      if (success) {
-        await ref.read(currentUserProvider.notifier).setPlan(UserPlan.vip);
+      final manager = ref.read(premiumManagerProvider);
+      final result = await manager.restore();
+      if (result.success) {
+        await ref.read(currentUserProvider.notifier).refreshFromPremium();
         if (mounted) {
           _showSuccessOverlay();
           HapticService.medium();
@@ -527,7 +524,7 @@ class _ProScreenState extends ConsumerState<ProScreen>
   Future<void> _handleGoogleSignIn() async {
     HapticService.light();
     try {
-      final service = ref.read(googleAuthProvider);
+      final service = ref.read(googleDriveServiceProvider);
       await service.signIn();
     } catch (e) {
       if (mounted) {
@@ -539,7 +536,7 @@ class _ProScreenState extends ConsumerState<ProScreen>
   Future<void> _handleGoogleSignOut() async {
     HapticService.light();
     try {
-      final service = ref.read(googleAuthProvider);
+      final service = ref.read(googleDriveServiceProvider);
       await service.signOut();
     } catch (e) {
       if (mounted) {

lib/shared/widgets/pro_subscription_card.dart

@@ -3,8 +3,8 @@ import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:go_router/go_router.dart';
 import '../../core/l10n/locale_provider.dart';
 import '../../core/services/haptic_service.dart';
-import '../feature_flags/feature_flags_provider.dart';
-import '../providers/google_auth_provider.dart';
+import '../providers/google_drive_provider.dart';
+import '../providers/premium_provider.dart';
 
 class ProSubscriptionCard extends ConsumerWidget {
   const ProSubscriptionCard({super.key});
@@ -18,10 +18,9 @@ class ProSubscriptionCard extends ConsumerWidget {
   @override
   Widget build(BuildContext context, WidgetRef ref) {
     final s = ref.watch(stringsProvider);
-    final flags = ref.watch(featureFlagsProvider);
-    final isVip = flags.maxAccounts != 3;
-    final googleUserAsync = ref.watch(googleCurrentUserProvider);
-    final googleUser = googleUserAsync.value;
+    final isPremium = ref.watch(isPremiumProvider);
+    final driveUserAsync = ref.watch(googleDriveUserProvider);
+    final driveUser = driveUserAsync.value;
 
     return Container(
       padding: const EdgeInsets.symmetric(horizontal: 20, vertical: 24),
@@ -45,7 +44,9 @@ class ProSubscriptionCard extends ConsumerWidget {
                   borderRadius: BorderRadius.circular(12),
                 ),
                 child: Icon(
-                  isVip ? Icons.verified_rounded : Icons.workspace_premium_rounded,
+                  isPremium
+                      ? Icons.verified_rounded
+                      : Icons.workspace_premium_rounded,
                   color: Colors.white,
                   size: 28,
                 ),
@@ -57,80 +58,111 @@ class ProSubscriptionCard extends ConsumerWidget {
                   children: [
                     Text(
                       s.proTitle,
-                      style: Theme.of(context).textTheme.titleLarge?.copyWith(
-                            fontWeight: FontWeight.w900,
-                            color: Colors.white,
-                          ),
+                      style:
+                          Theme.of(context).textTheme.titleLarge?.copyWith(
+                                fontWeight: FontWeight.w900,
+                                color: Colors.white,
+                              ),
+                    ),
+                    const SizedBox(height: 4),
+                    Text(
+                      isPremium ? s.proActive : s.proSubtitle,
+                      style: isPremium
+                          ? Theme.of(context).textTheme.bodyMedium?.copyWith(
+                                color: Colors.white.withOpacity(0.9),
+                                fontWeight: FontWeight.w600,
+                              )
+                          : Theme.of(context).textTheme.bodySmall?.copyWith(
+                                color: Colors.white.withOpacity(0.7),
+                              ),
                     ),
-                    if (isVip) ...[
-                      const SizedBox(height: 4),
-                      Text(
-                        s.proActive,
-                        style: Theme.of(context).textTheme.bodyMedium?.copyWith(
-                              color: Colors.white.withOpacity(0.9),
-                              fontWeight: FontWeight.w600,
-                            ),
-                      ),
-                    ] else ...[
-                      const SizedBox(height: 4),
-                      Text(
-                        s.proSubtitle,
-                        style: Theme.of(context).textTheme.bodySmall?.copyWith(
-                              color: Colors.white.withOpacity(0.7),
-                            ),
-                      ),
-                    ],
                   ],
                 ),
               ),
             ],
           ),
           const SizedBox(height: 16),
-          Row(
-            children: [
-              Expanded(
-                child: OutlinedButton(
+          if (!isPremium) ...[
+            Row(
+              children: [
+                Expanded(
+                  child: OutlinedButton(
+                    onPressed: () {
+                      HapticService.light();
+                      context.push('/pro');
+                    },
+                    style: OutlinedButton.styleFrom(
+                      foregroundColor: Colors.white,
+                      side: BorderSide(
+                          color: Colors.white.withOpacity(0.4), width: 1.5),
+                      padding: const EdgeInsets.symmetric(vertical: 12),
+                      shape: RoundedRectangleBorder(
+                        borderRadius: BorderRadius.circular(12),
+                      ),
+                    ),
+                    child: Text(
+                      s.proAboutPro,
+                      style: const TextStyle(
+                          fontWeight: FontWeight.w700, fontSize: 15),
+                    ),
+                  ),
+                ),
+              ],
+            ),
+          ] else ...[
+            Row(
+              children: [
+                Expanded(
+                  child: OutlinedButton.icon(
+                    onPressed: () {
+                      HapticService.light();
+                      context.push('/backup');
+                    },
+                    icon: Icon(
+                      driveUser != null
+                          ? Icons.cloud_done_rounded
+                          : Icons.cloud_sync_rounded,
+                      color: Colors.white,
+                      size: 20,
+                    ),
+                    label: Text(s.backupSyncWithDrive),
+                    style: OutlinedButton.styleFrom(
+                      foregroundColor: Colors.white,
+                      side: BorderSide(
+                          color: Colors.white.withOpacity(0.4), width: 1.5),
+                      padding: const EdgeInsets.symmetric(vertical: 12),
+                      shape: RoundedRectangleBorder(
+                        borderRadius: BorderRadius.circular(12),
+                      ),
+                    ),
+                  ),
+                ),
+              ],
+            ),
+            if (driveUser == null) ...[
+              const SizedBox(height: 10),
+              SizedBox(
+                width: double.infinity,
+                child: OutlinedButton.icon(
                   onPressed: () {
                     HapticService.light();
-                    context.push('/pro');
+                    ref.read(googleDriveServiceProvider).signIn();
                   },
+                  icon: const Icon(Icons.login_rounded,
+                      color: Colors.white, size: 18),
+                  label: Text(s.proSignInGoogle),
                   style: OutlinedButton.styleFrom(
                     foregroundColor: Colors.white,
-                    side: BorderSide(color: Colors.white.withOpacity(0.4), width: 1.5),
-                    padding: const EdgeInsets.symmetric(vertical: 12),
+                    side: BorderSide(
+                        color: Colors.white.withOpacity(0.3), width: 1),
+                    padding: const EdgeInsets.symmetric(vertical: 10),
                     shape: RoundedRectangleBorder(
                       borderRadius: BorderRadius.circular(12),
                     ),
                   ),
-                  child: Text(
-                    s.proAboutPro,
-                    style: const TextStyle(fontWeight: FontWeight.w700, fontSize: 15),
-                  ),
                 ),
               ),
             ],
-          ),
-          if (isVip && googleUser == null) ...[
-            const SizedBox(height: 10),
-            SizedBox(
-              width: double.infinity,
-              child: OutlinedButton.icon(
-                onPressed: () {
-                  HapticService.light();
-                  ref.read(googleAuthProvider).signIn();
-                },
-                icon: const Icon(Icons.login_rounded, color: Colors.white, size: 18),
-                label: Text(s.proSignInGoogle),
-                style: OutlinedButton.styleFrom(
-                  foregroundColor: Colors.white,
-                  side: BorderSide(color: Colors.white.withOpacity(0.3), width: 1),
-                  padding: const EdgeInsets.symmetric(vertical: 10),
-                  shape: RoundedRectangleBorder(
-                    borderRadius: BorderRadius.circular(12),
-                  ),
-                ),
-              ),
-            ),
           ],
         ],
       ),