'use strict'

const { test, describe, after } = require('node:test')
const { WebSocketServer } = require('ws')
const { MessageEvent, CloseEvent, ErrorEvent } = require('../../lib/web/websocket/events')
const { WebSocket } = require('../..')

test('MessageEvent', (t) => {
  t.assert.throws(() => new MessageEvent(), TypeError, 'no arguments')
  t.assert.throws(() => new MessageEvent('').initMessageEvent(), TypeError)

  const noInitEvent = new MessageEvent('message')

  t.assert.strictEqual(noInitEvent.origin, '')
  t.assert.strictEqual(noInitEvent.data, null)
  t.assert.strictEqual(noInitEvent.lastEventId, '')
  t.assert.strictEqual(noInitEvent.source, null)
  t.assert.ok(Array.isArray(noInitEvent.ports))
  t.assert.ok(Object.isFrozen(noInitEvent.ports))
  t.assert.ok(new MessageEvent('').initMessageEvent('message') instanceof MessageEvent)
})

test('CloseEvent', (t) => {
  t.assert.throws(() => new CloseEvent(), TypeError)

  const noInitEvent = new CloseEvent('close')

  t.assert.strictEqual(noInitEvent.wasClean, false)
  t.assert.strictEqual(noInitEvent.code, 0)
  t.assert.strictEqual(noInitEvent.reason, '')
})

test('ErrorEvent', (t) => {
  t.assert.throws(() => new ErrorEvent(), TypeError)

  const noInitEvent = new ErrorEvent('error')

  t.assert.strictEqual(noInitEvent.message, '')
  t.assert.strictEqual(noInitEvent.filename, '')
  t.assert.strictEqual(noInitEvent.lineno, 0)
  t.assert.strictEqual(noInitEvent.colno, 0)
  t.assert.strictEqual(noInitEvent.error, undefined)
})

describe('Event handlers', () => {
  const server = new WebSocketServer({ port: 0 })
  const ws = new WebSocket(`ws://localhost:${server.address().port}`)

  after(() => {
    server.close()
    ws.close()
  })

  function listen () {}

  describe('onopen', () => {
    test('should be null initially', (t) => {
      t.assert.strictEqual(ws.onopen, null)
    })

    test('should not allow non-function assignments', (t) => {
      ws.onopen = 3
      t.assert.strictEqual(ws.onopen, null)
    })

    test('should allow function assignments', (t) => {
      ws.onopen = listen
      t.assert.strictEqual(ws.onopen, listen)
    })
  })

  describe('onerror', () => {
    test('should be null initially', (t) => {
      t.assert.strictEqual(ws.onerror, null)
    })

    test('should not allow non-function assignments', (t) => {
      ws.onerror = 3
      t.assert.strictEqual(ws.onerror, null)
    })

    test('should allow function assignments', (t) => {
      ws.onerror = listen
      t.assert.strictEqual(ws.onerror, listen)
    })
  })

  describe('onclose', () => {
    test('should be null initially', (t) => {
      t.assert.strictEqual(ws.onclose, null)
    })

    test('should not allow non-function assignments', (t) => {
      ws.onclose = 3
      t.assert.strictEqual(ws.onclose, null)
    })

    test('should allow function assignments', (t) => {
      ws.onclose = listen
      t.assert.strictEqual(ws.onclose, listen)
    })
  })

  describe('onmessage', () => {
    test('should be null initially', (t) => {
      t.assert.strictEqual(ws.onmessage, null)
    })

    test('should not allow non-function assignments', (t) => {
      ws.onmessage = 3
      t.assert.strictEqual(ws.onmessage, null)
    })

    test('should allow function assignments', (t) => {
      ws.onmessage = listen
      t.assert.strictEqual(ws.onmessage, listen)
    })
  })
})

describe('CloseEvent WPTs ported', () => {
  test('initCloseEvent', (t) => {
    // Taken from websockets/interfaces/CloseEvent/historical.html
    t.assert.ok(!('initCloseEvent' in CloseEvent.prototype))
    t.assert.ok(!('initCloseEvent' in new CloseEvent('close')))
  })

  test('CloseEvent constructor', (t) => {
    // Taken from websockets/interfaces/CloseEvent/constructor.html

    {
      const event = new CloseEvent('foo')

      t.assert.ok(event instanceof CloseEvent, 'should be a CloseEvent')
      t.assert.strictEqual(event.type, 'foo')
      t.assert.ok(!event.bubbles, 'bubbles')
      t.assert.ok(!event.cancelable, 'cancelable')
      t.assert.ok(!event.wasClean, 'wasClean')
      t.assert.strictEqual(event.code, 0)
      t.assert.strictEqual(event.reason, '')
    }

    {
      const event = new CloseEvent('foo', {
        bubbles: true,
        cancelable: true,
        wasClean: true,
        code: 7,
        reason: 'x'
      })
      t.assert.ok(event instanceof CloseEvent, 'should be a CloseEvent')
      t.assert.strictEqual(event.type, 'foo')
      t.assert.ok(event.bubbles, 'bubbles')
      t.assert.ok(event.cancelable, 'cancelable')
      t.assert.ok(event.wasClean, 'wasClean')
      t.assert.strictEqual(event.code, 7)
      t.assert.strictEqual(event.reason, 'x')
    }
  })
})

describe('ErrorEvent WPTs ported', () => {
  test('Synthetic ErrorEvent', (t) => {
    // Taken from html/webappapis/scripting/events/event-handler-processing-algorithm-error/document-synthetic-errorevent.html

    {
      const e = new ErrorEvent('error')
      t.assert.strictEqual(e.message, '')
      t.assert.strictEqual(e.filename, '')
      t.assert.strictEqual(e.lineno, 0)
      t.assert.strictEqual(e.colno, 0)
      t.assert.strictEqual(e.error, undefined)
    }

    {
      const e = new ErrorEvent('error', { error: null })
      t.assert.strictEqual(e.error, null)
    }

    {
      const e = new ErrorEvent('error', { error: undefined })
      t.assert.strictEqual(e.error, undefined)
    }

    {
      const e = new ErrorEvent('error', { error: 'foo' })
      t.assert.strictEqual(e.error, 'foo')
    }
  })

  test('webidl', (t) => {
    // Taken from webidl/ecmascript-binding/no-regexp-special-casing.any.js

    const regExp = new RegExp()
    regExp.message = 'some message'

    const errorEvent = new ErrorEvent('type', regExp)

    t.assert.strictEqual(errorEvent.message, 'some message')
  })

  test('initErrorEvent', (t) => {
    // Taken from workers/Worker_dispatchEvent_ErrorEvent.htm

    const e = new ErrorEvent('error')
    t.assert.ok(!('initErrorEvent' in e), 'should not be supported')
  })
})