added local db

lib/presentation/sync/providers/sync_controller.dart

@@ -3,10 +3,28 @@ import 'package:flutter_riverpod/flutter_riverpod.dart';
 import '../../../app/providers.dart';
 import '../../../domain/entities/shift_report.dart';
 import '../../../domain/entities/sync_event.dart';
+import '../../../domain/repositories/sync_repository.dart';
 import '../../auth/providers/auth_controller.dart';
 import '../../pos/providers/catalog_providers.dart';
 
-/// Progress of a catalogue pull.
+/// Bumped after every import so catalogue-backed providers refetch.
+final catalogueVersionProvider = StateProvider<int>((ref) => 0);
+
+/// Bumped after every sale or sync so order-backed providers refetch.
+final orderVersionProvider = StateProvider<int>((ref) => 0);
+
+/// Whether products exist on this terminal. Billing is gated on it.
+final catalogueReadyProvider = Provider<bool>((ref) {
+  ref.watch(catalogueVersionProvider);
+  return ref.watch(syncRepositoryProvider).hasCatalogue;
+});
+
+final lastImportAtProvider = Provider<DateTime?>((ref) {
+  ref.watch(catalogueVersionProvider);
+  return ref.watch(syncRepositoryProvider).lastImportAt;
+});
+
+// ------------------------------------------------------- Morning: import
 sealed class ImportState {
   const ImportState();
 }
@@ -34,20 +52,6 @@ class ImportFailed extends ImportState {
   final String message;
 }
 
