Event System

/**
 * Base Event interface for all DOM events
 */
external class Event(type: String, eventInitDict: EventInit = definedExternally) {
    /** The event type */
    val type: String
    /** The event target */
    val target: EventTarget?
    /** The current event target during propagation */
    val currentTarget: EventTarget?
    /** The event phase (capturing, at target, bubbling) */
    val eventPhase: Short
    /** Whether the event bubbles */
    val bubbles: Boolean
    /** Whether the event is cancelable */
    val cancelable: Boolean
    /** Whether preventDefault has been called */
    val defaultPrevented: Boolean
    /** Whether the event is composed */
    val composed: Boolean
    /** Whether the event is trusted */
    val isTrusted: Boolean
    /** The event timestamp */
    val timeStamp: Double
    
    /** Prevent the default action */
    fun preventDefault()
    /** Stop event propagation */
    fun stopPropagation()
    /** Stop immediate event propagation */
    fun stopImmediatePropagation()
    /** Initialize the event (deprecated) */
    fun initEvent(type: String, bubbles: Boolean, cancelable: Boolean)
    
    companion object {
        const val NONE: Short = 0
        const val CAPTURING_PHASE: Short = 1
        const val AT_TARGET: Short = 2
        const val BUBBLING_PHASE: Short = 3
    }
}

/**
 * Event target interface for objects that can receive events
 */
external interface EventTarget {
    /** Add event listener */
    fun addEventListener(type: String, callback: EventListener?, options: dynamic = definedExternally)
    /** Remove event listener */
    fun removeEventListener(type: String, callback: EventListener?, options: dynamic = definedExternally)
    /** Dispatch event */
    fun dispatchEvent(event: Event): Boolean
}

/**
 * Event listener interface
 */
external interface EventListener {
    fun handleEvent(event: Event)
}

/**
 * Event initialization options
 */
external interface EventInit {
    var bubbles: Boolean?
    var cancelable: Boolean?
    var composed: Boolean?
}

/**
 * Add event listener options
 */
external interface AddEventListenerOptions : EventListenerOptions {
    var passive: Boolean?
    var once: Boolean?
    var signal: AbortSignal?
}

external interface EventListenerOptions {
    var capture: Boolean?
}

/**
 * UI Event for user interface interactions
 */
external class UIEvent(type: String, eventInitDict: UIEventInit = definedExternally) : Event {
    /** The view (window) where the event occurred */
    val view: Window?
    /** Additional detail about the event */
    val detail: Int
}

external interface UIEventInit : EventInit {
    var view: Window?
    var detail: Int?
}

/**
 * Focus events for element focus changes
 */
external class FocusEvent(type: String, eventInitDict: FocusEventInit = definedExternally) : UIEvent {
    /** The element losing or gaining focus */
    val relatedTarget: EventTarget?
}

external interface FocusEventInit : UIEventInit {
    var relatedTarget: EventTarget?
}

/**
 * Mouse events for mouse interactions
 */
external class MouseEvent(type: String, eventInitDict: MouseEventInit = definedExternally) : UIEvent {
    /** X coordinate relative to screen */
    val screenX: Int
    /** Y coordinate relative to screen */
    val screenY: Int
    /** X coordinate relative to client area */  
    val clientX: Int
    /** Y coordinate relative to client area */
    val clientY: Int
    /** Whether Ctrl key was pressed */
    val ctrlKey: Boolean
    /** Whether Shift key was pressed */
    val shiftKey: Boolean
    /** Whether Alt key was pressed */
    val altKey: Boolean
    /** Whether Meta key was pressed */
    val metaKey: Boolean
    /** Mouse button that was pressed */
    val button: Short
    /** Bitmask of pressed mouse buttons */
    val buttons: Short
    /** Related target element */
    val relatedTarget: EventTarget?
    
    /** Get modifier key state */
    fun getModifierState(keyArg: String): Boolean
    
    companion object {
        const val BUTTON_LEFT: Short = 0
        const val BUTTON_MIDDLE: Short = 1
        const val BUTTON_RIGHT: Short = 2
        const val BUTTON_BACK: Short = 3
        const val BUTTON_FORWARD: Short = 4
    }
}

external interface MouseEventInit : EventModifierInit {
    var screenX: Int?
    var screenY: Int?
    var clientX: Int?
    var clientY: Int?
    var button: Short?
    var buttons: Short?
    var relatedTarget: EventTarget?
}

/**
 * Wheel events for mouse wheel interactions
 */
external class WheelEvent(type: String, eventInitDict: WheelEventInit = definedExternally) : MouseEvent {
    /** Horizontal scroll delta */
    val deltaX: Double
    /** Vertical scroll delta */
    val deltaY: Double
    /** Z-axis scroll delta */
    val deltaZ: Double
    /** Delta mode (pixel, line, or page) */
    val deltaMode: Int
    
    companion object {
        const val DOM_DELTA_PIXEL: Int = 0
        const val DOM_DELTA_LINE: Int = 1
        const val DOM_DELTA_PAGE: Int = 2
    }
}

