import io, { Socket } from 'socket.io-client'
import { Observable } from 'lib0/observable'

import { logger } from '../utils'

import {
  SESSION_ADD_EVENT,
  SESSION_AUTO_CREATED,
  SESSION_STOPPED_EVENT,
  SESSION_SUBSCRIBE_EVENT,
  SESSION_UNSUBSCRIBE_EVENT,
  SOCKET_SET_USER_EVENT,
  REMOTE_SESSION_RECORDING_START,
  REMOTE_SESSION_RECORDING_STOP,
  SESSION_STARTED_EVENT,
  SESSION_SAVE_BUFFER_EVENT,
} from '../config'
import {
  type ISession,
  type IUserAttributes,
  ATTR_MULTIPLAYER_SESSION_CLIENT_ID,
} from '@multiplayer-app/session-recorder-common'

const MAX_RECONNECTION_ATTEMPTS = 2

export type SocketServiceEvents =
  | typeof SESSION_STOPPED_EVENT
  | typeof SESSION_AUTO_CREATED
  | typeof REMOTE_SESSION_RECORDING_START
  | typeof REMOTE_SESSION_RECORDING_STOP
  | typeof SESSION_SAVE_BUFFER_EVENT

export interface SocketServiceOptions {
  apiKey: string
  socketUrl: string
  keepAlive?: boolean
  clientId?: string
}

export class SocketService extends Observable<SocketServiceEvents> {
  private socket: Socket | null = null
  private queue: any[] = []
  private isConnecting: boolean = false
  private isConnected: boolean = false
  private attempts: number = 0
  private sessionId: string | null = null
  private options: SocketServiceOptions
  private isInitialized: boolean = false
  private lastUserPayload: {
    userAttributes: IUserAttributes | null
    clientId?: string
  } | null = null
  private lastSubscribeSession: ISession | null = null
  constructor() {
    super()
    this.options = {
      apiKey: '',
      socketUrl: '',
      keepAlive: false,
    }
  }

  /**
   * Initialize the socket service
   * @param config - Socket service configuration
   */
  public init(config: SocketServiceOptions): void {
    this.options = {
      ...this.options,
      ...config,
    }
    this.isInitialized = true
    if (
      this.options.keepAlive &&
      this.options.socketUrl &&
      this.options.apiKey
    ) {
      this._initConnection()
    }
  }

  /**
   * Update the socket service configuration
   * @param config - Partial configuration to update
   */
  public updateConfigs(config: Partial<SocketServiceOptions>): void {
    // If any config changed, reconnect if connected
    const hasChanges = Object.keys(config).some((key) => {
      const typedKey = key as keyof SocketServiceOptions
      return (
        config[typedKey] !== undefined &&
        config[typedKey] !== this.options[typedKey]
      )
    })

    if (hasChanges) {
      this.options = { ...this.options, ...config }
      if (this.socket?.connected) {
        this.close().then(() => {
          if (
            this.options.keepAlive &&
            this.options.socketUrl &&
            this.options.apiKey
          ) {
            this._initConnection()
          }
        })
      }
    }
  }

  private _initConnection(): void {
    if (this.isConnecting || this.isConnected || !this.isInitialized) return
    this.attempts++
    this.isConnecting = true
    this.socket = io(this.options.socketUrl, {
      path: '/v0/radar/ws',
      auth: {
        'x-api-key': this.options.apiKey,
        ...(this.options.clientId
          ? { [ATTR_MULTIPLAYER_SESSION_CLIENT_ID]: this.options.clientId }
          : {}),
      },
      reconnectionAttempts: 2,
      transports: ['websocket'],
    })

    this.socket.on('ready', () => {
      this.isConnecting = false
      this.isConnected = true
      logger.info('SocketService', 'Connected to server')
      // Re-establish identity and session on every (re)connect: socket.io's auto-reconnect
      // fires 'ready' again after a drop, but the server has no memory of the previous
      // setUser/subscribe calls — the client must replay them.
      if (this.lastUserPayload && this.socket) {
        this.socket.emit(SOCKET_SET_USER_EVENT, this.lastUserPayload)
      }
      if (this.lastSubscribeSession) {
        this._emitSubscribe(this.lastSubscribeSession)
      }
      this.flushQueue()
    })

    this.socket.on('disconnect', (_err: any) => {
      this.isConnecting = false
      this.isConnected = false
      logger.info('SocketService', 'Disconnected from server')
    })

    this.socket.on('connect_error', (err: any) => {
      this.isConnecting = false
      this.isConnected = false
      this.checkReconnectionAttempts()
      logger.error('SocketService', 'Error connecting to server', err)
    })

    this.socket.on(SESSION_STOPPED_EVENT, (data: any) => {
      this.emit(SESSION_STOPPED_EVENT, [data])
    })

    this.socket.on(SESSION_AUTO_CREATED, (data: any) => {
      this.emit(SESSION_AUTO_CREATED, [data])
    })

    this.socket.on(REMOTE_SESSION_RECORDING_START, (data: any) => {
      this.emit(REMOTE_SESSION_RECORDING_START, [data])
    })

    this.socket.on(REMOTE_SESSION_RECORDING_STOP, (data: any) => {
      this.emit(REMOTE_SESSION_RECORDING_STOP, [data])
    })

    this.socket.on(SESSION_SAVE_BUFFER_EVENT, (data: any) => {
      this.emit(SESSION_SAVE_BUFFER_EVENT, [data])
    })
  }

