/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

/**
 * This module implements the `Event` interface from the DOM.
 * See https://dom.spec.whatwg.org/#interface-event.
 */

import { setPlatformObject } from '../webidl/PlatformObjects'
import type RNEventTarget from './EventTarget'
import {
  getComposedPath,
  getCurrentTarget,
  getEventPhase,
  getInPassiveListenerFlag,
  getIsTrusted,
  getTarget,
  setStopImmediatePropagationFlag,
  setStopPropagationFlag,
  setIsTrusted,
  setEventPhase,
} from './internals/EventInternals'

export interface EventInit {
  bubbles?: boolean
  cancelable?: boolean
  composed?: boolean
}

export type EventPhase = 0 | 1 | 2 | 3

export default class Event {
  static NONE: 0
  static CAPTURING_PHASE: 1
  static AT_TARGET: 2
  static BUBBLING_PHASE: 3

  readonly NONE!: 0
  readonly CAPTURING_PHASE!: 1
  readonly AT_TARGET!: 2
  readonly BUBBLING_PHASE!: 3

  private _bubbles: boolean
  private _cancelable: boolean
  private _composed: boolean
  private _type: string

  private _defaultPrevented: boolean = false
  private _timeStamp: number = performance.now()

  // Symbol-keyed fields are internal and managed via helpers; not declared here.

  constructor(type: string, options?: EventInit | null) {
    if (arguments.length < 1) {
      throw new TypeError("Failed to construct 'Event': 1 argument required, but only 0 present.")
    }

    const typeOfOptions = typeof options
    if (options != null && typeOfOptions !== 'object' && typeOfOptions !== 'function') {
      throw new TypeError(
        "Failed to construct 'Event': The provided value is not of type 'EventInit'."
      )
    }

    this._type = String(type)
    this._bubbles = Boolean((options as EventInit | undefined)?.bubbles)
    this._cancelable = Boolean((options as EventInit | undefined)?.cancelable)
    this._composed = Boolean((options as EventInit | undefined)?.composed)

    // Initialize internal flags
    setIsTrusted(this, false)
    setEventPhase(this, 0 as 0)
  }

  get bubbles(): boolean {
    return this._bubbles
  }

  get cancelable(): boolean {
    return this._cancelable
  }

  get composed(): boolean {
    return this._composed
  }

  get currentTarget(): RNEventTarget | null {
    return getCurrentTarget(this)
  }

  get defaultPrevented(): boolean {
    return this._defaultPrevented
  }

  get eventPhase(): EventPhase {
    return getEventPhase(this)
  }

  get isTrusted(): boolean {
    return getIsTrusted(this)
  }

  get target(): RNEventTarget | null {
    return getTarget(this)
  }

  get timeStamp(): number {
    return this._timeStamp
  }

  get type(): string {
    return this._type
  }

  composedPath(): ReadonlyArray<RNEventTarget> {
    return getComposedPath(this).slice()
  }

  preventDefault(): void {
    if (!this._cancelable) {
      return
    }

    if (getInPassiveListenerFlag(this)) {
      console.error(new Error('Unable to preventDefault inside passive event listener invocation.'))
      return
    }

    this._defaultPrevented = true
  }

  stopImmediatePropagation(): void {
    setStopPropagationFlag(this, true)
    setStopImmediatePropagationFlag(this, true)
  }

  stopPropagation(): void {
    setStopPropagationFlag(this, true)
  }
}

Object.defineProperty(Event, 'NONE', {
  enumerable: true,
  value: 0,
})

Object.defineProperty(Event.prototype, 'NONE', {
  enumerable: true,
  value: 0,
})

Object.defineProperty(Event, 'CAPTURING_PHASE', {
  enumerable: true,
  value: 1,
})

Object.defineProperty(Event.prototype, 'CAPTURING_PHASE', {
  enumerable: true,
  value: 1,
})

Object.defineProperty(Event, 'AT_TARGET', {
  enumerable: true,
  value: 2,
})

Object.defineProperty(Event.prototype, 'AT_TARGET', {
  enumerable: true,
  value: 2,
})

Object.defineProperty(Event, 'BUBBLING_PHASE', {
  enumerable: true,
  value: 3,
})

Object.defineProperty(Event.prototype, 'BUBBLING_PHASE', {
  enumerable: true,
  value: 3,
})

setPlatformObject(Event)