'use strict'

const { InvalidArgumentError } = require('../core/errors')

module.exports = class WrapHandler {
  #handler

  constructor (handler) {
    this.#handler = handler
  }

  static wrap (handler) {
    // TODO (fix): More checks...
    return handler.onRequestStart ? handler : new WrapHandler(handler)
  }

  // Unwrap Interface

  onConnect (abort, context) {
    return this.#handler.onConnect?.(abort, context)
  }

  onHeaders (statusCode, rawHeaders, resume, statusMessage) {
    return this.#handler.onHeaders?.(statusCode, rawHeaders, resume, statusMessage)
  }

  onUpgrade (statusCode, rawHeaders, socket) {
    return this.#handler.onUpgrade?.(statusCode, rawHeaders, socket)
  }

  onData (data) {
    return this.#handler.onData?.(data)
  }

  onComplete (trailers) {
    return this.#handler.onComplete?.(trailers)
  }

  onError (err) {
    if (!this.#handler.onError) {
      throw err
    }

    return this.#handler.onError?.(err)
  }

  // Wrap Interface

  onRequestStart (controller, context) {
    this.#handler.onConnect?.((reason) => controller.abort(reason), context)
  }

  onRequestUpgrade (controller, statusCode, headers, socket) {
    const rawHeaders = []
    for (const [key, val] of Object.entries(headers)) {
      rawHeaders.push(Buffer.from(key), Array.isArray(val) ? val.map(v => Buffer.from(v)) : Buffer.from(val))
    }

    this.#handler.onUpgrade?.(statusCode, rawHeaders, socket)
  }

  onResponseStart (controller, statusCode, headers, statusMessage) {
    const rawHeaders = []
    for (const [key, val] of Object.entries(headers)) {
      rawHeaders.push(Buffer.from(key), Array.isArray(val) ? val.map(v => Buffer.from(v)) : Buffer.from(val))
    }

    if (this.#handler.onHeaders?.(statusCode, rawHeaders, () => controller.resume(), statusMessage) === false) {
      controller.pause()
    }
  }

  onResponseData (controller, data) {
    if (this.#handler.onData?.(data) === false) {
      controller.pause()
    }
  }

  onResponseEnd (controller, trailers) {
    const rawTrailers = []
    for (const [key, val] of Object.entries(trailers)) {
      rawTrailers.push(Buffer.from(key), Array.isArray(val) ? val.map(v => Buffer.from(v)) : Buffer.from(val))
    }

    this.#handler.onComplete?.(rawTrailers)
  }

  onResponseError (controller, err) {
    if (!this.#handler.onError) {
      throw new InvalidArgumentError('invalid onError method')
    }

    this.#handler.onError?.(err)
  }
}