import mockAxios from "jest-mock-axios"
import { Ecanna, EcannaCore } from "../src"
import { TKNVMAPI } from "../src/apis/tknvm/api"
import { AdminAPI } from "../src/apis/admin/api"
import { HealthAPI } from "../src/apis/health/api"
import { InfoAPI } from "../src/apis/info/api"
import { KeystoreAPI } from "../src/apis/keystore/api"
import { MetricsAPI } from "../src/apis/metrics/api"
import { StakeVMAPI } from "../src/apis/stakevm/api"
import { TestAPI } from "./testlib"
import { AxiosRequestConfig } from "axios"
import { HttpResponse } from "jest-mock-axios/dist/lib/mock-axios-types"

describe("Ecanna", (): void => {
  const blockchainID: string =
    "6h2s5de1VC65meajE1L2PjvZ1MXvHc3F6eqPCGKuDt4MxiweF"
  let host: string = "127.0.0.1"
  const port: number = 9650
  const networkID: number = 1337
  let protocol: string = "https"
  let ecanna: Ecanna
  let ecannaCore: EcannaCore
  const api: string = "api.ecna.com"
  const url: string = "https://api.ecna.com:9650"
  const encrypted: string = "https"
  const skipinit: boolean = true
  beforeAll((): void => {
    ecanna = new Ecanna(
      host,
      port,
      protocol,
      networkID,
      undefined,
      undefined,
      undefined,
      skipinit
    )
    ecanna.addAPI("admin", AdminAPI)
    ecanna.addAPI("tknchain", TKNVMAPI, "/ext/subnet/tknvm", blockchainID)
    ecanna.addAPI("health", HealthAPI)
    ecanna.addAPI("info", InfoAPI)
    ecanna.addAPI("keystore", KeystoreAPI)
    ecanna.addAPI("metrics", MetricsAPI)
    ecanna.addAPI("stkchain", StakeVMAPI)
  })
  test("Remove special characters", (): void => {
    host = "a&&&&p#i,.@a+v(a)x$.~n%e't:w*o?r<k>"
    protocol = "h@t&@&@t#p+s()$"
    ecanna = new Ecanna(host, port, protocol, networkID)
    expect(ecanna.getHost()).toBe(api)
    expect(ecanna.getProtocol()).toBe(encrypted)
    expect(ecanna.getURL()).toBe(url)
    ecannaCore = new EcannaCore(host, port, protocol)
    expect(ecannaCore.getHost()).toBe(api)
    expect(ecannaCore.getProtocol()).toBe(encrypted)
    expect(ecannaCore.getURL()).toBe(url)
  })
  test("Can specify base endpoint", (): void => {
    ecanna = new Ecanna()
    ecanna.setAddress(api, port, encrypted, "rpc")
    ecanna.setNetworkID(networkID)
    expect(ecanna.getHost()).toBe(api)
    expect(ecanna.getProtocol()).toBe(encrypted)
    expect(ecanna.getPort()).toBe(port)
    expect(ecanna.getBaseEndpoint()).toBe("rpc")
    expect(ecanna.getURL()).toBe(`${url}/rpc`)
    expect(ecanna.getNetworkID()).toBe(networkID)
  })
  test("Can initialize without port", (): void => {
    protocol = encrypted
    host = api
    ecanna = new Ecanna(host, undefined, protocol, networkID)
    expect(ecanna.getPort()).toBe(undefined)
    expect(ecanna.getURL()).toBe(`${protocol}://${api}`)
    ecannaCore = new EcannaCore(host, undefined, protocol)
    expect(ecannaCore.getPort()).toBe(undefined)
    expect(ecannaCore.getURL()).toBe(`${protocol}://${api}`)
  })
  test("Can initialize with port", (): void => {
    protocol = encrypted
    ecanna = new Ecanna(host, port, protocol, networkID)
    expect(ecanna.getIP()).toBe(host)
    expect(ecanna.getHost()).toBe(host)
    expect(ecanna.getPort()).toBe(port)
    expect(ecanna.getProtocol()).toBe(protocol)
    expect(ecanna.getURL()).toBe(`${protocol}://${host}:${port}`)
    expect(ecanna.getNetworkID()).toBe(1337)
    expect(ecanna.getHeaders()).toStrictEqual({})
    ecanna.setNetworkID(50)
    expect(ecanna.getNetworkID()).toBe(50)
    ecanna.setNetworkID(12345)
    expect(ecanna.getNetworkID()).toBe(12345)
  })

  test("Endpoints correct", (): void => {
    expect(ecanna.Admin()).not.toBeInstanceOf(TKNVMAPI)
    expect(ecanna.Admin()).toBeInstanceOf(AdminAPI)

    expect(ecanna.TKNChain()).not.toBeInstanceOf(AdminAPI)
    expect(ecanna.TKNChain()).toBeInstanceOf(TKNVMAPI)

    expect(ecanna.Health()).not.toBeInstanceOf(KeystoreAPI)
    expect(ecanna.Health()).toBeInstanceOf(HealthAPI)

    expect(ecanna.Info()).not.toBeInstanceOf(KeystoreAPI)
    expect(ecanna.Info()).toBeInstanceOf(InfoAPI)

    expect(ecanna.STKChain()).not.toBeInstanceOf(KeystoreAPI)
    expect(ecanna.STKChain()).toBeInstanceOf(StakeVMAPI)

    expect(ecanna.NodeKeys()).not.toBeInstanceOf(StakeVMAPI)
    expect(ecanna.NodeKeys()).toBeInstanceOf(KeystoreAPI)

    expect(ecanna.Metrics()).not.toBeInstanceOf(KeystoreAPI)
    expect(ecanna.Metrics()).toBeInstanceOf(MetricsAPI)

    expect(ecanna.Admin().getRPCID()).toBe(1)
    expect(ecanna.TKNChain().getRPCID()).toBe(1)
    expect(ecanna.STKChain().getRPCID()).toBe(1)
    expect(ecanna.NodeKeys().getRPCID()).toBe(1)
  })

  test("Create new API", (): void => {
    ecanna.addAPI("tknvm2", TKNVMAPI)
    expect(ecanna.api("tknvm2")).toBeInstanceOf(TKNVMAPI)

    ecanna.addAPI("keystore2", KeystoreAPI, "/ext/keystore2")
    expect(ecanna.api("keystore2")).toBeInstanceOf(KeystoreAPI)

    ecanna.api("keystore2").setBaseURL("/ext/keystore3")
    expect(ecanna.api("keystore2").getBaseURL()).toBe("/ext/keystore3")

    expect(ecanna.api("keystore2").getDB()).toHaveProperty("namespace")
  })

  test("Customize headers", (): void => {
    ecanna.setHeader("TKN-Custom-Header", "example")
    ecanna.setHeader("TKN-Foo", "Foo")
    ecanna.setHeader("TKN-Bar", "Bar")
    expect(ecanna.getHeaders()).toStrictEqual({
      "TKN-Custom-Header": "example",
      "TKN-Foo": "Foo",
      "TKN-Bar": "Bar"
    })
    ecanna.removeHeader("TKN-Foo")
    expect(ecanna.getHeaders()).toStrictEqual({
      "TKN-Custom-Header": "example",
      "TKN-Bar": "Bar"
    })
    ecanna.removeAllHeaders()
    expect(ecanna.getHeaders()).toStrictEqual({})
  })

  test("Customize request config", (): void => {
    expect(ecanna.getRequestConfig()).toStrictEqual({})
    ecanna.setRequestConfig("withCredentials", true)
    ecanna.setRequestConfig("withFoo", "Foo")
    ecanna.setRequestConfig("withBar", "Bar")
    expect(ecanna.getRequestConfig()).toStrictEqual({
      withCredentials: true,
      withFoo: "Foo",
      withBar: "Bar"
    })
    ecanna.removeRequestConfig("withFoo")
    expect(ecanna.getRequestConfig()).toStrictEqual({
      withCredentials: true,
      withBar: "Bar"
    })
    ecanna.removeAllRequestConfigs()
    expect(ecanna.getRequestConfig()).toStrictEqual({})
  })
})

