rn-app/utils/storageManager.ts

/**
 * 统一存储管理器
 * 
 * 提供统一的接口来使用 localStorage (AsyncStorage) 或 sessionStorage
 * 
 * 使用场景：
 * - localStorage: 持久化数据，应用重启后仍然存在
 * - sessionStorage: 临时数据，应用重启后丢失
 * 
 * 示例：
 * ```typescript
 * // 使用 localStorage（默认）
 * await StorageManager.set('user', userData);
 * 
 * // 使用 sessionStorage
 * await StorageManager.set('temp', tempData, { type: 'session' });
 * 
 * // 获取数据（自动从正确的存储中读取）
 * const user = await StorageManager.get('user');
 * const temp = await StorageManager.get('temp', { type: 'session' });
 * ```
 */

import Storage from './storage';
import SessionStorage from './sessionStorage';

/**
 * 存储类型
 */
export type StorageType = 'local' | 'session';

/**
 * 存储选项
 */
export interface StorageOptions {
  /**
   * 存储类型
   * - 'local': 持久化存储（AsyncStorage）
   * - 'session': 会话存储（内存）
   */
  type?: StorageType;
}

/**
 * 统一存储管理器
 */
class StorageManager {
  /**
   * 存储字符串
   */
  static async setString(
    key: string,
    value: string,
    options: StorageOptions = {}
  ): Promise<void> {
    const { type = 'local' } = options;

    if (type === 'session') {
      SessionStorage.setString(key, value);
    } else {
      await Storage.setString(key, value);
    }
  }

  /**
   * 获取字符串
   */
  static async getString(
    key: string,
    options: StorageOptions = {}
  ): Promise<string | null> {
    const { type = 'local' } = options;

    if (type === 'session') {
      return SessionStorage.getString(key);
    } else {
      return await Storage.getString(key);
    }
  }

  /**
   * 存储对象
   */
  static async setObject<T>(
    key: string,
    value: T,
    options: StorageOptions = {}
  ): Promise<void> {
    const { type = 'local' } = options;

    if (type === 'session') {
      SessionStorage.setObject(key, value);
    } else {
      await Storage.setObject(key, value);
    }
  }

  /**
   * 获取对象
   */
  static async getObject<T>(
    key: string,
    options: StorageOptions = {}
  ): Promise<T | null> {
    const { type = 'local' } = options;

    if (type === 'session') {
      return SessionStorage.getObject<T>(key);
    } else {
      return await Storage.getObject<T>(key);
    }
  }

  /**
   * 删除指定键
   */
  static async remove(key: string, options: StorageOptions = {}): Promise<void> {
    const { type = 'local' } = options;

    if (type === 'session') {
      SessionStorage.remove(key);
    } else {
      await Storage.remove(key);
    }
  }

  /**
   * 清空指定类型的所有存储
   */
  static async clear(options: StorageOptions = {}): Promise<void> {
    const { type = 'local' } = options;

    if (type === 'session') {
      SessionStorage.clear();
    } else {
      await Storage.clear();
    }
  }

  /**
   * 获取所有键名
   */
  static async getAllKeys(options: StorageOptions = {}): Promise<string[]> {
    const { type = 'local' } = options;

    if (type === 'session') {
      return SessionStorage.getAllKeys();
    } else {
      return await Storage.getAllKeys();
    }
  }

  /**
   * 检查键是否存在
   */
  static async has(key: string, options: StorageOptions = {}): Promise<boolean> {
    const { type = 'local' } = options;

    if (type === 'session') {
      return SessionStorage.has(key);
    } else {
      const value = await Storage.getString(key);
      return value !== null;
    }
  }

  /**
   * 批量获取
   */
  static async multiGet(
    keys: string[],
    options: StorageOptions = {}
  ): Promise<[string, string | null][]> {
    const { type = 'local' } = options;

    if (type === 'session') {
      return SessionStorage.multiGet(keys);
    } else {
      return await Storage.multiGet(keys);
    }
  }

  /**
   * 批量设置
   */
  static async multiSet(
    keyValuePairs: [string, string][],
    options: StorageOptions = {}
  ): Promise<void> {
    const { type = 'local' } = options;

    if (type === 'session') {
      SessionStorage.multiSet(keyValuePairs);
    } else {
      await Storage.multiSet(keyValuePairs);
    }
  }

  /**
   * 批量删除
   */
  static async multiRemove(
    keys: string[],
    options: StorageOptions = {}
  ): Promise<void> {
    const { type = 'local' } = options;

    if (type === 'session') {
      SessionStorage.multiRemove(keys);
    } else {
      await Storage.multiRemove(keys);
    }
  }

  /**
   * 获取存储大小（仅 session storage）
   */
  static getSize(options: StorageOptions = {}): number {
    const { type = 'local' } = options;

    if (type === 'session') {
      return SessionStorage.length;
    } else {
      // AsyncStorage 不支持直接获取大小
      return -1;
    }
  }

  /**
   * 清空所有存储（local + session）
   */
  static async clearAll(): Promise<void> {
    await Storage.clear();
    SessionStorage.clear();
    if (__DEV__) {
      console.log('🗑️ All storage cleared (local + session)');
    }
  }
}

export default StorageManager;