import 'dart:developer';

import 'package:hub/shared/helpers/secure_storage_helper.dart';
import 'package:hub/shared/helpers/shared_preferences_storage_helper.dart';
import 'package:hub/shared/helpers/sqlite_storage_helper.dart';
import 'package:hub/shared/utils/cache_util.dart';

abstract class Storage {
  Future<void> set(String key, dynamic value);
  Future<dynamic> get(String key);
  Future<void> delete(String key);
}

class StorageData {
  final String key;
  final dynamic value;
  final StorageType type;

  StorageData(this.key, this.value, this.type);
}

enum StorageType { SecureStorage, SharedPreferences, SQLite3 }

class StorageManager {
  static final SecureStorageHelper _secureStorage = SecureStorageHelper();
  static final SharedPreferencesStorageHelper _sharedPreferences = SharedPreferencesStorageHelper();
  static final SQLiteStorageHelper _sqliteStorage = SQLiteStorageHelper();

  static Future<void> set(StorageData data) async {
    try {
      switch (data.type) {
        case StorageType.SecureStorage:
          await _secureStorage.set(data.key, data.value);
          break;
        case StorageType.SharedPreferences:
          await _sharedPreferences.set(data.key, data.value);
          break;
        case StorageType.SQLite3:
          await _sqliteStorage.set(data.key, data.value);
          
          break;
      }
    } catch (e) {
      log('Error setting data: $e');
    }
  }

  static Future<dynamic> get(StorageData data) async {
    try {
      var value = CacheUtil().get(data.key);
      if (value == null) {
        switch (data.type) {
          case StorageType.SecureStorage:
            value = await _secureStorage.get(data.key);
            break;
          case StorageType.SharedPreferences:
            value = await _sharedPreferences.get(data.key);
            break;
          case StorageType.SQLite3:
            value = await _sqliteStorage.get(data.key);
            break;
        }
        CacheUtil().set(data.key, value);
      }
      return value;
    } catch (e) {
      log('Error getting data: $e');
      return null;
    }
  }

  static Future<void> delete(StorageData data) async {
    try {
      switch (data.type) {
        case StorageType.SecureStorage:
          CacheUtil().delete(data.key);
          await _secureStorage.delete(data.key);
          break;
        case StorageType.SharedPreferences:
          await _sharedPreferences.delete(data.key);
          break;
        case StorageType.SQLite3:
          await _sqliteStorage.delete(data.key);
          break;
      }
    } catch (e) {
      log('Error deleting data: $e');
    }
  }

  static Future<void> purge() async {
    try {
      await _secureStorage.purge();
      await _sharedPreferences.purge();
      await _sqliteStorage.purge();
    } catch (e) {
      log('Error purging data: $e');
    }
  }
}

class StorageUtil {}