  private checkReconnectionAttempts(): void {
    if (this.attempts >= MAX_RECONNECTION_ATTEMPTS) {
      this.flushQueue()
    }
  }

  private emitSocketEvent(name: string, data: any): void {
    if (this.socket && this.isConnected) {
      this.socket.emit(name, data)
    } else {
      this.queue.push({ data, name })
      this._initConnection()
    }
  }

  private flushQueue(): void {
    while (this.queue.length > 0 && this.isConnected) {
      const event = this.queue.shift()
      if (!event) continue

      if (this.socket && this.isConnected) {
        this.socket.emit(event.name, event.data)
      }
    }
  }

  public send(event: any): void {
    this.emitSocketEvent(SESSION_ADD_EVENT, event)
  }

  public subscribeToSession(session: ISession): void {
    // Remember the session so reconnects replay subscribe + started.
    this.lastSubscribeSession = session
    this._emitSubscribe(session)
  }

  private _emitSubscribe(session: ISession): void {
    this.sessionId = session.shortId || session._id
    const subscribePayload = {
      projectId: session.project,
      workspaceId: session.workspace,
      debugSessionId: this.sessionId,
      sessionType: session.creationType,
    }
    const startedPayload = { debugSessionId: session._id }
    // Send directly (not via the queue). The queue would cause a duplicate emit on
    // the next 'ready' alongside the replay, since 'ready' replays lastSubscribeSession.
    if (this.socket && this.isConnected) {
      this.socket.emit(SESSION_SUBSCRIBE_EVENT, subscribePayload)
      this.socket.emit(SESSION_STARTED_EVENT, startedPayload)
    } else {
      // Not connected: 'ready' will replay via lastSubscribeSession once the socket is up.
      this._initConnection()
    }
  }

  public unsubscribeFromSession(stopSession?: boolean) {
    if (this.sessionId) {
      this.emitSocketEvent(SESSION_UNSUBSCRIBE_EVENT, {
        debugSessionId: this.sessionId,
      })
      if (stopSession) {
        this.emitSocketEvent(SESSION_STOPPED_EVENT, {})
      }
    }
    this.lastSubscribeSession = null
  }

  public setUser(data: {
    userAttributes: IUserAttributes | null
    clientId?: string
  }): void {
    // Remember the last identity so 'ready' (initial connect + every reconnect) can replay it.
    // Send directly here rather than queuing: the queue would cause a duplicate emit on the
    // next 'ready' alongside the replay.
    this.lastUserPayload = data
    if (this.socket && this.isConnected) {
      this.socket.emit(SOCKET_SET_USER_EVENT, data)
    } else {
      // Not connected yet: 'ready' will replay lastUserPayload once the socket is up.
      this._initConnection()
    }
  }

  public close(): Promise<void> {
    return new Promise((resolve) => {
      if (this.socket?.connected) {
        setTimeout(() => {
          this.unsubscribeFromSession()
          this.attempts = 0
          this.isConnected = false
          this.isConnecting = false
          this.socket?.disconnect()
          this.socket = null
          resolve()
        }, 500)
      } else {
        resolve()
      }
    })
  }
}