import {
  SessionType,
  type ISession,
  type IUserAttributes,
} from '@multiplayer-app/session-recorder-common'
import { Observable } from 'lib0/observable'
import { type eventWithTime } from '@rrweb/types'

import { TracerReactNativeSDK } from './otel'
import { RecorderReactNativeSDK } from './recorder'
import { logger } from './utils'

import {
  SessionState,
  type ISessionRecorder,
  type SessionRecorderConfigs,
  type SessionRecorderOptions,
  type EventRecorder,
} from './types'
import {
  SESSION_STOPPED_EVENT,
  REMOTE_SESSION_RECORDING_START,
  REMOTE_SESSION_RECORDING_STOP,
  SESSION_SAVE_BUFFER_EVENT,
} from './config'
import { getFormattedDate, isSessionActive, getNavigatorInfo } from './utils'
import {
  setShouldRecordHttpData,
  setMaxCapturingHttpPayloadSize,
} from './patch'
import { BASE_CONFIG, getSessionRecorderConfig } from './config'

import { StorageService } from './services/storage.service'
import { NetworkService } from './services/network.service'
import { CrashBufferService } from './services/crashBuffer.service'
import {
  ApiService,
  type StartSessionRequest,
  type StopSessionRequest,
} from './services/api.service'
import { SocketService } from './services/socket.service'

type SessionRecorderEvents = 'state-change' | 'init'

