notas/lib/data/app_database.dart

import 'dart:io';

import 'package:drift/drift.dart';
import 'package:drift/native.dart';
import 'package:path/path.dart' as p;
import 'package:path_provider/path_provider.dart';

part 'app_database.g.dart';

@DataClassName('DbCategory')
class Categories extends Table {
  TextColumn get uuid => text().unique()();
  TextColumn get encryptedName => text().named('encrypted_name')();
  IntColumn get serverVersion =>
      integer().named('server_version').withDefault(const Constant(0))();
  BoolColumn get isDeleted =>
      boolean().named('is_deleted').withDefault(const Constant(false))();
  DateTimeColumn get updatedAt => dateTime().named('updated_at')();

  @override
  Set<Column> get primaryKey => {uuid};
}

@DataClassName('DbNote')
class Notes extends Table {
  IntColumn get id => integer().autoIncrement()();
  TextColumn get uuid => text().unique()();
  TextColumn get title => text()();
  TextColumn get body => text()();
  DateTimeColumn get createdAt => dateTime().named('created_at')();
  DateTimeColumn get updatedAt => dateTime().named('updated_at')();
  IntColumn get sortIndex => integer().named('sort_index')();
  IntColumn get serverVersion =>
      integer().named('server_version').withDefault(const Constant(0))();
  BoolColumn get isDeleted =>
      boolean().named('is_deleted').withDefault(const Constant(false))();
  TextColumn get categoryId => text().nullable().named('category_id')();
}

@DriftDatabase(tables: [Notes, Categories])
class AppDatabase extends _$AppDatabase {
  @override
  int get schemaVersion => 1;
  AppDatabase({required String encryptionKey})
    : super(_openConnection(encryptionKey));

  // ========== Categories ==========
  Future<List<DbCategory>> getAllCategories() {
    return (select(categories)..where((c) => c.isDeleted.equals(false))).get();
  }

  Future<int> upsertCategory(CategoriesCompanion category) {
    return into(categories).insertOnConflictUpdate(category);
  }

  Future<void> deleteCategory(String uuid) {
    return (update(categories)..where((c) => c.uuid.equals(uuid))).write(
      CategoriesCompanion(isDeleted: Value(true)),
    );
  }

  // ========== Notes ==========
  Future<List<DbNote>> getAllNotes() {
    return (select(notes)
          ..orderBy([(note) => OrderingTerm(expression: note.sortIndex)])
          ..where((n) => n.isDeleted.equals(false)))
        .get();
  }

  Future<int> insertNoteAtTop(NotesCompanion note) {
    return transaction(() async {
      await customStatement(
        'UPDATE notes SET sort_index = sort_index + 1 WHERE is_deleted = 0',
      );
      return into(notes).insert(note.copyWith(sortIndex: const Value<int>(0)));
    });
  }

  Future<void> replaceAllNotes(List<NotesCompanion> noteList) {
    return transaction(() async {
      await (delete(notes)..where((n) => n.isDeleted.equals(false))).go();

      for (final NotesCompanion note in noteList) {
        await into(notes).insert(note);
      }
    });
  }

  Future<void> updateNoteRow(DbNote note) {
    return update(notes).replace(note);
  }

  Future<void> deleteNote(int id, int removedIndex) async {
    await (update(notes)..where((n) => n.id.equals(id))).write(
      NotesCompanion(
        isDeleted: const Value(true),
        updatedAt: Value(DateTime.now()),
      ),
    );

    await customStatement(
      'UPDATE notes SET sort_index = sort_index - 1 WHERE sort_index > ? AND is_deleted = 0',
      [removedIndex],
    );
  }

  Future<void> deleteNoteAndShift({
    required int id,
    required int removedIndex,
  }) {
    return deleteNote(id, removedIndex);
  }

  Future<void> permanentlyDeleteNote(int id) async {
    await (update(notes)..where((n) => n.id.equals(id))).write(
      NotesCompanion(
        title: const Value(''),
        body: const Value(''),
        categoryId: const Value(null),
        isDeleted: const Value(true),
        updatedAt: Value(DateTime.now()),
      ),
    );
  }

  Future<void> moveNote({
    required int id,
    required int oldIndex,
    required int newIndex,
  }) {
    if (oldIndex == newIndex) {
      return Future<void>.value();
    }

    return transaction(() async {
      final List<DbNote> all = await (select(notes)
            ..where((n) => n.isDeleted.equals(false)))
          .get();

      final int count = all.length;
      if (count == 0) {
        return;
      }

      final int maxIndex = count - 1;

      final int safeOld = oldIndex.clamp(0, maxIndex);
      final int safeNew = newIndex.clamp(0, maxIndex);

      if (safeOld == safeNew) {
        return;
      }

      if (safeOld < safeNew) {
        await customStatement(
          'UPDATE notes SET sort_index = sort_index - 1 WHERE sort_index > ? AND sort_index <= ? AND is_deleted = 0',
          [safeOld, safeNew],
        );
      } else {
        await customStatement(
          'UPDATE notes SET sort_index = sort_index + 1 WHERE sort_index >= ? AND sort_index < ? AND is_deleted = 0',
          [safeNew, safeOld],
        );
      }

      await (update(notes)..where((n) => n.id.equals(id))).write(
        NotesCompanion(
          sortIndex: Value<int>(safeNew),
          updatedAt: Value<DateTime>(DateTime.now()),
        ),
      );
    });
  }

  Future<List<DbNote>> getNotesChangedSince(DateTime since) {
    return (select(
      notes,
    )..where((n) => n.updatedAt.isBiggerThanValue(since))).get();
  }

  Future<List<DbNote>> getDeletedNotes() {
    return (select(notes)
          ..where((n) => n.isDeleted.equals(true) & n.title.isNotValue('') & n.body.isNotValue('')))
        .get();
  }

  Future<List<DbCategory>> getCategoriesChangedSince(DateTime since) {
    return (select(
      categories,
    )..where((c) => c.updatedAt.isBiggerThanValue(since))).get();
  }

  // ========== Sync helpers ==========
  Future<List<DbNote>> getUnsyncedNotes() {
    return (select(notes)
          ..where((n) => n.isDeleted.equals(true) | n.serverVersion.equals(0)))
        .get();
  }

  Future<List<DbCategory>> getUnsyncedCategories() {
    return (select(categories)
          ..where((c) => c.isDeleted.equals(true) | c.serverVersion.equals(0)))
        .get();
  }
}

LazyDatabase _openConnection(String encryptionKey) {
  return LazyDatabase(() async {
    final Directory supportDir = await getApplicationSupportDirectory();
    final File file = File(p.join(supportDir.path, 'notes.sqlite'));

    return NativeDatabase(
      file,
      setup: (database) {
        final String escapedKey = encryptionKey.replaceAll("'", "''");

        // sqlite3mc can emulate SQLCipher file format for compatibility.
        database.execute("PRAGMA cipher = 'sqlcipher'");
        database.execute('PRAGMA legacy = 4');
        database.execute("PRAGMA key = '$escapedKey'");
      },
    );
  });
}