import {
  Events,
  type IPortalApi,
  generateTraceId,
  sdkLogger,
} from '@portal-hq/utils'

import {
  ScanEVMRequest,
  ScanEVMResponse,
  ScanEip712Request,
  ScanEip712Response,
  ScanNftRequest,
  ScanNftResponse,
  ScanSolanaRequest,
  ScanSolanaResponse,
  ScanTokenRequest,
  ScanTokenResponse,
  ScanUrlRequest,
  ScanUrlResponse,
  ScreenAddressApiResponse,
  ScreenAddressRequest,
} from './types'

const HYPERNATIVE_BASE_PATH = '/api/v3/clients/me/integrations/hypernative'

const HypernativeEndpoint = {
  evm: `${HYPERNATIVE_BASE_PATH}/evm/scan`,
  eip712: `${HYPERNATIVE_BASE_PATH}/eip-712/scan`,
  solana: `${HYPERNATIVE_BASE_PATH}/solana/scan`,
  addresses: `${HYPERNATIVE_BASE_PATH}/addresses/scan`,
  nfts: `${HYPERNATIVE_BASE_PATH}/nfts/scan`,
  tokens: `${HYPERNATIVE_BASE_PATH}/tokens/scan`,
  url: `${HYPERNATIVE_BASE_PATH}/url/scan`,
} as const

export interface IPortalHypernativeApi {
  scanEVMTx(params: ScanEVMRequest): Promise<ScanEVMResponse>
  scanEip712Tx(params: ScanEip712Request): Promise<ScanEip712Response>
  scanSolanaTx(params: ScanSolanaRequest): Promise<ScanSolanaResponse>
  scanAddresses(params: ScreenAddressRequest): Promise<ScreenAddressApiResponse>
  scanNfts(params: ScanNftRequest): Promise<ScanNftResponse>
  scanTokens(params: ScanTokenRequest): Promise<ScanTokenResponse>
  scanURL(params: ScanUrlRequest): Promise<ScanUrlResponse>
}

export interface PortalHypernativeApiOptions {
  api: IPortalApi
}

export class PortalHypernativeApi implements IPortalHypernativeApi {
  private readonly api: IPortalApi

  constructor(options: PortalHypernativeApiOptions) {
    this.api = options.api
  }

  public async scanEVMTx(params: ScanEVMRequest): Promise<ScanEVMResponse> {
    const path = HypernativeEndpoint.evm
    const body = params

    const response = await this.post<ScanEVMResponse, typeof body>(path, body)

    await this.trackEvent(Events.HypernativeScanTx, {
      path,
      type: 'evm',
    })

    return response
  }

  public async scanEip712Tx(
    params: ScanEip712Request,
  ): Promise<ScanEip712Response> {
    const path = HypernativeEndpoint.eip712
    const body = params

    const response = await this.post<ScanEip712Response, typeof body>(
      path,
      body,
    )

    await this.trackEvent(Events.HypernativeScanTx, {
      path,
      type: 'eip712',
    })

    return response
  }

  public async scanSolanaTx(
    params: ScanSolanaRequest,
  ): Promise<ScanSolanaResponse> {
    const path = HypernativeEndpoint.solana
    const body = params

    const response = await this.post<ScanSolanaResponse, typeof body>(
      path,
      body,
    )

    await this.trackEvent(Events.HypernativeScanTx, {
      path,
      type: 'solana',
    })

    return response
  }

  public async scanAddresses(
    params: ScreenAddressRequest,
  ): Promise<ScreenAddressApiResponse> {
    const path = HypernativeEndpoint.addresses
    const body = params

    const response = await this.post<ScreenAddressApiResponse, typeof body>(
      path,
      body,
    )

    await this.trackEvent(Events.HypernativeScanAddresses, {
      path,
      count: params.addresses.length,
    })

    return response
  }

  public async scanNfts(params: ScanNftRequest): Promise<ScanNftResponse> {
    const path = HypernativeEndpoint.nfts

    const response = await this.post<ScanNftResponse, typeof params>(
      path,
      params,
    )

    await this.trackEvent(Events.HypernativeScanNFTs, {
      path,
      count: params.nfts.length,
    })

    return response
  }

  public async scanTokens(
    params: ScanTokenRequest,
  ): Promise<ScanTokenResponse> {
    const path = HypernativeEndpoint.tokens

    const response = await this.post<ScanTokenResponse, typeof params>(
      path,
      params,
    )

    await this.trackEvent(Events.HypernativeScanTokens, {
      path,
      count: params.tokens.length,
    })

    return response
  }

  public async scanURL(params: ScanUrlRequest): Promise<ScanUrlResponse> {
    const path = HypernativeEndpoint.url

    const response = await this.post<ScanUrlResponse, typeof params>(
      path,
      params,
    )

    await this.trackEvent(Events.HypernativeScanURL, {
      path,
      url: params.url,
    })

    return response
  }

  private async post<T, B extends object>(path: string, body: B): Promise<T> {
    return this.api.requests.post<T>(path, {
      headers: {
        Authorization: `Bearer ${this.api.apiKey}`,
        Accept: 'application/json',
        'Content-Type': 'application/json',
      },
      body,
      traceId: generateTraceId(),
    })
  }

  private async trackEvent(
    event: string,
    properties: Record<string, unknown>,
  ): Promise<void> {
    try {
      await this.api.track(event, properties)
    } catch (error) {
      sdkLogger.warn(
        `[PortalHypernativeApi] Failed to track event "${event}":`,
        error,
      )
    }
  }
}

export default PortalHypernativeApi