import 'package:shared_preferences/shared_preferences.dart';
class SettingsService {
  late final SharedPreferences _prefs;
  Future<void> init() async {
    _prefs = await SharedPreferences.getInstance();
  }
  // Read
  String? get theme => _prefs.getString('theme');
  bool get isDarkMode => _prefs.getBool('dark_mode') ?? false;
  int get launchCount => _prefs.getInt('launch_count') ?? 0;
  // Write
  Future<void> setTheme(String theme) => _prefs.setString('theme', theme);
  Future<void> setDarkMode(bool value) => _prefs.setBool('dark_mode', value);
  // Increment
  Future<void> incrementLaunchCount() async {
    final count = _prefs.getInt('launch_count') ?? 0;
    await _prefs.setInt('launch_count', count + 1);
  }
  // Remove
  Future<void> clear() => _prefs.clear();
}

import 'package:sqflite/sqflite.dart';
import 'package:path/path.dart';
class DatabaseHelper {
  static Database? _db;
  Future<Database> get database async {
    if (_db != null) return _db!;
    _db = await _initDb();
    return _db!;
  }
  Future<Database> _initDb() async {
    final path = join(await getDatabasesPath(), 'myapp.db');
    return openDatabase(
      path,
      version: 1,
      onCreate: (db, version) async {
        await db.execute('''
          CREATE TABLE notes (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            title TEXT NOT NULL,...)
        ''');
      },
    );
  }
}

class NoteRepository {
  final DatabaseHelper _dbHelper;
  NoteRepository(this._dbHelper);
  ...
}

Future<int> insert(Note note) async {
  final db = await _dbHelper.database;
  return db.insert('notes', note.toMap());
}

Future<int> update(Note note) async {
  final db = await _dbHelper.database;
  return db.update('notes', note.toMap(),
    where: 'id = ?', whereArgs: [note.id]);
}

Future<int> delete(int id) async {
  final db = await _dbHelper.database;
  return db.delete('notes', where: 'id = ?', whereArgs: [id]);
}

Future<List<Note>> search(String query) async {
  final db = await _dbHelper.database;
  final maps = await db.query('notes',
    where: 'title LIKE ? OR body LIKE ?',
    whereArgs: ['%$query%', '%$query%']);
  return maps.map((m) => Note.fromMap(m)).toList();
}

Future<List<Note>> getAll() async {
  final db = await _dbHelper.database;
  final maps = await db.query('notes', orderBy: 'created_at DESC');
  return maps.map((m) => Note.fromMap(m)).toList();
}

Future<void> _v2Migration(Database db) async {
  await db.execute('ALTER TABLE notes ADD COLUMN is_encrypted INTEGER DEFAULT 0');
}

Future<void> _v3Migration(Database db) async {
  await db.execute('ALTER TABLE notes ADD COLUMN category TEXT DEFAULT "general"');
}

openDatabase(
  path,
  version: 3,
  onCreate: (db, version) async {
    await db.execute('''
      CREATE TABLE notes (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        title TEXT NOT NULL,
        body TEXT NOT NULL,
        created_at INTEGER NOT NULL
      )
    ''');
    // Run all migrations for fresh install
    await _v2Migration(db);
    await _v3Migration(db);
  },
  onUpgrade: (db, oldVersion, newVersion) async {
    if (oldVersion < 2) await _v2Migration(db);
    if (oldVersion < 3) await _v3Migration(db);
  },
);

// Initialize
await Hive.initFlutter();
// Register adapter (for custom objects)
Hive.registerAdapter(NoteAdapter());
// Open a box
final notesBox = await Hive.openBox<Note>('notes');
// CRUD
await notesBox.put('key1', note);          // Create/Update
final note = notesBox.get('key1');          // Read
await notesBox.delete('key1');              // Delete
final allNotes = notesBox.values.toList();  // Read all
// Listen to changes
notesBox.watch().listen((event) {
  print('Box changed: ${event.key}');
});

import 'package:flutter_secure_storage/flutter_secure_storage.dart';
class SecureStorageService {
  static const _storage = FlutterSecureStorage(
    aOptions: AndroidOptions(encryptedSharedPreferences: true),
    iOptions: IOSOptions(accessibility: KeychainAccessibility.first_unlock),
  );
  static Future<void> saveToken(String token) => _storage.write(key: 'auth_token', value: token);
  static Future<String?> getToken() => _storage.read(key: 'auth_token');
  static Future<void> deleteToken() => _storage.delete(key: 'auth_token');
  static Future<void> saveCredentials({
    required String email, required String password,
  }) async {
    await _storage.write(key: 'user_email', value: email);
    await _storage.write(key: 'user_password', value: password);
  }
  static Future<void> clearAll() => _storage.deleteAll();
}

import 'dart:io';
import 'package:path_provider/path_provider.dart';
class FileService {
  Future<String> get _localPath async {
    final directory = await getApplicationDocumentsDirectory();
    return directory.path;
  }
  Future<File> get _localFile async {
    final path = await _localPath;
    return File('$path/counter.txt');
  }
  Future<String> readCounter() async {
    try {
      final file = await _localFile;
      return await file.readAsString();
    } catch (e) {
      return '0';
    }
  }
  Future<File> writeCounter(int counter) async {
    final file = await _localFile;
    return file.writeAsString('$counter');
  }
}