import { Platform } from 'react-native'
import { logger } from '../utils'
import { sessionRecorderStore } from '../context/SessionRecorderStore'

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

if (!isWeb) {
  try {
    NetInfo = require('@react-native-community/netinfo').default
  } catch (error) {
    console.warn('NetInfo not available:', error)
  }
} else {
  // Web fallback using navigator.onLine
  NetInfo = {
    fetch: () =>
      Promise.resolve({
        isConnected: true, // Default to connected for web
        type: 'unknown',
        isInternetReachable: true,
      }),
    addEventListener: (_callback: (state: any) => void) => {
      // Return a no-op function for web
      return () => {}
    },
  }
}

export interface NetworkState {
  isConnected: boolean
  type: string | null
  isInternetReachable: boolean | null
}

export type NetworkStateChangeCallback = (state: NetworkState) => void

export class NetworkService {
  private static instance: NetworkService | null = null
  private _isOnline = true
  private unsubscribe: (() => void) | null = null
  private callbacks: NetworkStateChangeCallback[] = []

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

  static getInstance(): NetworkService {
    if (!NetworkService.instance) {
      NetworkService.instance = new NetworkService()
    }
    return NetworkService.instance
  }

  /**
   * Initialize network monitoring
   */
  async init(): Promise<void> {
    try {
      // Get initial network state
      const initialState = await NetInfo.fetch()
      this._isOnline = initialState.isConnected ?? true

      // Update store with initial state
      sessionRecorderStore.setState({ isOnline: this._isOnline })

      // Notify callbacks
      this.notifyCallbacks({
        isConnected: this._isOnline,
        type: initialState.type,
        isInternetReachable: initialState.isInternetReachable,
      })

      // Listen for network state changes
      this.unsubscribe = NetInfo.addEventListener((state: any) => {
        const wasOnline = this._isOnline
        this._isOnline = state.isConnected ?? true

        // Update store
        sessionRecorderStore.setState({ isOnline: this._isOnline })

        // Notify callbacks
        this.notifyCallbacks({
          isConnected: this._isOnline,
          type: state.type,
          isInternetReachable: state.isInternetReachable,
        })

        // Log state changes
        if (wasOnline && !this._isOnline) {
          logger.info('NetworkService', 'Network went offline')
        } else if (!wasOnline && this._isOnline) {
          logger.info('NetworkService', 'Network came back online')
        }
      })

      logger.info('NetworkService', 'Network monitoring initialized')
    } catch (error) {
      logger.error(
        'NetworkService',
        'Failed to initialize network monitoring',
        error,
      )
    }
  }

  /**
   * Get current network state
   */
  getCurrentState(): NetworkState {
    return {
      isConnected: this._isOnline,
      type: null, // We don't store this in the service
      isInternetReachable: null, // We don't store this in the service
    }
  }

  /**
   * Check if device is online
   */
  isOnline(): boolean {
    return this._isOnline
  }

  /**
   * Add callback for network state changes
   */
  addCallback(callback: NetworkStateChangeCallback): void {
    this.callbacks.push(callback)
  }

  /**
   * Remove callback for network state changes
   */
  removeCallback(callback: NetworkStateChangeCallback): void {
    this.callbacks = this.callbacks.filter((cb) => cb !== callback)
  }

  /**
   * Notify all callbacks of network state change
   */
  private notifyCallbacks(state: NetworkState): void {
    this.callbacks.forEach((callback) => {
      try {
        callback(state)
      } catch (error) {
        logger.error('NetworkService', 'Error in network state callback', error)
      }
    })
  }

  /**
   * Cleanup network monitoring
   */
  cleanup(): void {
    if (this.unsubscribe) {
      this.unsubscribe()
      this.unsubscribe = null
    }
    this.callbacks = []
    logger.info('NetworkService', 'Network monitoring cleaned up')
  }

  /**
   * Force refresh network state
   */
  async refresh(): Promise<NetworkState> {
    try {
      const state = await NetInfo.fetch()
      this._isOnline = state.isConnected ?? true
      sessionRecorderStore.setState({ isOnline: this._isOnline })

      const networkState: NetworkState = {
        isConnected: this._isOnline,
        type: state.type,
        isInternetReachable: state.isInternetReachable,
      }

      this.notifyCallbacks(networkState)
      return networkState
    } catch (error) {
      logger.error('NetworkService', 'Failed to refresh network state', error)
      throw error
    }
  }
}