import { EventType, type eventWithTime } from '@rrweb/types'
import { SessionType } from '@multiplayer-app/session-recorder-common'

import { logger } from '../utils'
import { type RecorderConfig, type EventRecorder } from '../types'
import { SocketService } from '../services/socket.service'
import { CrashBufferService } from '../services/crashBuffer.service'

import { ScreenRecorder } from './screenRecorder'
import { GestureRecorder } from './gestureRecorder'
import { NavigationRecorder } from './navigationRecorder'

export class RecorderReactNativeSDK implements EventRecorder {
  private isRecording = false
  private generation = 0
  private config?: RecorderConfig
  private screenRecorder: ScreenRecorder
  private gestureRecorder: GestureRecorder
  private navigationRecorder: NavigationRecorder
  private recordedEvents: eventWithTime[] = []
  private socketService!: SocketService
  private crashBuffer?: CrashBufferService
  private bufferingEnabled: boolean = false
  private bufferWindowMs: number = 2 * 60 * 1000
  private sessionId: string | null = null
  private sessionType: SessionType = SessionType.MANUAL

  constructor() {
    this.screenRecorder = new ScreenRecorder()
    this.gestureRecorder = new GestureRecorder()
    this.navigationRecorder = new NavigationRecorder()
  }

  init(
    config: RecorderConfig,
    socketService: SocketService,
    crashBuffer?: CrashBufferService,
    buffering?: { enabled: boolean; windowMs: number },
  ): void {
    this.config = config
    this.socketService = socketService
    this.crashBuffer = crashBuffer
    this.bufferingEnabled = Boolean(buffering?.enabled)
    this.bufferWindowMs = Math.max(
      10_000,
      buffering?.windowMs || 0.5 * 60 * 1000,
    )
    this.screenRecorder.init(config, this)
    this.navigationRecorder.init(config, this.screenRecorder)
    this.gestureRecorder.init(config, this, this.screenRecorder)
  }

  start(sessionId: string | null, sessionType: SessionType): void {
    if (!this.config) {
      throw new Error(
        'Configuration not initialized. Call init() before start().',
      )
    }

    this.sessionId = sessionId
    this.sessionType = sessionType
    this.isRecording = true
    this.generation++

    // Emit recording started meta event

    if (this.config.recordScreen) {
      this.screenRecorder.setBufferOnlyMode(!sessionId && this.bufferingEnabled)
      this.screenRecorder.start()
    }

    if (this.config.recordGestures) {
      this.gestureRecorder.start()
    }

    if (this.config.recordNavigation) {
      this.navigationRecorder.start()
    }
  }

  stop(): void {
    this.isRecording = false
    this.generation++
    this.gestureRecorder.stop()
    this.navigationRecorder.stop()
    this.screenRecorder.stop()
    this.socketService?.close()
  }

  /**
   * Current recorder generation. Capture at the start of an async
   * capture/emit and re-check before publishing the event; a mismatch
   * means the recorder was stopped/restarted mid-flight and the event
   * would bleed across sessions (different node-id mirrors).
   */
  getGeneration(): number {
    return this.generation
  }

  setNavigationRef(ref: any): void {
    this.navigationRecorder.setNavigationRef(ref)
  }

  /**
   * Set the viewshot ref for screen capture
   * @param ref - React Native View ref for screen capture
   */
  setViewShotRef(ref: any): void {
    this.screenRecorder.setViewShotRef(ref)
  }

  /**
   * Record an rrweb event
   * @param event - The rrweb event to record
   */
  recordEvent(event: eventWithTime): void {
    if (!this.isRecording) {
      return
    }

    // Buffer-only mode (no active debug session): persist locally.
    if (!this.sessionId && this.crashBuffer && this.bufferingEnabled) {
      void this.crashBuffer.appendEvent(
        {
          ts: event.timestamp,
          isFullSnapshot: event.type === EventType.FullSnapshot,
          event: {
            event: event,
            eventType: event.type,
            timestamp: event.timestamp,
          },
        },
        this.bufferWindowMs,
      )
      return
    }

    if (this.socketService) {
      logger.debug('RecorderReactNativeSDK', 'Sending to socket service', event)
      // Skip packing to avoid blob creation issues in Hermes
      // const packedEvent = pack(event)
      this.socketService.send({
        event: event, // Send raw event instead of packed
        eventType: event.type,
        timestamp: event.timestamp,
        debugSessionId: this.sessionId,
        debugSessionType: this.sessionType,
      })
    }
  }

  /**
   * Record touch start event
   * @param x - X coordinate
   * @param y - Y coordinate
   * @param target - Target element identifier
   * @param pressure - Touch pressure
   */
  recordTouchStart(
    x: number,
    y: number,
    target?: string,
    pressure?: number,
  ): void {
    if (!this.isRecording) {
      return
    }

    this.gestureRecorder.recordTouchStart(x, y, target, pressure)
  }

  /**
   * Record touch move event
   * @param x - X coordinate
   * @param y - Y coordinate
   * @param target - Target element identifier
   * @param pressure - Touch pressure
   */
  recordTouchMove(
    x: number,
    y: number,
    target?: string,
    pressure?: number,
  ): void {
    if (!this.isRecording) {
      return
    }

    this.gestureRecorder.recordTouchMove(x, y, target, pressure)
  }

  /**
   * Record touch end event
   * @param x - X coordinate
   * @param y - Y coordinate
   * @param target - Target element identifier
   * @param pressure - Touch pressure
   */
  recordTouchEnd(
    x: number,
    y: number,
    target?: string,
    pressure?: number,
  ): void {
    if (!this.isRecording) {
      return
    }

    this.gestureRecorder.recordTouchEnd(x, y, target, pressure)
  }

  /**
   * Get all recorded events
   * @returns Array of recorded rrweb events
   */
  getRecordedEvents(): eventWithTime[] {
    return [...this.recordedEvents]
  }

  /**
   * Clear all recorded events
   */
  clearRecordedEvents(): void {
    this.recordedEvents = []
  }

  /**
   * Get recording statistics
   * @returns Recording statistics
   */
  getRecordingStats(): { totalEvents: number; isRecording: boolean } {
    return {
      totalEvents: this.recordedEvents.length,
      isRecording: this.isRecording,
    }
  }
}