/**
 * IndexedStorage - A modern, localStorage-like API for IndexedDB operations
 */

export interface IndexedStorageConfig {
  /** Enable console logging for debugging (default: false) */
  enableLogging?: boolean;
}

export interface StorageManager {
  storage: {
    getItem(key: string): Promise<any>;
    setItem(key: string, value: any): Promise<void>;
    removeItem(key: string): Promise<void>;
    hasItem(key: string): Promise<boolean>;
    clear(): Promise<void>;
    getAllKeys(): Promise<string[]>;
    testAvailability(): Promise<boolean>;
  };
}

export interface IndexedDBManager {
  get(key: string): Promise<any>;
  save(key: string, data: any): Promise<void>;
  remove(key: string): Promise<void>;
  clear(): Promise<void>;
  getAllKeys(): Promise<string[]>;
  testAvailability(): Promise<boolean>;
}

export interface IndexedStorageAPI {
  /**
   * Configure IndexedStorage options
   * @param options - Configuration options
   * 
   * @example
   * // Enable logging for debugging
   * IndexedStorage.configure({ enableLogging: true });
   * 
   * // Disable logging (default)
   * IndexedStorage.configure({ enableLogging: false });
   */
  configure(options?: IndexedStorageConfig): void;

  /**
   * Get current configuration
   * @returns Current configuration object
   */
  getConfig(): IndexedStorageConfig;

  /**
   * Retrieve an item from storage
   * @param key - The key to retrieve
   * @returns The stored value or null if not found
   */
  getItem(key: string): Promise<any | null>;

  /**
   * Store an item in storage
   * @param key - The key to store under
   * @param value - The value to store (will be serialized)
   */
  setItem(key: string, value: any): Promise<void>;

  /**
   * Remove an item from storage
   * @param key - The key to remove
   */
  removeItem(key: string): Promise<void>;

  /**
   * Check if an item exists in storage
   * @param key - The key to check
   * @returns True if the key exists
   */
  hasItem(key: string): Promise<boolean>;

  /**
   * Clear all items from storage
   */
  clear(): Promise<void>;

  /**
   * Get all keys from storage
   * @returns Array of all keys
   */
  getAllKeys(): Promise<string[]>;

  /**
   * Get the number of items in storage
   * @returns Number of stored items
   */
  length(): Promise<number>;

  /**
   * Get a key by index (for iteration)
   * @param index - The index of the key
   * @returns The key at the specified index or null
   */
  key(index: number): Promise<string | null>;

  /**
   * Test if storage is available and working
   * @returns True if storage is available
   */
  isAvailable(): Promise<boolean>;

  /**
   * Iterate over all items in storage
   * @param callback - Function called for each item (key, value, index)
   */
  forEach(callback: (key: string, value: any, index: number) => void | Promise<void>): Promise<void>;

  /**
   * Get multiple items at once
   * @param keys - Array of keys to retrieve
   * @returns Object with key-value pairs
   */
  getMultiple(keys: string[]): Promise<Record<string, any>>;

  /**
   * Set multiple items at once
   * @param items - Object with key-value pairs to store
   */
  setMultiple(items: Record<string, any>): Promise<void>;

  /**
   * Remove multiple items at once
   * @param keys - Array of keys to remove
   */
  removeMultiple(keys: string[]): Promise<void>;
}

/**
 * Main IndexedStorage instance
 */
declare const IndexedStorage: IndexedStorageAPI;

/**
 * Storage manager composable
 */
export function useStorageManager(): StorageManager;

/**
 * IndexedDB composable
 */
export function useIndexedDB(): IndexedDBManager;

export default IndexedStorage;
export { IndexedStorage };