flutter-freaccess-hub/lib/shared/helpers/db_helper.dart

import 'dart:developer';

import 'package:flutter/foundation.dart';
import 'package:flutter/services.dart';
import 'package:path/path.dart';
import 'package:sqflite/sqflite.dart';

class DatabaseHelper {
  static final DatabaseHelper _instance = DatabaseHelper._internal();
  static Database? _database;

  factory DatabaseHelper() => _instance;

  DatabaseHelper._internal();

  Future<Database> get database async {
    if (_database != null) return _database!;
    _database = await _initDatabase();
    return _database!;
  }

  Future<void> _onUpgrade(Database db, int oldVersion, int newVersion) async {
    log('Upgrading database from version $oldVersion to $newVersion');

    // if (oldVersion < 2) {
    //   // await db.execute('ALTER TABLE keychain ADD COLUMN newColumn TEXT');
    // }
  }

  Future<void> _onDowngrade(Database db, int oldVersion, int newVersion) async {
    log('Downgrading database from version $oldVersion to $newVersion');
  }

  Future<void> _onConfigure(Database db) async {
    log('Configuring database...');
  }

  Future<Database> _initDatabase() async {
    final path = await _getDatabasePath();
    log('Database path: $path');
    return await openDatabase(
      path,
      version: 1,
      onCreate: _onCreate,
      onOpen: _onOpen,
      onUpgrade: _onUpgrade,
      onDowngrade: _onDowngrade,
      onConfigure: _onConfigure,
    ).catchError((error) {
      throw error;
    }).whenComplete(() => log('Database initialized'));
  }

  Future<void> _onCreate(Database db, int version) async {
    log('Creating tables...');

    await db.execute('''
            CREATE TABLE keychain (
            key TEXT,
            value TEXT,
            type TEXT,
            updateAt TEXT,
            resolvedAt TEXT,
            createdAt TEXT
          );
      ''');
// ----------------------------------------------
    await insert('devUUID', '', 'user');
    await insert('userUUID', '', 'user');
    await insert('userDevUUID', '', 'user');
    await insert('status', '', 'user');
    await insert('userName', '', 'user');
// ----------------------------------------------
    await insert('cliUUID', '', 'local');
    await insert('ownerUUID', '', 'local');
    await insert('cliName', '', 'local');
// ----------------------------------------------
    await insert('whatsapp', 'false', 'util');
    await insert('provisional', 'false', 'util');
    await insert('pets', 'false', 'util');
    await insert('local', 'false', 'util');
    await insert('notify', 'false', 'util');
    await insert('fingerprint', 'false', 'util');
    await insert('access', 'false', 'util');
    await insert('panic', 'false', 'util');
    await insert('person', 'false', 'util');
    await insert('requestOSnotification', 'false', 'util');
    await insert('petAmountRegister', '', 'local');
// ----------------------------------------------
    log('Tables created');
  }

  Future<void> _onOpen(Database db) async {
    log('Checking existing data...');
    await _checkExistingData(db);
  }

  Future<void> deleteDatabaseDB() async {
    final path = await _getDatabasePath();
    await deleteDatabase(path);
    log('Database deleted');
    _database = null;
  }

  Future<String> _getDatabasePath() async {
    final databasesPath = await getDatabasesPath();
    final path = join(databasesPath, 'database.db');
    log('Database path: $path');
    return path;
  }

  Future<void> _checkExistingData(Database db) async {
    try {
      final maps = await db.query('keychain');
      log('Existing data: $maps');
    } catch (error) {
      log('Error checking existing data: $error');
    }
  }

  Future<dynamic> get({String? key, String? field}) async {
    try {
      final db = await database;

      List<Map<String, dynamic>> queryResult;
      if (field != null && key != null) {
        queryResult = await db.query(
          'keychain',
          columns: [field],
          where: 'key = ?',
          whereArgs: [key],
        );
      } else if (field != null) {
        queryResult = await db.query(
          'keychain',
          columns: [field],
        );
      } else if (key != null) {
        field = 'value';

        queryResult = await db.query(
          'keychain',
          columns: [field],
          where: 'key = ?',
          whereArgs: [key],
        );
      } else {
        queryResult = await db.query('keychain');
      }

      log('Query result for key: $key, field: $field -> $queryResult');

      if (queryResult.isNotEmpty) {
        return queryResult.first[field];
      } else {
        return null;
      }
    } catch (error) {
      log('Error getting: $error');
      return null;
    }
  }

  Future<int> insert(String key, dynamic value, String? type) async {
    final db = await database;

    final Map<String, dynamic> data = {
      'key': key,
      'value': value.toString(),
      'type': type,
      'updateAt': DateTime.now().toIso8601String(),
      'resolvedAt': null,
      'createdAt': DateTime.now().toIso8601String(),
    };

    log('Inserting: $data');
    return await db.insert('keychain', data);
  }

  Future<int> update(String key, dynamic value, String? type) async {
    final db = await database;

    final Map<String, dynamic> data = {
      'key': key,
      if (value != null) 'value': value.toString(),
      if (type != null) 'type': type,
      'updateAt': DateTime.now().toIso8601String(),
      'resolvedAt': null,
      'createdAt': DateTime.now().toIso8601String(),
    };

    log('Updating: $data');
    return await db.update(
      'keychain',
      data,
      where: 'key = ?',
      whereArgs: [key],
    );
  }

  Future<int> clear(String key) async {
    final db = await database;

    log('Setting value of key: $key to empty string');
    return await db.update(
      'keychain',
      {'value': ''},
      where: 'key = ?',
      whereArgs: [key],
    );
  }

  Future<int> delete(String key) async {
    final db = await database;

    log('Deleting key: $key');
    return await db.delete(
      'keychain',
      where: 'key = ?',
      whereArgs: [key],
    );
  }

  Future<void> purge() async {
    final DatabaseHelper helper = DatabaseHelper();

    await helper.deleteDatabaseDB();
    await helper.database;
    await database;

    log('Purge');
  }
}