-/// Bumped after every successful import so catalogue providers refetch.
-final catalogueVersionProvider = StateProvider<int>((ref) => 0);
-
-/// Whether the terminal has products to sell. The POS is gated on this.
-final catalogueReadyProvider = Provider<bool>((ref) {
-  ref.watch(catalogueVersionProvider);
-  return ref.watch(syncRepositoryProvider).hasCatalogue;
-});
-
-final lastImportAtProvider = Provider<DateTime?>((ref) {
-  ref.watch(catalogueVersionProvider);
-  return ref.watch(syncRepositoryProvider).lastImportAt;
-});
-
 class CatalogueImportController extends StateNotifier<ImportState> {
   CatalogueImportController(this._ref) : super(const ImportIdle());
 
@@ -55,7 +59,6 @@ class CatalogueImportController extends StateNotifier<ImportState> {
 
   Future<bool> run() async {
     if (state is ImportRunning) return false;
-
     state = const ImportRunning(0, 'Starting…');
 
     final event = await _ref.read(syncRepositoryProvider).importCatalogue(
@@ -65,13 +68,11 @@ class CatalogueImportController extends StateNotifier<ImportState> {
         );
 
     if (event.status == SyncStatus.synced) {
-      // Force every catalogue-backed provider to refetch.
       _ref.read(catalogueVersionProvider.notifier).state++;
       _ref.invalidate(allProductsProvider);
       _ref.invalidate(visibleProductsProvider);
       _ref.invalidate(categoryCountsProvider);
       _ref.invalidate(lowStockProductsProvider);
-
       state = ImportDone(event);
       return true;
     }
@@ -79,8 +80,6 @@ class CatalogueImportController extends StateNotifier<ImportState> {
     state = ImportFailed(event.error ?? 'Import failed.');
     return false;
   }
-
-  void reset() => state = const ImportIdle();
 }
 
 final catalogueImportProvider =
@@ -88,69 +87,89 @@ final catalogueImportProvider =
   (ref) => CatalogueImportController(ref),
 );
 
-// ------------------------------------------------------------------ Events
-/// Bumped whenever the event log changes.
-final syncVersionProvider = StateProvider<int>((ref) => 0);
-
-final syncEventsProvider = Provider<List<SyncEvent>>((ref) {
-  ref.watch(syncVersionProvider);
-  ref.watch(catalogueVersionProvider);
-  return ref.watch(syncRepositoryProvider).events;
+// ---------------------------------------------------- Business hours: read
+/// Bills still held on this terminal at sync_status = 0.
+final unsyncedCountProvider = FutureProvider<int>((ref) {
+  ref.watch(orderVersionProvider);
+  return ref.watch(syncRepositoryProvider).unsyncedCount();
 });
 
-final hasUnsyncedProvider = Provider<bool>((ref) {
-  ref.watch(syncVersionProvider);
-  ref.watch(catalogueVersionProvider);
-  return ref.watch(syncRepositoryProvider).hasUnsyncedEvents;
-});
-
-/// Today's takings, recomputed from local sales on every change.
-final shiftReportProvider = Provider<ShiftReport>((ref) {
-  ref.watch(syncVersionProvider);
+/// Today's totals, read back from SQLite.
+final todayReportProvider = FutureProvider<ShiftReport>((ref) {
+  ref.watch(orderVersionProvider);
   final session = ref.watch(cashierSessionProvider);
   final user = ref.watch(currentUserProvider);
 
-  return ref.watch(syncRepositoryProvider).buildShiftReport(
-        businessDate: DateTime.now(),
+  return ref.watch(syncRepositoryProvider).todayReport(
         terminalId: session.terminalId,
         cashierName: user?.name ?? session.name,
       );
 });
 
-/// Drives the push button and the sign-out dialog.
-class ReportPushController extends StateNotifier<bool> {
-  ReportPushController(this._ref) : super(false);
+/// Per-order sync state for the events log.
+final orderSyncRowsProvider = FutureProvider<List<OrderSyncRow>>((ref) {
+  ref.watch(orderVersionProvider);
+  return ref.watch(syncRepositoryProvider).orderSyncRows();
+});
+
+final syncEventsProvider = Provider<List<SyncEvent>>((ref) {
+  ref.watch(orderVersionProvider);
+  ref.watch(catalogueVersionProvider);
+  return ref.watch(syncRepositoryProvider).events;
+});
+
+// ------------------------------------------------------ End of day: upload
+sealed class OrderSyncState {
+  const OrderSyncState();
+}
+
+class SyncIdle extends OrderSyncState {
+  const SyncIdle();
+}
+
+class SyncRunning extends OrderSyncState {
+  const SyncRunning(this.progress, this.stage);
+
+  final double progress;
+  final String stage;
+}
+
+class SyncFinished extends OrderSyncState {
+  const SyncFinished(this.outcome);
+
+  final SyncOutcome outcome;
+}
+
+class OrderSyncController extends StateNotifier<OrderSyncState> {
+  OrderSyncController(this._ref) : super(const SyncIdle());
 
   final Ref _ref;
 
-  /// Pushes today's report. Returns the resulting event so the caller can
-  /// tell the cashier whether it landed.
-  Future<SyncEvent> pushToday() async {
-    state = true;
-    try {
-      final report = _ref.read(shiftReportProvider);
-      final event =
-          await _ref.read(syncRepositoryProvider).pushShiftReport(report);
-      _ref.read(syncVersionProvider.notifier).state++;
-      return event;
-    } finally {
-      if (mounted) state = false;
+  bool get isRunning => state is SyncRunning;
+
+  /// Uploads every bill at sync_status = 0 and flips the accepted ones to 1.
+  Future<SyncOutcome> run() async {
+    if (isRunning) {
+      return const SyncOutcome(attempted: 0, uploaded: 0);
     }
+
+    state = const SyncRunning(0, 'Starting…');
+
+    final outcome = await _ref.read(syncRepositoryProvider).syncOrders(
+          onProgress: (progress, stage) {
+            if (mounted) state = SyncRunning(progress, stage);
+          },
+        );
+
+    _ref.read(orderVersionProvider.notifier).state++;
+    if (mounted) state = SyncFinished(outcome);
+    return outcome;
   }
 
-  Future<SyncEvent> retry(String eventId) async {
-    state = true;
-    try {
-      final event = await _ref.read(syncRepositoryProvider).retry(eventId);
-      _ref.read(syncVersionProvider.notifier).state++;
-      return event;
-    } finally {
-      if (mounted) state = false;
-    }
-  }
+  void reset() => state = const SyncIdle();
 }
 
-final reportPushProvider =
-    StateNotifierProvider<ReportPushController, bool>(
-  (ref) => ReportPushController(ref),
+final orderSyncProvider =
+    StateNotifierProvider<OrderSyncController, OrderSyncState>(
+  (ref) => OrderSyncController(ref),
 );