external interface WheelEventInit : MouseEventInit {
    var deltaX: Double?
    var deltaY: Double?
    var deltaZ: Double?
    var deltaMode: Int?
}

/**
 * Keyboard events for key input
 */
external class KeyboardEvent(type: String, eventInitDict: KeyboardEventInit = definedExternally) : UIEvent {
    /** The key value */
    val key: String
    /** The physical key code */
    val code: String
    /** The key location */
    val location: Int
    /** Whether Ctrl key was pressed */
    val ctrlKey: Boolean
    /** Whether Shift key was pressed */
    val shiftKey: Boolean
    /** Whether Alt key was pressed */
    val altKey: Boolean
    /** Whether Meta key was pressed */
    val metaKey: Boolean
    /** Whether the key is being held down */
    val repeat: Boolean
    /** Whether the key is part of composition */
    val isComposing: Boolean
    
    /** Get modifier key state */
    fun getModifierState(keyArg: String): Boolean
    
    companion object {
        const val DOM_KEY_LOCATION_STANDARD: Int = 0
        const val DOM_KEY_LOCATION_LEFT: Int = 1
        const val DOM_KEY_LOCATION_RIGHT: Int = 2
        const val DOM_KEY_LOCATION_NUMPAD: Int = 3
    }
}

external interface KeyboardEventInit : EventModifierInit {
    var key: String?
    var code: String?
    var location: Int?
    var repeat: Boolean?
    var isComposing: Boolean?
}

/**
 * Input events for text input changes
 */
external class InputEvent(type: String, eventInitDict: InputEventInit = definedExternally) : UIEvent {
    /** The input data */
    val data: String?
    /** The data transfer object */
    val dataTransfer: DataTransfer?
    /** The input type */
    val inputType: String
    /** Whether the input is composing */
    val isComposing: Boolean
}

external interface InputEventInit : UIEventInit {
    var data: String?
    var dataTransfer: DataTransfer?
    var inputType: String?
    var isComposing: Boolean?
}

/**
 * Composition events for text composition
 */
external class CompositionEvent(type: String, eventInitDict: CompositionEventInit = definedExternally) : UIEvent {
    /** The composition data */
    val data: String
}

external interface CompositionEventInit : UIEventInit {
    var data: String?
}

/**
 * Pointer events for unified input handling
 */
external class PointerEvent(type: String, eventInitDict: PointerEventInit = definedExternally) : MouseEvent {
    /** Unique pointer identifier */
    val pointerId: Int
    /** Contact width */
    val width: Double
    /** Contact height */
    val height: Double
    /** Contact pressure */
    val pressure: Float
    /** Tangential pressure */
    val tangentialPressure: Float
    /** X-axis tilt */
    val tiltX: Int
    /** Y-axis tilt */
    val tiltY: Int
    /** Pointer twist/rotation */
    val twist: Int
    /** Pointer type (mouse, pen, touch) */
    val pointerType: String
    /** Whether this is the primary pointer */
    val isPrimary: Boolean
}

external interface PointerEventInit : MouseEventInit {
    var pointerId: Int?
    var width: Double?
    var height: Double?
    var pressure: Float?
    var tangentialPressure: Float?
    var tiltX: Int?
    var tiltY: Int?
    var twist: Int?
    var pointerType: String?
    var isPrimary: Boolean?
}

/**
 * Touch events for touch input
 */
external class TouchEvent(type: String, eventInitDict: TouchEventInit = definedExternally) : UIEvent {
    /** List of current touches */
    val touches: TouchList
    /** List of touches on the target element */
    val targetTouches: TouchList
    /** List of changed touches */
    val changedTouches: TouchList
    /** Whether Alt key was pressed */
    val altKey: Boolean
    /** Whether Meta key was pressed */
    val metaKey: Boolean
    /** Whether Ctrl key was pressed */
    val ctrlKey: Boolean
    /** Whether Shift key was pressed */
    val shiftKey: Boolean
}

external interface TouchEventInit : EventModifierInit {
    var touches: Array<Touch>?
    var targetTouches: Array<Touch>?
    var changedTouches: Array<Touch>?
}

/**
 * Individual touch point
 */
external interface Touch {
    /** Touch identifier */
    val identifier: Int
    /** Touch target */
    val target: EventTarget
    /** Screen X coordinate */
    val screenX: Int
    /** Screen Y coordinate */
    val screenY: Int
    /** Client X coordinate */
    val clientX: Int
    /** Client Y coordinate */
    val clientY: Int
    /** Page X coordinate */
    val pageX: Int
    /** Page Y coordinate */
    val pageY: Int
    /** Touch radius X */
    val radiusX: Float
    /** Touch radius Y */
    val radiusY: Float
    /** Rotation angle */
    val rotationAngle: Float
    /** Touch pressure */
    val force: Float
}