class SessionRecorder
  extends Observable<SessionRecorderEvents>
  implements ISessionRecorder, EventRecorder
{
  private _configs: SessionRecorderConfigs
  private _apiService = new ApiService()
  private _socketService = new SocketService()
  private _tracer = new TracerReactNativeSDK()
  private _recorder = new RecorderReactNativeSDK()
  private _storageService = StorageService.getInstance()
  private _networkService = NetworkService.getInstance()
  private _crashBuffer = CrashBufferService.getInstance()
  private _isFlushingBuffer: boolean = false
  private _startRequestController: AbortController | null = null

  // Whether the session recorder is initialized
  private _isInitialized = false
  get isInitialized(): boolean {
    return this._isInitialized
  }
  set isInitialized(isInitialized: boolean) {
    this._isInitialized = isInitialized
  }

  // Session ID and state are stored in AsyncStorage
  private _sessionId: string | null = null
  get sessionId(): string | null {
    return this._sessionId
  }
  set sessionId(sessionId: string | null) {
    this._sessionId = sessionId
    if (sessionId) {
      this._storageService.saveSessionId(sessionId)
    }
  }

  private _sessionType: SessionType = SessionType.MANUAL
  get sessionType(): SessionType {
    return this._sessionType
  }
  set sessionType(sessionType: SessionType) {
    this._sessionType = sessionType
    this._storageService.saveSessionType(sessionType)
  }

  get continuousRecording(): boolean {
    return this.sessionType === SessionType.CONTINUOUS
  }

  private _sessionState: SessionState | null = null
  get sessionState(): SessionState | null {
    return this._sessionState || SessionState.stopped
  }
  set sessionState(state: SessionState | null) {
    this._sessionState = state
    this.emit('state-change', [state || SessionState.stopped, this.sessionType])
    if (state) {
      this._storageService.saveSessionState(state)
    }
  }

  private _session: ISession | null = null
  get session(): ISession | null {
    return this._session
  }
  set session(session: ISession | null) {
    this._session = session
    if (session) {
      this._storageService.saveSessionObject(session)
    }
  }

  private _sessionAttributes: Record<string, any> | null = null
  get sessionAttributes(): Record<string, any> {
    return this._sessionAttributes || {}
  }
  set sessionAttributes(attributes: Record<string, any> | null) {
    this._sessionAttributes = attributes
  }

  private _userAttributes: IUserAttributes | null = null
  get userAttributes(): IUserAttributes | null {
    return this._userAttributes
  }
  set userAttributes(userAttributes: IUserAttributes | null) {
    this._userAttributes = userAttributes
  }
  /**
   * Error message getter and setter
   */
  public get error(): string {
    return this._error || ''
  }

  public set error(v: string) {
    this._error = v
  }
  private _error: string = ''

  /**
   * React Native doesn't have HTML elements, so we return null
   */
  public get sessionWidgetButtonElement(): any {
    return null
  }

  public get config(): SessionRecorderConfigs {
    return this._configs
  }
  /**
   * Initialize debugger with default or custom configurations
   */
  constructor() {
    super()
    this._configs = BASE_CONFIG
    // Initialize with stored session data if available
    StorageService.initialize()
  }

  /**
   * Capture an exception manually and send it as an error trace.
   */
  public captureException(
    error: unknown,
    errorInfo?: Record<string, any>,
  ): void {
    try {
      const normalizedError = this._normalizeError(error)
      const normalizedErrorInfo = this._normalizeErrorInfo(errorInfo)
      this._tracer.captureException(normalizedError, normalizedErrorInfo)
    } catch (e: any) {
      this.error = e?.message || 'Failed to capture exception'
    }
  }

  private async _flushBuffer(sessionId: string): Promise<any> {
    if (
      !sessionId ||
      !this._crashBuffer ||
      this._isFlushingBuffer ||
      !this._configs?.buffering?.enabled
    ) {
      return null
    }

    this._isFlushingBuffer = true

    try {
      const { events, spans, startedAt, stoppedAt } =
        await this._crashBuffer.snapshot()
      if (events.length === 0 && spans.length === 0) {
        return null
      }

      await Promise.all([
        this._tracer.exportTraces(spans.map((s) => s.span)),
        this._apiService.exportEvents(sessionId, {
          events: events.map((e) => e.event),
        }),
        this._apiService.updateSessionAttributes(sessionId, {
          startedAt: this._toCrashBufferSessionIso(startedAt),
          stoppedAt: this._toCrashBufferSessionIso(stoppedAt),
          sessionAttributes: this.sessionAttributes,
          resourceAttributes: getNavigatorInfo(),
          userAttributes: this._userAttributes || undefined,
        }),
      ])
    } catch (_e) {
      // swallow: flush is best-effort; never throw into app code
    } finally {
      await this._crashBuffer.clear()
      this._isFlushingBuffer = false
    }
  }

  private _toCrashBufferSessionIso(ts: number): string {
    return new Date(ts).toISOString()
  }

  private async _createExceptionSession(span: any): Promise<void> {
    try {
      const session = await this._apiService.createErrorSession({ span })
      if (session?._id) {
        void this._flushBuffer(session._id)
      }
    } catch (_ignored) {
      // best-effort
    }
  }

  private async _loadStoredSessionData(): Promise<void> {
    try {
      await StorageService.initialize()
      const storedData = await this._storageService.getAllSessionData()
      if (isSessionActive(storedData.sessionObject, storedData.sessionType)) {
        this.session = storedData.sessionObject
        this.sessionId = storedData.sessionId
        this.sessionType = storedData.sessionType || SessionType.MANUAL
        this.sessionState = storedData.sessionState
      } else {
        this.session = null
        this.sessionId = null
        this.sessionState = null
        this.sessionType = SessionType.MANUAL
      }
    } catch (error) {
      logger.error(
        'SessionRecorder',
        'Failed to load stored session data',
        error,
      )
      this.session = null
      this.sessionId = null
      this.sessionState = null
      this.sessionType = SessionType.MANUAL
    }
  }

  /**
   * Initialize the session debugger
   * @param configs - custom configurations for session debugger
   */
  public async init(configs: SessionRecorderOptions): Promise<void> {
    if (this._isInitialized) return
    this._isInitialized = true
    this._configs = getSessionRecorderConfig({ ...this._configs, ...configs })
    logger.configure(this._configs.logger)
    await this._loadStoredSessionData()
    setMaxCapturingHttpPayloadSize(this._configs.maxCapturingHttpPayloadSize)
    setShouldRecordHttpData(
      this._configs.captureBody,
      this._configs.captureHeaders,
    )

    // Crash buffer wiring (RN): set BEFORE tracer init so early spans don't get exported.
    const bufferEnabled = Boolean(this._configs.buffering?.enabled)
    const windowMs = Math.max(
      10_000,
      (this._configs.buffering?.windowMinutes || 0.5) * 60 * 1000,
    )
    if (bufferEnabled) {
      // Drop any buffer persisted by a previous app launch: the stored FullSnapshot
      // refers to a view hierarchy that no longer exists, and carrying old timestamps
      // forward inflates the reported session duration on flush. The CrashBufferService
      // serializes its ops via an internal chain, so appends triggered after this
      // clear are guaranteed to run afterwards.
      void this._crashBuffer.clear()
    }
    this._tracer.setCrashBuffer(
      bufferEnabled ? this._crashBuffer : undefined,
      windowMs,
    )

    this._tracer.init(this._configs)
    this._apiService.init(this._configs)
    this._socketService.init({
      apiKey: this._configs.apiKey,
      socketUrl: this._configs.apiBaseUrl,
      keepAlive: this._configs.useWebsocket,
      clientId: this._tracer.clientId,
    })

    this._recorder.init(
      this._configs,
      this._socketService,
      bufferEnabled ? this._crashBuffer : undefined,
      { enabled: bufferEnabled, windowMs },
    )

    this._crashBuffer.on('error-span-appended', (payload) => {
      if (
        !payload.span ||
        this.sessionId ||
        this.sessionState !== SessionState.stopped
      ) {
        return
      }
      this._createExceptionSession(payload.span)
    })

    await this._networkService.init()
    this._setupNetworkCallbacks()
    this._registerSocketServiceListeners()

    if (
      this.sessionId &&
      (this.sessionState === SessionState.started ||
        this.sessionState === SessionState.paused)
    ) {
      this._start()
    } else {
      this._startBufferOnlyRecording()
    }
    this.emit('init', [])
  }

  private _startBufferOnlyRecording(): void {
    // `this.sessionId` is intentionally NOT checked: `_stop()` runs before
    // `_clearSession()` (the stopSession API call sits between them), so the
    // buffer-restart chain fires while sessionId is still set. Bailing here
    // meant the recorder never restarted after manual stop, leaving no
    // FullSnapshot and silently breaking exception-triggered flushBuffer.
    if (
      !this._crashBuffer ||
      !this._configs?.buffering?.enabled ||
      this.sessionState !== SessionState.stopped
    ) {
      return
    }

    const windowMs = Math.max(
      10_000,
      (this._configs.buffering.windowMinutes || 0.5) * 60 * 1000,
    )

    // Wire buffer into tracer + recorder (only used when sessionId is null).
    this._tracer.setCrashBuffer(this._crashBuffer, windowMs)
    this._recorder.init(this._configs, this._socketService, this._crashBuffer, {
      enabled: true,
      windowMs,
    })

    // Start capturing events without an active debug session id.
    try {
      this._recorder.stop()
      // eslint-disable-next-line no-empty
    } catch (_e) {}
    this._recorder.start(null, SessionType.MANUAL)
  }

  /**
   * Register socket service event listeners
   */
  private _registerSocketServiceListeners(): void {
    this._socketService.on(SESSION_STOPPED_EVENT, () => {
      this._stop()
      this._clearSession()
    })

    this._socketService.on(REMOTE_SESSION_RECORDING_START, (payload: any) => {
      logger.info(
        'SessionRecorder',
        'Remote session recording started',
        payload,
      )
      if (this.sessionState === SessionState.stopped) {
        this.start()
      }
    })

    this._socketService.on(REMOTE_SESSION_RECORDING_STOP, (payload: any) => {
      logger.info(
        'SessionRecorder',
        'Remote session recording stopped',
        payload,
      )
      if (this.sessionState !== SessionState.stopped) {
        this.stop()
      }
    })

    this._socketService.on(SESSION_SAVE_BUFFER_EVENT, (payload: any) => {
      // Only honor backend save-buffer requests while in buffer-only mode. If a session
      // is already recording (manual/continuous), the client is streaming directly and
      // should ignore this event.
      if (this.sessionState !== SessionState.stopped) return
      this._flushBuffer(payload?.debugSession?._id)
    })
  }

  /**
   * Setup network state change callbacks
   */
  private _setupNetworkCallbacks(): void {
    this._networkService.addCallback((state) => {
      if (!state.isConnected && this.sessionState === SessionState.started) {
        logger.info(
          'SessionRecorder',
          'Network went offline - pausing session recording',
        )
        this.pause()
      } else if (
        state.isConnected &&
        this.sessionState === SessionState.paused
      ) {
        logger.info(
          'SessionRecorder',
          'Network came back online - resuming session recording',
        )
        this.resume()
      }
    })
  }

  /**
   * Start a new session
   * @param type - the type of session to start
   * @param session - the session to start
   */
  public async start(
    type: SessionType = SessionType.MANUAL,
    session?: ISession,
  ): Promise<void> {
    this._checkOperation('start')

    // Check if offline - don't start recording if offline
    if (!this._networkService.isOnline()) {
      logger.warn(
        'SessionRecorder',
        'Cannot start session recording - device is offline',
      )
      throw new Error('Cannot start session recording while offline')
    }

    // If continuous recording is disabled, force plain mode
    if (
      type === SessionType.CONTINUOUS &&
      !this._configs?.showContinuousRecording
    ) {
      type = SessionType.MANUAL
    }
    logger.info('SessionRecorder', 'Starting session with type:', type)
    this.sessionType = type
    this._startRequestController = new AbortController()
    if (session) {
      this._setupSessionAndStart(session, true)
    } else {
      await this._createSessionAndStart()
    }
  }

  /**
   * Stop the current session with an optional comment
   * @param comment - user-provided comment to include in session session attributes
   */
  public async stop(comment?: string): Promise<void> {
    try {
      this._checkOperation('stop')
      const sid = this.sessionId
      this._stop()
      if (this.continuousRecording) {
        await this._apiService.stopContinuousDebugSession(sid!)
        this.sessionType = SessionType.MANUAL
      } else {
        const request: StopSessionRequest = {
          sessionAttributes: { comment },
          stoppedAt: Date.now(),
        }
        await this._apiService.stopSession(sid!, request)
      }
    } catch (error: any) {
      this.error = error.message
    }
  }

  /**
   * Pause the current session
   */
  public async pause(): Promise<void> {
    try {
      this._checkOperation('pause')
      this._pause()
    } catch (error: any) {
      this.error = error.message
    }
  }

  /**
   * Resume the current session
   */
  public async resume(): Promise<void> {
    try {
      this._checkOperation('resume')
      this._resume()
    } catch (error: any) {
      this.error = error.message
    }
  }

  /**
   * Cancel the current session
   */
  public async cancel(): Promise<void> {
    try {
      this._checkOperation('cancel')
      const sid = this.sessionId
      this._stop()
      if (this.continuousRecording) {
        await this._apiService.stopContinuousDebugSession(sid!)
        this.sessionType = SessionType.MANUAL
      } else {
        await this._apiService.cancelSession(sid!)
      }
    } catch (error: any) {
      this.error = error.message
    }
  }

  /**
   * Save the continuous recording session
   */
  public async save(): Promise<any> {
    try {
      this._checkOperation('save')
      if (
        !this.continuousRecording ||
        !this._configs?.showContinuousRecording
      ) {
        return
      }

      const res = await this._apiService.saveContinuousDebugSession(
        this.sessionId!,
        {
          sessionAttributes: this.sessionAttributes,
          resourceAttributes: getNavigatorInfo(),
          stoppedAt: Date.now(),
          name: this._getSessionName(),
        },
      )

      return res
    } catch (error: any) {
      this.error = error.message
    }
  }

  /**
   * Set the session attributes
   * @param attributes - the attributes to set
   */
  public setSessionAttributes(attributes: Record<string, any>): void {
    this._sessionAttributes = attributes
  }

  /**
   * Set the user attributes
   * @param userAttributes - the user attributes to set
   */
  public setUserAttributes(userAttributes: IUserAttributes | null): void {
    if (!this._userAttributes && !userAttributes) {
      return
    }
    this._userAttributes = userAttributes

    const data = {
      userAttributes: this._userAttributes,
      clientId: this._tracer.clientId,
    }

    this._socketService.setUser(data)
  }

  /**
   * @description Check if session should be started/stopped automatically
   * @param {ISession} [sessionPayload]
   * @returns {Promise<void>}
   */
  public async checkRemoteContinuousSession(
    sessionPayload?: Omit<ISession, '_id' | 'shortId'>,
  ): Promise<void> {
    this._checkOperation('autoStartRemoteContinuousSession')
    if (!this._configs?.showContinuousRecording) {
      return
    }
    const payload = {
      sessionAttributes: {
        ...this.sessionAttributes,
        ...(sessionPayload?.sessionAttributes || {}),
      },
      resourceAttributes: {
        ...getNavigatorInfo(),
        ...(sessionPayload?.resourceAttributes || {}),
      },
      ...(this._userAttributes ? { userAttributes: this._userAttributes } : {}),
    }

    const { state } = await this._apiService.checkRemoteSession(payload)

    if (state == 'START') {
      if (this.sessionState !== SessionState.started) {
        await this.start(SessionType.CONTINUOUS)
      }
    } else if (state == 'STOP') {
      if (this.sessionState !== SessionState.stopped) {
        await this.stop()
      }
    }
  }

  /**
   * Create a new session and start it
   */
  private async _createSessionAndStart(): Promise<void> {
    const signal = this._startRequestController?.signal
    try {
      const payload = {
        sessionAttributes: this.sessionAttributes,
        resourceAttributes: getNavigatorInfo(),
        name: this._getSessionName(),
        ...(this._userAttributes
          ? { userAttributes: this._userAttributes }
          : {}),
      }
      const request: StartSessionRequest = !this.continuousRecording
        ? payload
        : { debugSessionData: payload }

      const session = this.continuousRecording
        ? await this._apiService.startContinuousDebugSession(request, signal)
        : await this._apiService.startSession(request, signal)

      if (session) {
        session.sessionType = this.continuousRecording
          ? SessionType.CONTINUOUS
          : SessionType.MANUAL
        this._setupSessionAndStart(session, false)
      }
    } catch (error: any) {
      this.error = error.message
      logger.error('SessionRecorder', 'Error creating session:', error.message)
      if (this.continuousRecording) {
        this.sessionType = SessionType.MANUAL
      }
    }
  }

  /**
   * Start tracing and recording for the session
   */
  private _start(): void {
    this.sessionState = SessionState.started
    // eslint-disable-next-line no-self-assign
    this.sessionType = this.sessionType

    if (this.sessionId) {
      // Switch from buffer-only recording to session recording cleanly.
      try {
        this._recorder.stop()
        // eslint-disable-next-line no-empty
      } catch (_e) {}
      this._tracer.start(this.sessionId, this.sessionType)
      this._recorder.start(this.sessionId, this.sessionType)
      if (this.session) {
        this._socketService.subscribeToSession(this.session)
      }
    }
  }

  /**
   * Stop tracing and recording for the session
   */
  private _stop(): void {
    this.sessionState = SessionState.stopped
    this._socketService.unsubscribeFromSession(true)
    this._tracer.stop()
    this._recorder.stop()
    // Clear session identity synchronously. The buffer-restart path and the
    // error-span-appended listener both gate on `this.sessionId === null`;
    // deferring this to `_clearSession()` (after the network stopSession
    // call) left them seeing a stale id and silently no-oping. Callers that
    // need the id for the stop/cancel API must capture it before _stop().
    this.session = null
    this.sessionId = null
    // Each recorder start assigns fresh node IDs, so the next buffer
    // segment must not carry events from the previous generation. The
    // crash buffer's opChain queues this clear before any subsequent
    // appendEvent, so the fresh FullSnapshot can't be wiped.
    void this._crashBuffer?.clear()
    this._startBufferOnlyRecording()
  }

  /**
   * Pause the session tracing and recording
   */
  private _pause(): void {
    this._tracer.stop()
    this._recorder.stop()
    this.sessionState = SessionState.paused
  }

  /**
   * Resume the session tracing and recording
   */
  private _resume(): void {
    if (this.sessionId) {
      this._tracer.start(this.sessionId, this.sessionType)
      try {
        this._recorder.stop()
        // eslint-disable-next-line no-empty
      } catch (_e) {}
      this._recorder.start(this.sessionId, this.sessionType)
    }
    this.sessionState = SessionState.started
  }

  private _setupSessionAndStart(
    session: ISession,
    configureExporters: boolean = true,
  ): void {
    if (configureExporters && session.tempApiKey) {
      this._configs.apiKey = session.tempApiKey
      this._tracer.setApiKey(session.tempApiKey)
      this._apiService.setApiKey(session.tempApiKey)
      this._socketService.updateConfigs({ apiKey: session.tempApiKey })
    }

    this._setSession(session)
    this._start()
  }

  /**
   * Set the session ID in storage
   * @param sessionId - the session ID to set or clear
   */
  private _setSession(session: ISession): void {
    this.session = {
      ...session,
      createdAt: session.createdAt || new Date().toISOString(),
    }
    this.sessionId = session?.shortId || session?._id
  }

  private _clearSession(): void {
    this.session = null
    this.sessionId = null
    this.sessionState = SessionState.stopped
    this._storageService.clearSessionData()
  }

  /**
   * Check the operation validity based on the session state and action
   * @param action - action being checked ('init', 'start', 'stop', 'cancel', 'pause', 'resume')
   */
  private _checkOperation(
    action:
      | 'init'
      | 'start'
      | 'stop'
      | 'cancel'
      | 'pause'
      | 'resume'
      | 'save'
      | 'autoStartRemoteContinuousSession',
    _payload?: any,
  ): void {
    if (!this._isInitialized) {
      throw new Error(
        'Configuration not initialized. Call init() before performing any actions.',
      )
    }
    switch (action) {
      case 'start':
        if (this.sessionState === SessionState.started) {
          throw new Error('Session is already started.')
        }
        break
      case 'stop':
        if (
          this.sessionState !== SessionState.paused &&
          this.sessionState !== SessionState.started
        ) {
          throw new Error('Cannot stop. Session is not currently started.')
        }
        break
      case 'cancel':
        if (this.sessionState === SessionState.stopped) {
          throw new Error('Cannot cancel. Session has already been stopped.')
        }
        break
      case 'pause':
        if (this.sessionState !== SessionState.started) {
          throw new Error('Cannot pause. Session is not running.')
        }
        break
      case 'resume':
        if (this.sessionState !== SessionState.paused) {
          throw new Error('Cannot resume. Session is not paused.')
        }
        break
      case 'save':
        if (!this.continuousRecording) {
          throw new Error(
            'Cannot save continuous recording session. Continuous recording is not enabled.',
          )
        }
        if (this.sessionState !== SessionState.started) {
          throw new Error(
            'Cannot save continuous recording session. Session is not started.',
          )
        }
        break
      case 'autoStartRemoteContinuousSession':
        if (this.sessionState !== SessionState.stopped) {
          throw new Error(
            'Cannot start remote continuous session. Session is not stopped.',
          )
        }
        break
    }
  }
  // Session attributes
  setSessionAttribute(key: string, value: any): void {
    if (this._session) {
      if (!this._session.sessionAttributes) {
        this._session.sessionAttributes = {}
      }
      this._session.sessionAttributes[key] = value
      this._session.updatedAt = new Date().toISOString()
    }
  }

  /**
   * Record a custom rrweb event
   * Note: Screen capture and touch events are recorded automatically when session is started
   * @param event - The rrweb event to record
   */
  recordEvent(event: eventWithTime): void {
    if (!this._isInitialized || this.sessionState !== SessionState.started) {
      return
    }

    // Forward the event to the recorder SDK
    this._recorder.recordEvent(event)
  }

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

  /**
   * Set the navigation ref for navigation tracking
   * @param ref - React Native Navigation ref for navigation tracking
   */
  setNavigationRef(ref: any): void {
    if (this._recorder) {
      this._recorder.setNavigationRef(ref)
    }
  }

  /**
   * Cleanup resources and unsubscribe from network monitoring
   */
  cleanup(): void {
    this._networkService.cleanup()
  }

  /**
   * Normalize an error to an Error object
   * @param error - the error to normalize
   * @returns the normalized error
   */
  private _normalizeError(error: unknown): Error {
    if (error instanceof Error) return error
    if (typeof error === 'string') return new Error(error)
    try {
      return new Error(JSON.stringify(error))
    } catch (_e) {
      return new Error(String(error))
    }
  }

  /**
   * Normalize an error info object to a Record<string, any>
   * @param errorInfo - the error info to normalize
   * @returns the normalized error info
   */
  private _normalizeErrorInfo(
    errorInfo?: Record<string, any>,
  ): Record<string, any> {
    if (!errorInfo) return {}
    try {
      return JSON.parse(JSON.stringify(errorInfo))
    } catch (_e) {
      return { errorInfo: String(errorInfo) }
    }
  }

  /**
   * Get the session name
   * @returns the session name
   */
  private _getSessionName(date: Date = new Date()): string {
    const userName =
      this.sessionAttributes?.userName ||
      this._userAttributes?.userName ||
      this._userAttributes?.name ||
      ''
    return userName
      ? `${userName}'s session on ${getFormattedDate(date, { month: 'short', day: 'numeric' })}`
      : `Session on ${getFormattedDate(date)}`
  }
}

export default new SessionRecorder()