import { PlayerData, GameResult } from '../core/types';

// Storage keys
const STORAGE_KEYS = {
  PLAYER_DATA: '@games_library_player_data',
  GAME_RESULTS: '@games_library_game_results',
  SETTINGS: '@games_library_settings',
  CACHE: '@games_library_cache'
};

// Simple in-memory storage fallback
class MemoryStorage {
  private data = new Map<string, string>();

  async getItem(key: string): Promise<string | null> {
    return this.data.get(key) || null;
  }

  async setItem(key: string, value: string): Promise<void> {
    this.data.set(key, value);
  }

  async removeItem(key: string): Promise<void> {
    this.data.delete(key);
  }

  async clear(): Promise<void> {
    this.data.clear();
  }

  async getAllKeys(): Promise<string[]> {
    return Array.from(this.data.keys());
  }
}

// Storage interface
export interface StorageService {
  getPlayerData(): Promise<PlayerData | null>;
  savePlayerData(data: PlayerData): Promise<void>;
  getGameResults(): Promise<GameResult[]>;
  saveGameResult(result: GameResult): Promise<void>;
  getSettings(): Promise<Record<string, any>>;
  saveSettings(settings: Record<string, any>): Promise<void>;
  clearAll(): Promise<void>;
}

// Default storage implementation
export class DefaultStorageService implements StorageService {
  private storage: MemoryStorage;

  constructor() {
    this.storage = new MemoryStorage();
  }

  async getPlayerData(): Promise<PlayerData | null> {
    try {
      const data = await this.storage.getItem(STORAGE_KEYS.PLAYER_DATA);
      return data ? JSON.parse(data) : null;
    } catch (error) {
      console.warn('Failed to get player data:', error);
      return null;
    }
  }

  async savePlayerData(data: PlayerData): Promise<void> {
    try {
      await this.storage.setItem(STORAGE_KEYS.PLAYER_DATA, JSON.stringify(data));
    } catch (error) {
      console.warn('Failed to save player data:', error);
    }
  }

  async getGameResults(): Promise<GameResult[]> {
    try {
      const data = await this.storage.getItem(STORAGE_KEYS.GAME_RESULTS);
      return data ? JSON.parse(data) : [];
    } catch (error) {
      console.warn('Failed to get game results:', error);
      return [];
    }
  }

  async saveGameResult(result: GameResult): Promise<void> {
    try {
      const results = await this.getGameResults();
      results.push(result);
      await this.storage.setItem(STORAGE_KEYS.GAME_RESULTS, JSON.stringify(results));
    } catch (error) {
      console.warn('Failed to save game result:', error);
    }
  }

  async getSettings(): Promise<Record<string, any>> {
    try {
      const data = await this.storage.getItem(STORAGE_KEYS.SETTINGS);
      return data ? JSON.parse(data) : {};
    } catch (error) {
      console.warn('Failed to get settings:', error);
      return {};
    }
  }

  async saveSettings(settings: Record<string, any>): Promise<void> {
    try {
      await this.storage.setItem(STORAGE_KEYS.SETTINGS, JSON.stringify(settings));
    } catch (error) {
      console.warn('Failed to save settings:', error);
    }
  }

  async clearAll(): Promise<void> {
    try {
      await this.storage.clear();
    } catch (error) {
      console.warn('Failed to clear storage:', error);
    }
  }
}

// Export default instance
export const storageService = new DefaultStorageService();