/**
 * @see https://github.com/expressjs/express/blob/master/lib/request.js
 */
import '../src/deps/polyfill'
import { toStringy } from '../src/deps/toStringy'
import { toSkavaSessionId } from '../src/deps/toSkavaSessionId'
import { encodeBody } from '../src/deps/encodeBody'
import {
  fromParamsToStringified,
  stringifyProperties,
  stringifyParamsRecursively,
} from '../src/deps/fromParamsToStringified'
import { fromNodeHttpRequestToFetchRequest } from '../src/deps/fromNodeHttpRequestToFetchRequest'
import { fromRequestToHash } from '../src/deps/fromRequestToHash'
import { isErrorLikeResponse } from '../src/deps/isErrorLikeResponse'
import { isJsonContentType } from '../src/deps/isJsonContentType'
import { isValidResponseWithHeaders } from '../src/deps/isValidResponseWithHeaders'
import { toHeaders, cloneHeaders } from '../src/deps/toHeaders'
import { toOptions } from '../src/deps/toOptions'
import { validateRequestStore } from '../src/deps/validate'
import { assignConstantHeaders } from '../src/deps/assignConstantHeaders'
import { assignConstantParams } from '../src/deps/assignConstantParams'
import { assignConstants } from '../src/deps/assignConstants'
import { toAuth } from '../src/deps/toAuth'
import { fromHeadersToSerialized } from '../src/deps/fromHeadersToSerialized'
import { cloneURL } from '../src/deps/cloneURL'
import { MockIncomingMessage } from '../src/testHelpers/MockRequest'

/**
 * @todo should test param stringify too
 */
describe('deps', () => {
  it('should work with cloneURL', () => {
    const url = new URL('http://localhost:4000')
    const cloned = cloneURL(url)
    expect(url === cloned).not.toBe(true)
    expect(url.href).toEqual(cloned.href)
  })
  it('should work with fromHeadersToSerialized', () => {
    const headers = new Headers()
    headers.set('canada', 'eh')
    const serialized = fromHeadersToSerialized(headers)
    expect(serialized).toEqual({ canada: 'eh' })
  })

  it('should convert fromNodeHttpRequestToFetchRequest', () => {
    const req = new MockIncomingMessage({
      method: 'PUT',
      url: '/stuff?q=thing',
      headers: {
        Accept: 'text/plain',
      },
    })
    const converted = fromNodeHttpRequestToFetchRequest(req)
    expect(converted).toBeInstanceOf(Request)
  })
  it.skip('cookies', () => {
    // todo
  })
  it.skip('correctly encode a body', () => {
    // todo
  })
  it.skip('should convert a node stream request to global.Request', () => {
    // todo
  })
  it.skip('should a request to a hash', () => {
    // todo
  })
  it.skip('should correctly & not-incorrectly identify a json content type', () => {
    // todo
  })
  it.skip('should assign constants based on the config', () => {
    // todo
  })
  it.skip('should be immutable and completely clone headers', () => {
    // todo
  })

  it('should stringify', () => {
    const actual = [
      toStringy(''),
      toStringy(null),
      toStringy(undefined),
      toStringy({}),
      toStringy([]),
      toStringy([
        {
          undefined,
          null: null,
          string: 'string',
          obj: {
            isObj: true,
          },
        },
      ]),
      toStringy([
        {
          undefined,
          null: null,
          string: 'string',

          // !!! not double encode
          obj: JSON.stringify({
            isObj: true,
          }),
        },
      ]),
    ]
    const expected = [
      '',
      '',
      '',
      '{}',
      '[]',
      `[{"undefined":"","null":"","string":"string","obj":{"isObj":true}}]`,
      // what it would be with nested stringify... even with escape removed
      // `[{"undefined":"","null":"","string":"string","obj":"{"isObj":true}"}]`,
      `[{"undefined":"","null":"","string":"string","obj":{"isObj":true}}]`,
    ]

    actual.forEach((value, index) => {
      expect(value).toEqual(expected[index])
    })
  })
  describe('tests for toSkavaSessionId', () => {
    it('should return session-id if exists', () => {
      expect(toSkavaSessionId('x-sk-session-id=1234567890')).toEqual(
        '1234567890'
      )
      expect(
        toSkavaSessionId(
          'testCookie=12221;x-sk-session-id=1234567890;testCookie2=123456'
        )
      ).toEqual('1234567890')
    })
    it('should return false if session-id does not exists', () => {
      expect(toSkavaSessionId('testCookie=1234567890')).toEqual(false)
      expect(
        toSkavaSessionId('testCookie=1234567890;testCookie2=123456')
      ).toEqual(false)
    })
  })
})