rework one-time migrations

lib/services/changelog_service.dart

@@ -1,9 +1,11 @@
 import 'dart:convert';
 import 'package:flutter/foundation.dart';
+import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
 import 'package:shared_preferences/shared_preferences.dart';
 import 'version_service.dart';
 import '../app_state.dart';
+import '../migrations.dart';
 
 /// Service for managing changelog data and first launch detection
 class ChangelogService {
@@ -207,6 +209,10 @@ class ChangelogService {
       versionsNeedingMigration.add('1.5.3');
     }
     
+    if (needsMigration(lastSeenVersion, currentVersion, '1.6.3')) {
+      versionsNeedingMigration.add('1.6.3');
+    }
+    
     // Future versions can be added here
     // if (needsMigration(lastSeenVersion, currentVersion, '2.0.0')) {
     //   versionsNeedingMigration.add('2.0.0');
@@ -262,31 +268,9 @@ class ChangelogService {
   bool get isInitialized => _initialized;
 
   /// Run a specific migration by version number
-  Future<void> runMigration(String version, AppState appState) async {
+  Future<void> runMigration(String version, AppState appState, BuildContext? context) async {
     debugPrint('[ChangelogService] Running $version migration');
-    
-    switch (version) {
-      case '1.3.1':
-        // Enable network status indicator for all existing users
-        await appState.setNetworkStatusIndicatorEnabled(true);
-        debugPrint('[ChangelogService] 1.3.1 migration completed: enabled network status indicator');
-        break;
-        
-      case '1.5.3':
-        // Migrate upload queue to new two-stage changeset system
-        await appState.migrateUploadQueueToTwoStageSystem();
-        debugPrint('[ChangelogService] 1.5.3 migration completed: migrated upload queue to two-stage system');
-        break;
-        
-      // Future migrations can be added here
-      // case '2.0.0':
-      //   await appState.doSomethingNew();
-      //   debugPrint('[ChangelogService] 2.0.0 migration completed');
-      //   break;
-      
-      default:
-        debugPrint('[ChangelogService] Unknown migration version: $version');
-    }
+    await OneTimeMigrations.runMigration(version, appState, context);
   }
 
   /// Check if a migration should run

lib/services/nuclear_reset_service.dart

@@ -0,0 +1,160 @@
+import 'dart:io';
+import 'package:flutter/foundation.dart';
+import 'package:flutter/services.dart';
+import 'package:path_provider/path_provider.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'version_service.dart';
+
+/// Nuclear reset service - clears ALL app data when migrations fail.
+/// This is the "big hammer" approach for when something goes seriously wrong.
+class NuclearResetService {
+  static final NuclearResetService _instance = NuclearResetService._();
+  factory NuclearResetService() => _instance;
+  NuclearResetService._();
+
+  /// Completely clear all app data - SharedPreferences, files, caches, everything.
+  /// After this, the app should behave exactly like a fresh install.
+  static Future<void> clearEverything() async {
+    try {
+      debugPrint('[NuclearReset] Starting complete app data wipe...');
+
+      // Clear ALL SharedPreferences
+      await _clearSharedPreferences();
+
+      // Clear ALL files in app directories
+      await _clearFileSystem();
+
+      debugPrint('[NuclearReset] Complete app data wipe finished');
+    } catch (e) {
+      // Even the nuclear option can fail, but we can't do anything about it
+      debugPrint('[NuclearReset] Error during nuclear reset: $e');
+    }
+  }
+
+  /// Clear all SharedPreferences data
+  static Future<void> _clearSharedPreferences() async {
+    try {
+      final prefs = await SharedPreferences.getInstance();
+      await prefs.clear();
+      debugPrint('[NuclearReset] Cleared SharedPreferences');
+    } catch (e) {
+      debugPrint('[NuclearReset] Failed to clear SharedPreferences: $e');
+    }
+  }
+
+  /// Clear all files and directories in app storage
+  static Future<void> _clearFileSystem() async {
+    try {
+      // Clear Documents directory (offline areas, etc.)
+      await _clearDirectory(() => getApplicationDocumentsDirectory(), 'Documents');
+      
+      // Clear Cache directory (tile cache, etc.)
+      await _clearDirectory(() => getTemporaryDirectory(), 'Cache');
+      
+      // Clear Support directory if it exists (iOS/macOS)
+      if (!kIsWeb && (Platform.isIOS || Platform.isMacOS)) {
+        await _clearDirectory(() => getApplicationSupportDirectory(), 'Support');
+      }
+      
+    } catch (e) {
+      debugPrint('[NuclearReset] Failed to clear file system: $e');
+    }
+  }
+
+  /// Clear a specific directory, with error handling
+  static Future<void> _clearDirectory(
+    Future<Directory> Function() getDirFunc,
+    String dirName,
+  ) async {
+    try {
+      final dir = await getDirFunc();
+      if (dir.existsSync()) {
+        await dir.delete(recursive: true);
+        debugPrint('[NuclearReset] Cleared $dirName directory');
+      }
+    } catch (e) {
+      debugPrint('[NuclearReset] Failed to clear $dirName directory: $e');
+    }
+  }
+
+  /// Generate error report information (safely, with fallbacks)
+  static Future<String> generateErrorReport(Object error, StackTrace? stackTrace) async {
+    final buffer = StringBuffer();
+    
+    // Basic error information (always include this)
+    buffer.writeln('MIGRATION FAILURE ERROR REPORT');
+    buffer.writeln('Generated: ${DateTime.now().toIso8601String()}');
+    buffer.writeln('');
+    buffer.writeln('Error: $error');
+    
+    if (stackTrace != null) {
+      buffer.writeln('');
+      buffer.writeln('Stack trace:');
+      buffer.writeln(stackTrace.toString());
+    }
+    
+    // Try to add enrichment data, but don't fail if it doesn't work
+    await _addEnrichmentData(buffer);
+    
+    return buffer.toString();
+  }
+
+  /// Add device/app information to error report (with extensive error handling)
+  static Future<void> _addEnrichmentData(StringBuffer buffer) async {
+    try {
+      buffer.writeln('');
+      buffer.writeln('--- System Information ---');
+      
+      // App version (should always work)
+      try {
+        buffer.writeln('App Version: ${VersionService().version}');
+      } catch (e) {
+        buffer.writeln('App Version: [Failed to get version: $e]');
+      }
+      
+      // Platform information
+      try {
+        if (!kIsWeb) {
+          buffer.writeln('Platform: ${Platform.operatingSystem}');
+          buffer.writeln('OS Version: ${Platform.operatingSystemVersion}');
+        } else {
+          buffer.writeln('Platform: Web');
+        }
+      } catch (e) {
+        buffer.writeln('Platform: [Failed to get platform info: $e]');
+      }
+      
+      // Flutter/Dart information
+      try {
+        buffer.writeln('Flutter Mode: ${kDebugMode ? 'Debug' : kProfileMode ? 'Profile' : 'Release'}');
+      } catch (e) {
+        buffer.writeln('Flutter Mode: [Failed to get mode: $e]');
+      }
+      
+      // Previous version (if available)
+      try {
+        final prefs = await SharedPreferences.getInstance();
+        final lastVersion = prefs.getString('last_seen_version');
+        buffer.writeln('Previous Version: ${lastVersion ?? 'Unknown (fresh install?)'}');
+      } catch (e) {
+        buffer.writeln('Previous Version: [Failed to get: $e]');
+      }
+      
+    } catch (e) {
+      // If enrichment completely fails, just note it
+      buffer.writeln('');
+      buffer.writeln('--- System Information ---');
+      buffer.writeln('[Failed to gather system information: $e]');
+    }
+  }
+
+  /// Copy text to clipboard (safely)
+  static Future<void> copyToClipboard(String text) async {
+    try {
+      await Clipboard.setData(ClipboardData(text: text));
+      debugPrint('[NuclearReset] Copied error report to clipboard');
+    } catch (e) {
+      debugPrint('[NuclearReset] Failed to copy to clipboard: $e');
+    }
+  }
+}