import type { TimeStamp } from '@datadog/browser-core'
import { elapsed, timeStampNow } from '@datadog/browser-core'

import { ChangeType, RecordType, SnapshotFormat } from '../../../types'
import type {
  AddCDataSectionNodeChange,
  AddDocTypeNodeChange,
  AddDocumentFragmentNodeChange,
  AddDocumentNodeChange,
  AddElementNodeChange,
  AddNodeChange,
  AddShadowRootNodeChange,
  AddTextNodeChange,
  AttachedStyleSheetsChange,
  AttributeChange,
  InsertionPoint,
  MediaInteractionType,
  StyleSheetMediaList,
  StyleSheetRules,
} from '../../../types'
import type { NodeId, StyleSheetId } from '../itemIds'
import type { EmitRecordCallback, EmitStatsCallback } from '../record.types'
import type { RecordingScope } from '../recordingScope'
import type { SerializationStats } from './serializationStats'
import { createSerializationStats, updateSerializationStats } from './serializationStats'
import { createChangeEncoder } from './changeEncoder'

export const enum SerializationKind {
  INITIAL_FULL_SNAPSHOT,
  SUBSEQUENT_FULL_SNAPSHOT,
  INCREMENTAL_SNAPSHOT,
}

type AddNodeParams<NodeChange extends AddNodeChange> = NodeChange extends [any, any, ...infer Params] ? Params : never

export type ChangeSerializationTransactionCallback = (transaction: ChangeSerializationTransaction) => void

/**
 * ChangeSerializationTransaction is used to build and emit a BrowserChangeRecord
 * containing a serialized snapshot of the DOM. Unlike SerializationTransaction, it
 * doesn't support emitting arbitrary BrowserRecords; instead, the builder methods it
 * exposes are used to construct a single BrowserChangeRecord which is emitted at the end
 * of the transaction.
 */
export interface ChangeSerializationTransaction {
  /**
   * Add a metric to the transaction's statistics. The aggregated statistics will be
   * emitted when the transaction ends.
   */
  addMetric(metric: keyof SerializationStats, value: number): void

  /** Add a node to the document at the given insertion point. */
  addNode(pos: InsertionPoint, nodeName: '#cdata-section', ...params: AddNodeParams<AddCDataSectionNodeChange>): void
  addNode(pos: InsertionPoint, nodeName: '#doctype', ...params: AddNodeParams<AddDocTypeNodeChange>): void
  addNode(pos: InsertionPoint, nodeName: '#document', ...params: AddNodeParams<AddDocumentNodeChange>): void
  addNode(
    pos: InsertionPoint,
    nodeName: '#document-fragment',
    ...params: AddNodeParams<AddDocumentFragmentNodeChange>
  ): void
  addNode(pos: InsertionPoint, nodeName: '#shadow-root', ...params: AddNodeParams<AddShadowRootNodeChange>): void
  addNode(pos: InsertionPoint, nodeName: '#text', ...params: AddNodeParams<AddTextNodeChange>): void
  addNode(
    pos: InsertionPoint,
    nodeName: Exclude<string, `#${string}`>,
    ...params: AddNodeParams<AddElementNodeChange>
  ): void
  addNode(pos: InsertionPoint, nodeName: string, ...params: AddNodeParams<AddNodeChange>): void

  /** Add a stylesheet to the document. */
  addStyleSheet(rules: StyleSheetRules, mediaList?: StyleSheetMediaList, disabled?: boolean): void

  /**
   * Attach one or more stylesheets to a <link>, <style>, #document, #document-fragment,
   * or #shadow-root node.
   */
  attachStyleSheets(nodeId: NodeId, sheetIds: StyleSheetId[]): void

  /** Remove a node from the document. */
  removeNode(nodeId: NodeId): void

  /** Set a node's attributes to the given values. */
  setAttributes(change: AttributeChange): void

  /** Set the media playback state of an <audio> or <video> element. */
  setMediaPlaybackState(nodeId: NodeId, state: MediaInteractionType): void

  /** Set the given node's scroll position in CSS pixels. */
  setScrollPosition(nodeId: NodeId, x: number, y: number): void

  /** Set the given node's size in CSS pixels. */
  setSize(nodeId: NodeId, width: number, height: number): void

  /** Set the given node's text content. */
  setText(nodeId: NodeId, content: string): void

  /** The kind of serialization being performed in this transaction. */
  kind: SerializationKind

  /** The recording scope in which this transaction is occurring. */
  scope: RecordingScope
}

export function serializeChangesInTransaction(
  kind: SerializationKind,
  emitRecord: EmitRecordCallback,
  emitStats: EmitStatsCallback,
  scope: RecordingScope,
  timestamp: TimeStamp,
  serialize: ChangeSerializationTransactionCallback
): void {
  const encoder = createChangeEncoder(scope.stringIds)
  const stats = createSerializationStats()

  const transaction: ChangeSerializationTransaction = {
    addMetric(metric: keyof SerializationStats, value: number): void {
      updateSerializationStats(stats, metric, value)
    },
    addNode(...change): void {
      encoder.add(ChangeType.AddNode, change as AddNodeChange)
    },
    addStyleSheet(rules: StyleSheetRules, mediaList?: StyleSheetMediaList, disabled?: boolean): void {
      if (disabled) {
        encoder.add(ChangeType.AddStyleSheet, [rules, mediaList || [], disabled])
      } else if (mediaList) {
        encoder.add(ChangeType.AddStyleSheet, [rules, mediaList])
      } else {
        encoder.add(ChangeType.AddStyleSheet, [rules])
      }
    },
    attachStyleSheets(nodeId: NodeId, sheetIds: StyleSheetId[]): void {
      const change: AttachedStyleSheetsChange = [nodeId]
      for (const sheetId of sheetIds) {
        change.push(sheetId)
      }
      encoder.add(ChangeType.AttachedStyleSheets, change)
    },
    removeNode(nodeId: NodeId): void {
      encoder.add(ChangeType.RemoveNode, nodeId)
    },
    setAttributes(change: AttributeChange): void {
      encoder.add(ChangeType.Attribute, change)
    },
    setMediaPlaybackState(nodeId: NodeId, state: MediaInteractionType): void {
      encoder.add(ChangeType.MediaPlaybackState, [nodeId, state])
    },
    setScrollPosition(nodeId: NodeId, x: number, y: number): void {
      encoder.add(ChangeType.ScrollPosition, [nodeId, x, y])
    },
    setSize(nodeId: NodeId, width: number, height: number): void {
      encoder.add(ChangeType.Size, [nodeId, width, height])
    },
    setText(nodeId: NodeId, content: string): void {
      encoder.add(ChangeType.Text, [nodeId, content])
    },
    kind,
    scope,
  }

  const start = timeStampNow()
  serialize(transaction)
  updateSerializationStats(stats, 'serializationDuration', elapsed(start, timeStampNow()))

  const changes = encoder.flush()
  if (changes.length > 0) {
    if (kind === SerializationKind.INITIAL_FULL_SNAPSHOT || kind === SerializationKind.SUBSEQUENT_FULL_SNAPSHOT) {
      emitRecord({
        data: changes,
        format: SnapshotFormat.Change,
        type: RecordType.FullSnapshot,
        timestamp,
      })
    } else {
      emitRecord({
        data: changes,
        type: RecordType.Change,
        timestamp,
      })
    }
  }

  emitStats(stats)
}