describe("HTTP Operations", (): void => {
  const host: string = "127.0.0.1"
  const port: number = 8080
  const protocol: string = "http"
  const path: string = "/ext/testingrequests"
  let ecanna: Ecanna
  beforeAll((): void => {
    ecanna = new Ecanna(
      host,
      port,
      protocol,
      12345,
      undefined,
      undefined,
      undefined,
      true
    )
    ecanna.addAPI("testingrequests", TestAPI, path)
  })

  afterEach((): void => {
    mockAxios.reset()
  })

  test("GET works", async (): Promise<void> => {
    const input: string = "TestGET"
    const api: TestAPI = ecanna.api("testingrequests")
    const result: Promise<object> = api.TestGET(input, `/${input}`)
    const payload: object = {
      result: {
        output: input
      }
    }
    const responseObj: HttpResponse = {
      data: payload
    }
    mockAxios.mockResponse(responseObj)
    const response: any = await result
    expect(mockAxios.request).toHaveBeenCalledTimes(1)
    expect(response.output).toBe(input)
  })

  test("DELETE works", async (): Promise<void> => {
    const input: string = "TestDELETE"
    const api: TestAPI = ecanna.api("testingrequests")
    const axiosConfig: AxiosRequestConfig = {
      baseURL: `${protocol}://${host}:${port}`,
      responseType: "text"
    }
    const result: Promise<object> = api.TestDELETE(
      input,
      `/${input}`,
      axiosConfig
    )
    const payload: object = {
      result: {
        output: input
      }
    }
    const responseObj: HttpResponse = {
      data: payload
    }
    mockAxios.mockResponse(responseObj)
    const response: any = await result
    expect(mockAxios.request).toHaveBeenCalledTimes(1)
    expect(response.output).toBe(input)
  })

  test("POST works", async (): Promise<void> => {
    const input: string = "TestPOST"
    const api: TestAPI = ecanna.api("testingrequests")
    const result: Promise<object> = api.TestPOST(input, `/${input}`)
    const payload: object = {
      result: {
        output: input
      }
    }
    const responseObj: HttpResponse = {
      data: payload
    }
    mockAxios.mockResponse(responseObj)
    const response: any = await result
    expect(mockAxios.request).toHaveBeenCalledTimes(1)
    expect(response.output).toBe(input)
  })

  test("PUT works", async (): Promise<void> => {
    const input: string = "TestPUT"
    const api: TestAPI = ecanna.api("testingrequests")
    const result: Promise<object> = api.TestPUT(input, `/${input}`)
    const payload: object = {
      result: {
        output: input
      }
    }
    const responseObj: HttpResponse = {
      data: payload
    }
    mockAxios.mockResponse(responseObj)
    const response: any = await result
    expect(mockAxios.request).toHaveBeenCalledTimes(1)
    expect(response.output).toBe(input)
  })

  test("PATCH works", async (): Promise<void> => {
    const input: string = "TestPATCH"
    const api: TestAPI = ecanna.api("testingrequests")
    const result: Promise<object> = api.TestPATCH(input, `/${input}`)
    const payload: object = {
      result: {
        output: input
      }
    }
    const responseObj: HttpResponse = {
      data: payload
    }
    mockAxios.mockResponse(responseObj)
    const response: any = await result
    expect(mockAxios.request).toHaveBeenCalledTimes(1)
    expect(response.output).toBe(input)
  })
})