import type {
  IUserAttributes,
  ISessionAttributes,
  IResourceAttributes,
} from '@multiplayer-app/session-recorder-common'
import { type ApiServiceConfig } from '../types'
import type { eventWithTime } from '@rrweb/types'

export interface StartSessionRequest {
  name?: string
  stoppedAt?: string | number
  sessionAttributes?: ISessionAttributes
  resourceAttributes?: IResourceAttributes
  userAttributes?: IUserAttributes
  debugSessionData?: Record<string, any>
  tags?: { key?: string; value: string }[]
}

export interface StopSessionRequest {
  sessionAttributes?: ISessionAttributes
  stoppedAt: string | number
}

export interface CheckRemoteSessionRequest {
  sessionAttributes?: ISessionAttributes
  resourceAttributes?: IResourceAttributes
  userAttributes?: IUserAttributes
}

export interface CreateErrorSpanSessionRequest {
  span: any
}

export class ApiService {
  private config?: ApiServiceConfig
  private baseUrl: string = 'https://api.multiplayer.app'

  constructor() {
    this.config = {
      apiKey: '',
      apiBaseUrl: '',
      exporterEndpoint: '',
    }
  }

  init(config: ApiServiceConfig): void {
    this.config = {
      ...this.config,
      ...config,
    }
    if (config.apiBaseUrl) {
      this.baseUrl = config.apiBaseUrl
    }
  }

  /**
   * Update the API service configuration
   * @param config - Partial configuration to update
   */
  public updateConfigs(config: Partial<ApiServiceConfig>) {
    if (this.config) {
      this.config = { ...this.config, ...config }
    }
  }

  /**
   * Set the API key
   * @param apiKey - The API key to set
   */
  setApiKey(apiKey: string): void {
    if (this.config) {
      this.config.apiKey = apiKey
    }
  }

  /**
   * Create a new error span session
   * @param request - Session create error span request data
   * @param signal - Optional AbortSignal for request cancellation
   */
  createErrorSession(
    request: CreateErrorSpanSessionRequest,
    signal?: AbortSignal,
  ): Promise<any> {
    return this.makeRequest(
      '/debug-sessions/error-span/start',
      'POST',
      request,
      signal,
    )
  }

  updateSessionAttributes(
    sessionId: string,
    requestBody: {
      name?: string
      startedAt?: string
      stoppedAt?: string
      userAttributes?: IUserAttributes
      sessionAttributes?: ISessionAttributes
      resourceAttributes?: IResourceAttributes
    },
    signal?: AbortSignal,
  ): Promise<any> {
    return this.makeRequest(
      `/debug-sessions/${sessionId}`,
      'PATCH',
      requestBody,
      signal,
    )
  }

  /**
   * Export events to the session debugger API
   * @param sessionId - ID of the session to export events
   * @param requestBody - Request body containing events
   * @param signal - Optional AbortSignal for request cancellation
   */
  exportEvents(
    sessionId: string,
    requestBody: { events: eventWithTime[] },
    signal?: AbortSignal,
  ): Promise<any> {
    return this.makeRequest(
      `/debug-sessions/${sessionId}/rrweb-events`,
      'POST',
      requestBody,
      signal,
    )
  }

  /**
   * Start a new debug session
   * @param request - Session start request data
   * @param signal - Optional AbortSignal for request cancellation
   */
  startSession(
    request: StartSessionRequest,
    signal?: AbortSignal,
  ): Promise<any> {
    return this.makeRequest('/debug-sessions/start', 'POST', request, signal)
  }

  /**
   * Stop an active debug session
   * @param sessionId - ID of the session to stop
   * @param request - Session stop request data
   */
  stopSession(sessionId: string, request: StopSessionRequest): Promise<any> {
    return this.makeRequest(
      `/debug-sessions/${sessionId}/stop`,
      'PATCH',
      request,
    )
  }

  /**
   * Cancel an active debug session
   * @param sessionId - ID of the session to cancel
   */
  cancelSession(sessionId: string): Promise<any> {
    return this.makeRequest(`/debug-sessions/${sessionId}/cancel`, 'DELETE')
  }

  /**
   * Start a new continuous debug session
   * @param request - Session start request data
   * @param signal - Optional AbortSignal for request cancellation
   */
  startContinuousDebugSession(
    request: StartSessionRequest,
    signal?: AbortSignal,
  ): Promise<any> {
    return this.makeRequest(
      '/continuous-debug-sessions/start',
      'POST',
      request,
      signal,
    )
  }

  /**
   * Save a continuous debug session
   * @param sessionId - ID of the session to save
   * @param request - Session save request data
   * @param signal - Optional AbortSignal for request cancellation
   */
  saveContinuousDebugSession(
    sessionId: string,
    request: StartSessionRequest,
    signal?: AbortSignal,
  ): Promise<any> {
    return this.makeRequest(
      `/continuous-debug-sessions/${sessionId}/save`,
      'POST',
      request,
      signal,
    )
  }

  /**
   * Stop an active continuous debug session
   * @param sessionId - ID of the session to stop
   */
  stopContinuousDebugSession(sessionId: string): Promise<any> {
    return this.makeRequest(
      `/continuous-debug-sessions/${sessionId}/cancel`,
      'DELETE',
    )
  }

  /**
   * Check debug session should be started remotely
   */
  checkRemoteSession(
    requestBody: CheckRemoteSessionRequest,
    signal?: AbortSignal,
  ): Promise<{ state: 'START' | 'STOP' }> {
    return this.makeRequest(
      '/remote-debug-session/check',
      'POST',
      requestBody,
      signal,
    )
  }

  /**
   * Make a request to the session debugger API
   * @param path - API endpoint path (relative to the base URL)
   * @param method - HTTP method (GET, POST, PATCH, etc.)
   * @param body - request payload
   * @param signal - AbortSignal to set request's signal
   */
  private async makeRequest(
    path: string,
    method: string,
    body?: any,
    signal?: AbortSignal,
  ): Promise<any> {
    const url = `${this.baseUrl}/v0/radar${path}`
    const params = {
      method,
      body: body ? JSON.stringify(body) : null,
      headers: {
        'Content-Type': 'application/json',
        ...(this.config?.apiKey && { 'X-Api-Key': this.config.apiKey }),
      },
    }

    try {
      const response = await fetch(url, {
        ...params,
        signal,
      })

      if (!response.ok) {
        throw new Error('Network response was not ok: ' + response.statusText)
      }

      if (response.status === 204) {
        return null
      }

      return await response.json()
    } catch (error: any) {
      if (error?.name === 'AbortError') {
        throw new Error('Request aborted')
      }
      throw new Error('Error making request: ' + error.message)
    }
  }
}