/**
 * Collection of touches
 */
external interface TouchList : ItemArrayLike<Touch> {
    /** Get touch by identifier */
    fun identifiedTouch(identifier: Int): Touch?
}

/**
 * Drag events for drag and drop operations
 */
external class DragEvent(type: String, eventInitDict: DragEventInit = definedExternally) : MouseEvent {
    /** The drag data transfer object */
    val dataTransfer: DataTransfer?
}

external interface DragEventInit : MouseEventInit {
    var dataTransfer: DataTransfer?
}

/**
 * Data transfer object for drag operations
 */
external interface DataTransfer {
    /** The drop effect */
    var dropEffect: String
    /** The effective allowed effect */
    var effectAllowed: String
    /** The drag items */
    val items: DataTransferItemList
    /** The drag types */
    val types: Array<String>
    /** The drag files */
    val files: FileList
    
    /** Clear drag data */
    fun clearData(format: String = definedExternally)
    /** Get drag data */
    fun getData(format: String): String
    /** Set drag data */
    fun setData(format: String, data: String)
    /** Set drag image */
    fun setDragImage(image: Element, x: Int, y: Int)
}

external interface DataTransferItemList : ItemArrayLike<DataTransferItem> {
    /** Add drag item */
    fun add(data: String, type: String): DataTransferItem?
    /** Add file item */
    fun add(data: File): DataTransferItem?
    /** Remove item */
    fun remove(index: Int)
    /** Clear all items */
    fun clear()
}

external interface DataTransferItem {
    /** Item kind */
    val kind: String
    /** Item type */
    val type: String
    /** Get item as string */
    fun getAsString(callback: ((String) -> Unit)?)
    /** Get item as file */
    fun getAsFile(): File?
}

/**
 * Custom events for application-specific events
 */
external class CustomEvent<T>(type: String, eventInitDict: CustomEventInit<T> = definedExternally) : Event {
    /** Custom event detail data */
    val detail: T
    
    /** Initialize custom event (deprecated) */
    fun initCustomEvent(type: String, bubbles: Boolean, cancelable: Boolean, detail: T)
}

external interface CustomEventInit<T> : EventInit {
    var detail: T?
}

/**
 * Event modifier init interface
 */
external interface EventModifierInit : UIEventInit {
    var ctrlKey: Boolean?
    var shiftKey: Boolean?
    var altKey: Boolean?
    var metaKey: Boolean?
}

/**
 * Abort signal for canceling event listeners
 */
external interface AbortSignal : EventTarget {
    /** Whether the signal is aborted */
    val aborted: Boolean
    /** The abort reason */
    val reason: Any?
}

/**
 * Event listener factory function
 */
fun EventListener(handler: (Event) -> Unit): EventListener

import kotlinx.browser.document
import kotlinx.browser.window
import org.w3c.dom.events.*
import org.w3c.dom.*

// Basic event handling
val button = document.createElement("button") as HTMLButtonElement
button.textContent = "Click me"

button.addEventListener("click") { event ->
    val mouseEvent = event as MouseEvent
    console.log("Button clicked at (${mouseEvent.clientX}, ${mouseEvent.clientY})")
    event.preventDefault()
}

// Keyboard event handling
document.addEventListener("keydown") { event ->
    val keyEvent = event as KeyboardEvent
    when {
        keyEvent.ctrlKey && keyEvent.key == "s" -> {
            event.preventDefault()
            console.log("Save shortcut pressed")
        }
        keyEvent.key == "Escape" -> {
            console.log("Escape pressed")
        }
    }
}

// Touch event handling
val touchArea = document.getElementById("touch-area")
touchArea?.addEventListener("touchstart") { event ->
    val touchEvent = event as TouchEvent
    touchEvent.changedTouches.asList().forEach { touch ->
        console.log("Touch started at (${touch.clientX}, ${touch.clientY})")
    }
    event.preventDefault()
}

// Custom events
val customEvent = CustomEvent("myCustomEvent", object : CustomEventInit<String> {
    override var detail = "Hello from custom event"
    override var bubbles = true
})

document.addEventListener("myCustomEvent") { event ->
    val custom = event as CustomEvent<String>
    console.log("Custom event received: ${custom.detail}")
}

document.dispatchEvent(customEvent)

// Event delegation
document.addEventListener("click") { event ->
    val target = event.target as? Element
    if (target?.classList?.contains("button") == true) {
        console.log("Delegated button click")
    }
}

// Modern event listener options
button.addEventListener("click", object : AddEventListenerOptions {
    override var once = true
    override var passive = true
}) { event ->
    console.log("This listener will only fire once")
}