import 'package:hub/shared/helpers/base_storage.dart';
import 'package:hub/shared/services/keychain/keychain_database_delegate.dart';
import 'package:hub/shared/services/keychain/keychain_service.dart';
import 'package:hub/shared/services/license/license_database_delegate.dart';
import 'package:hub/shared/services/license/license_service.dart';
import 'package:sqflite/sqflite.dart';
import 'package:path/path.dart';
import 'dart:developer';

class DatabaseStorage implements BaseStorage {
  static final String _dbName = 'database.db';
  static final int _dbVersion = 2;

  static final DatabaseStorage instance = DatabaseStorage._internal();
  factory DatabaseStorage() => instance;
  DatabaseStorage._internal();

  static Database? _database;
  static Database get database {
    if (_database == null) {
      throw Exception('Database has not been initialized. Call init() first.');
    }
    return _database!;
  }

  static BaseStorage getInstanceByKey(String key) {
    if (KeychainStorageKey.values.map((e) => e.value).toList().contains(key)) {
      return KeychainDelegate.instance;
    }
    if (LicenseStorageKey.values.map((e) => e.value).toList().contains(key)) {
      return LicenseDelegate.instance;
    }
    throw Exception('Storage not found');
  }

  Future<void> init() async {
    if (_database != null && _database!.isOpen) return;
    _database = await openDatabase(
      join(await getDatabasesPath(), _dbName),
      version: _dbVersion,
      onCreate: _onCreate,
      onUpgrade: _onUpgrade,
      onDowngrade: _onDowngrade,
    );
  }

  Future<void> _onCreate(Database database, int version) async {
    log('Creating database...');
    await database.execute(KeychainDelegate.createTableQuery);
    await database.execute(LicenseDelegate.createTableQuery);
    await LicenseService.setupLicense(database);
  }

  Future<void> _onUpgrade(Database database, int oldVersion, int newVersion) async {
    log('Upgrading database from version $oldVersion to $newVersion...');
    if (oldVersion < 2) {
      await database.execute(LicenseDelegate.createTableQuery);
      await LicenseService.setupLicense(database);
    }
  }

  Future<void> _onDowngrade(Database database, int oldVersion, int newVersion) async {}

  @override
  Future<void> clearAll() async {
    await _database?.delete(KeychainDelegate.tableKeychain);
    await _database?.delete(LicenseDelegate.tableLicense);
    return;
  }

  @override
  Future<void> delete(String key) async {
    return await getInstanceByKey(key).delete(key);
  }

  @override
  Future<String?> get(String key) async {
    return await getInstanceByKey(key).get(key);
  }

  @override
  Future<void> set<T>(String key, T value) async {
    return await getInstanceByKey(key).set(key, value);
  }
}