import { Platform } from 'react-native';
import {
  SessionType,
  type ISession,
} from '@multiplayer-app/session-recorder-common';
import { logger } from '../utils';
import type { SessionState } from '../types';

// Safe import for AsyncStorage with web fallback
let AsyncStorage: any = null;
const isWeb = Platform.OS === 'web';

if (!isWeb) {
  try {
    AsyncStorage = require('@react-native-async-storage/async-storage').default;
  } catch (error) {
    console.warn('AsyncStorage not available:', error);
  }
} else {
  // Web fallback using localStorage
  AsyncStorage = {
    getItem: (_key: string) => Promise.resolve(null), // Simplified for web
    setItem: (_key: string, _value: string) => Promise.resolve(undefined),
    removeItem: (_key: string) => Promise.resolve(undefined),
    multiRemove: (_keys: string[]) => Promise.resolve(undefined),
  };
}

interface CacheData {
  sessionId: string | null;
  sessionType: SessionType | null;
  sessionState: SessionState | null;
  sessionObject: ISession | null;
  floatingButtonPosition: { x: number; y: number } | null;
}

export class StorageService {
  private static readonly SESSION_ID_KEY = 'session_id';
  private static readonly SESSION_TYPE_KEY = 'session_type';
  private static readonly SESSION_STATE_KEY = 'session_state';
  private static readonly SESSION_OBJECT_KEY = 'session_object';
  private static readonly FLOATING_BUTTON_POSITION_KEY =
    'floating_button_position';

  private static cache: CacheData = {
    sessionId: null,
    sessionType: null,
    sessionState: null,
    sessionObject: null,
    floatingButtonPosition: null,
  };

  private static cacheInitialized = false;
  private static instance: StorageService | null = null;
  private static positionSaveTimeout: any | null = null;

  private constructor() {
    // Private constructor for singleton
  }

  static getInstance(): StorageService {
    if (!StorageService.instance) {
      StorageService.instance = new StorageService();
      StorageService.initialize();
    }
    return StorageService.instance;
  }

  private static async initializeCache(): Promise<void> {
    if (StorageService.cacheInitialized) return;

    try {
      const [
        sessionId,
        sessionType,
        sessionState,
        sessionObject,
        floatingButtonPosition,
      ] = await Promise.all([
        AsyncStorage.getItem(StorageService.SESSION_ID_KEY),
        AsyncStorage.getItem(StorageService.SESSION_TYPE_KEY),
        AsyncStorage.getItem(StorageService.SESSION_STATE_KEY),
        AsyncStorage.getItem(StorageService.SESSION_OBJECT_KEY),
        AsyncStorage.getItem(StorageService.FLOATING_BUTTON_POSITION_KEY),
      ]);

      StorageService.cache = {
        sessionId,
        sessionType: sessionType as SessionType | null,
        sessionState: sessionState as SessionState | null,
        sessionObject: sessionObject ? JSON.parse(sessionObject) : null,
        floatingButtonPosition: floatingButtonPosition
          ? JSON.parse(floatingButtonPosition)
          : null,
      };
      StorageService.cacheInitialized = true;
    } catch (error) {
      // Failed to initialize cache - silently continue
      StorageService.cacheInitialized = true; // Mark as initialized to prevent retries
    }
  }

  saveSessionId(sessionId: string): void {
    try {
      StorageService.cache.sessionId = sessionId;
      AsyncStorage.setItem(StorageService.SESSION_ID_KEY, sessionId).catch(
        (_error: any) => {
          // Failed to persist session ID - silently continue
        }
      );
    } catch (error) {
      // Failed to save session ID - silently continue
      throw error;
    }
  }

  getSessionId(): string | null {
    return StorageService.cache.sessionId;
  }

  saveSessionType(sessionType: SessionType): void {
    try {
      StorageService.cache.sessionType = sessionType;
      AsyncStorage.setItem(StorageService.SESSION_TYPE_KEY, sessionType).catch(
        (_error: any) => {
          // Failed to persist session type - silently continue
        }
      );
    } catch (error) {
      // Failed to save session type - silently continue
      throw error;
    }
  }

  getSessionType(): SessionType | null {
    return StorageService.cache.sessionType;
  }

  saveSessionState(state: SessionState): void {
    try {
      StorageService.cache.sessionState = state;

      AsyncStorage.setItem(StorageService.SESSION_STATE_KEY, state).catch(
        (_error: any) => {
          // Failed to persist session state - silently continue
        }
      );
    } catch (error) {
      // Failed to save session state - silently continue
      throw error;
    }
  }

  getSessionState(): SessionState | null {
    return StorageService.cache.sessionState;
  }

  saveSessionObject(session: ISession): void {
    try {
      StorageService.cache.sessionObject = session;
      AsyncStorage.setItem(
        StorageService.SESSION_OBJECT_KEY,
        JSON.stringify(session)
      ).catch((_error: any) => {
        // Failed to persist session object - silently continue
      });
    } catch (error) {
      // Failed to save session object - silently continue
      throw error;
    }
  }

  getSessionObject(): ISession | null {
    return StorageService.cache.sessionObject;
  }

  clearSessionData(): void {
    try {
      // Clear cache immediately
      StorageService.cache = {
        ...StorageService.cache,
        sessionId: null,
        sessionType: null,
        sessionState: null,
        sessionObject: null,
      };

      // Clear persistent storage asynchronously
      AsyncStorage.multiRemove([
        StorageService.SESSION_ID_KEY,
        StorageService.SESSION_TYPE_KEY,
        StorageService.SESSION_STATE_KEY,
        StorageService.SESSION_OBJECT_KEY,
      ]).catch((_error: any) => {
        // Failed to clear session data from storage - silently continue
      });
    } catch (error) {
      // Failed to clear session data - silently continue
      throw error;
    }
  }

  getAllSessionData(): Omit<CacheData, 'floatingButtonPosition'> {
    return {
      sessionId: StorageService.cache.sessionId,
      sessionType: StorageService.cache.sessionType,
      sessionState: StorageService.cache.sessionState,
      sessionObject: StorageService.cache.sessionObject,
    };
  }

  saveFloatingButtonPosition(position: { x: number; y: number }): void {
    try {
      StorageService.cache.floatingButtonPosition = position;

      // Debounce AsyncStorage writes to avoid excessive I/O
      if (StorageService.positionSaveTimeout) {
        clearTimeout(StorageService.positionSaveTimeout);
      }

      StorageService.positionSaveTimeout = setTimeout(() => {
        AsyncStorage.setItem(
          StorageService.FLOATING_BUTTON_POSITION_KEY,
          JSON.stringify(position)
        ).catch((error: any) => {
          logger.error(
            'StorageService',
            'Failed to persist floating button position',
            error
          );
        });
      }, 100); // 100ms debounce
    } catch (error) {
      logger.error(
        'StorageService',
        'Failed to save floating button position',
        error
      );
      throw error;
    }
  }

  getFloatingButtonPosition(): { x: number; y: number } | null {
    return StorageService.cache.floatingButtonPosition;
  }

  // Initialize cache on first use - call this method when the service is first used
  static async initialize(): Promise<void> {
    await StorageService.initializeCache();
  }
}