/**
 * @jest-environment jsdom
 */

import Blockaid from '.'
import Mpc from '../../../mpc'
import portalMock from '../../../__mocks/portal/portal'
import {
  mockHost,
  mockBlockaidScanEvmTxRequest,
  mockBlockaidScanEvmTxResponse,
  mockBlockaidScanSolanaTxRequest,
  mockBlockaidScanSolanaTxResponse,
  mockBlockaidScanAddressRequest,
  mockBlockaidScanAddressResponse,
  mockBlockaidScanTokensRequest,
  mockBlockaidScanTokensResponse,
  mockBlockaidScanUrlRequest,
  mockBlockaidScanUrlResponse,
} from '../../../__mocks/constants'

describe('Blockaid', () => {
  let blockaid: Blockaid
  let mpc: Mpc

  beforeEach(() => {
    jest.clearAllMocks()

    portalMock.host = mockHost
    mpc = new Mpc({
      portal: portalMock,
    })

    blockaid = new Blockaid({ mpc })
  })

  describe('scanEVMTx', () => {
    it('should call mpc.blockaidScanEvmTx with the correct arguments', async () => {
      const spy = jest
        .spyOn(mpc, 'blockaidScanEvmTx')
        .mockResolvedValue(mockBlockaidScanEvmTxResponse)

      const result = await blockaid.scanEVMTx(mockBlockaidScanEvmTxRequest)

      expect(spy).toHaveBeenCalledWith(mockBlockaidScanEvmTxRequest)
      expect(result).toEqual(mockBlockaidScanEvmTxResponse)
    })

    it('should propagate errors from mpc.blockaidScanEvmTx', async () => {
      const error = new Error('Test error')
      jest.spyOn(mpc, 'blockaidScanEvmTx').mockRejectedValue(error)

      await expect(
        blockaid.scanEVMTx(mockBlockaidScanEvmTxRequest),
      ).rejects.toThrow('Test error')
    })
  })

  describe('scanSolanaTx', () => {
    it('should call mpc.blockaidScanSolanaTx with the correct arguments', async () => {
      const spy = jest
        .spyOn(mpc, 'blockaidScanSolanaTx')
        .mockResolvedValue(mockBlockaidScanSolanaTxResponse)

      const result = await blockaid.scanSolanaTx(mockBlockaidScanSolanaTxRequest)

      expect(spy).toHaveBeenCalledWith(mockBlockaidScanSolanaTxRequest)
      expect(result).toEqual(mockBlockaidScanSolanaTxResponse)
    })

    it('should propagate errors from mpc.blockaidScanSolanaTx', async () => {
      const error = new Error('Test error')
      jest.spyOn(mpc, 'blockaidScanSolanaTx').mockRejectedValue(error)

      await expect(
        blockaid.scanSolanaTx(mockBlockaidScanSolanaTxRequest),
      ).rejects.toThrow('Test error')
    })
  })

  describe('scanAddress', () => {
    it('should call mpc.blockaidScanAddress with the correct arguments', async () => {
      const spy = jest
        .spyOn(mpc, 'blockaidScanAddress')
        .mockResolvedValue(mockBlockaidScanAddressResponse)

      const result = await blockaid.scanAddress(mockBlockaidScanAddressRequest)

      expect(spy).toHaveBeenCalledWith(mockBlockaidScanAddressRequest)
      expect(result).toEqual(mockBlockaidScanAddressResponse)
    })

    it('should propagate errors from mpc.blockaidScanAddress', async () => {
      const error = new Error('Test error')
      jest.spyOn(mpc, 'blockaidScanAddress').mockRejectedValue(error)

      await expect(
        blockaid.scanAddress(mockBlockaidScanAddressRequest),
      ).rejects.toThrow('Test error')
    })
  })

  describe('scanTokens', () => {
    it('should call mpc.blockaidScanTokens with the correct arguments', async () => {
      const spy = jest
        .spyOn(mpc, 'blockaidScanTokens')
        .mockResolvedValue(mockBlockaidScanTokensResponse)

      const result = await blockaid.scanTokens(mockBlockaidScanTokensRequest)

      expect(spy).toHaveBeenCalledWith(mockBlockaidScanTokensRequest)
      expect(result).toEqual(mockBlockaidScanTokensResponse)
    })

    it('should propagate errors from mpc.blockaidScanTokens', async () => {
      const error = new Error('Test error')
      jest.spyOn(mpc, 'blockaidScanTokens').mockRejectedValue(error)

      await expect(
        blockaid.scanTokens(mockBlockaidScanTokensRequest),
      ).rejects.toThrow('Test error')
    })
  })

  describe('scanURL', () => {
    it('should call mpc.blockaidScanUrl with the correct arguments', async () => {
      const spy = jest
        .spyOn(mpc, 'blockaidScanUrl')
        .mockResolvedValue(mockBlockaidScanUrlResponse)

      const result = await blockaid.scanURL(mockBlockaidScanUrlRequest)

      expect(spy).toHaveBeenCalledWith(mockBlockaidScanUrlRequest)
      expect(result).toEqual(mockBlockaidScanUrlResponse)
    })

    it('should propagate errors from mpc.blockaidScanUrl', async () => {
      const error = new Error('Test error')
      jest.spyOn(mpc, 'blockaidScanUrl').mockRejectedValue(error)

      await expect(
        blockaid.scanURL(mockBlockaidScanUrlRequest),
      ).rejects.toThrow('Test error')
    })
  })
})