label_datasource.dart

import 'package:bb_mobile/core/labels/data/label_model.dart';
import 'package:bb_mobile/core/labels/domain/label_error.dart';
import 'package:bb_mobile/core/labels/label_system.dart';
import 'package:bb_mobile/core/storage/sqlite_database.dart';
import 'package:bb_mobile/core/utils/logger.dart';
import 'package:drift/drift.dart';

class LabelDatasource {
  final SqliteDatabase _sqlite;

  LabelDatasource({required SqliteDatabase sqlite}) : _sqlite = sqlite;

  Future<void> store(LabelModel label) async {
    await _sqlite.managers.labels.create(
      (l) => l(
        label: label.label,
        type: label.type,
        ref: label.ref,
        origin: Value(label.origin),
        spendable: Value(label.spendable),
      ),
    );
  }

  Future<void> batch(List<LabelModel> labels) async {
    final rows = labels.map((label) => label.toSqlite()).toList();
    await _sqlite.batch(
      (batch) => batch.insertAll(
        _sqlite.labels,
        rows,
        mode: InsertMode.insertOrReplace,
      ),
    );
  }

  Future<List<LabelModel>> fetchByLabel({required String label}) async {
    final labelModels = await _sqlite.managers.labels
        .filter((l) => l.label(label))
        .get();
    return labelModels.map((row) => LabelModel.fromSqlite(row)).toList();
  }

  Future<List<LabelModel>> fetchByRef(String ref) async {
    final labelModels = await _sqlite.managers.labels
        .filter((l) => l.ref(ref))
        .get();
    return labelModels.map((row) => LabelModel.fromSqlite(row)).toList();
  }

  Future<void> trashByLabel({required String label}) async {
    try {
      if (LabelSystem.isSystemLabel(label)) {
        throw const SystemLabelCannotBeDeletedError();
      }

      await _sqlite.managers.labels.filter((l) => l.label(label)).delete();
    } catch (e) {
      log.severe('$LabelDatasource: $e');
      rethrow;
    }
  }

  Future<void> trashByRef(String ref) async {
    await _sqlite.managers.labels.filter((l) => l.ref(ref)).delete();
  }

  Future<void> trashLabel(LabelModel label) async {
    try {
      if (LabelSystem.isSystemLabel(label.label)) {
        throw const SystemLabelCannotBeDeletedError();
      }

      await _sqlite.managers.labels
          .filter((l) => l.ref(label.ref) & l.label(label.label))
          .delete();
    } catch (e) {
      log.severe('$LabelDatasource: $e');
      rethrow;
    }
  }

  Future<List<LabelModel>> fetchAll() async {
    final labelModels = await _sqlite.managers.labels.get();
    return labelModels.map((row) => LabelModel.fromSqlite(row)).toList();
  }

  Future<List<String>> fetchDistinct() async {
    final rows = await (_sqlite.selectOnly(
      _sqlite.labels,
      distinct: true,
    )..addColumns([_sqlite.labels.label])).get();
    return rows.map((row) => row.read<String>(_sqlite.labels.label)!).toList();
  }

  Future<void> trashAll() async {
    await _sqlite.delete(_sqlite.labels).go();
  }
}