import { Hash } from 'ox'
import { TxEnvelopeTempo } from 'ox/tempo'

import * as TestApp from '../../../test/App.js'
import * as Runtime from '../../../test/runtime.js'
import * as Tempo from '../../../test/Tempo.js'
import * as SponsoredTransactions from '../../db/tables/sponsoredTransactions.js'
import type * as Viem from '../../internal/Viem.js'
import * as Sponsorships from './Sponsorships.js'

describe('createFinalizer', () => {
  test.each(['pending', 'failed'] as const)(
    'passes Zone metadata to the indexer resolver for %s fill intents',
    async (status) => {
      const db = TestApp.database()
      const chainId = Runtime.get().zone.chainId
      const zone = TestApp.zone({
        chainId,
        rpcUrl: Runtime.get().zone.internalRpcUrl,
        tidxUrl: 'http://127.0.0.1:9',
      })
      const transaction = await Tempo.accounts[0].signTransaction({
        calls: [{ data: '0x', to: Tempo.accounts[1].address }],
        chainId,
        feePayer: true,
        gas: 100_000n,
        maxFeePerGas: 1_000_000n,
        maxPriorityFeePerGas: 0n,
        nonce: 0,
      })
      const intent = await SponsoredTransactions.upsert(db, {
        apiKeyId: 'key_zone',
        billable: true,
        chainId,
        environment: 'production',
        orgId: 'org_zone',
        signPayload: TxEnvelopeTempo.getFeePayerSignPayload(
          TxEnvelopeTempo.deserialize(transaction as TxEnvelopeTempo.Serialized),
          { sender: Tempo.accounts[0].address },
        ),
        transaction,
      })
      if (status === 'failed')
        await SponsoredTransactions.fail(db, intent.id, new Date().toISOString())
      const contexts: Viem.resolveRpc.Context[] = []
      const finalizer = Sponsorships.createFinalizer({
        db,
        feePayer: Tempo.accounts[1].address,
        tidx: (context) => {
          contexts.push(context)
          // An unavailable indexer must leave both active and failed intents retryable.
          return { baseUrl: 'http://127.0.0.1:9' }
        },
        zones: [zone],
      })

      expect(await finalizer.tick()).toMatchObject({ errors: 1, matched: 0 })
      expect(contexts).toContainEqual({ chainId, principal: null, zone })
      expect(await SponsoredTransactions.get(db, intent.id)).toMatchObject({
        status,
        transactionHash: null,
      })
    },
  )

  test('looks up Zone receipts using configured Zone metadata', async () => {
    const db = TestApp.database()
    const runtime = Runtime.get()
    const chainId = runtime.zone.chainId
    const transaction = await Tempo.accounts[0].signTransaction({
      calls: [{ data: '0x', to: Tempo.accounts[1].address }],
      chainId,
      feePayer: true,
      gas: 100_000n,
      maxFeePerGas: 1_000_000n,
      maxPriorityFeePerGas: 0n,
      nonce: 0,
    })
    await SponsoredTransactions.upsert(db, {
      apiKeyId: 'key_mpp_zone',
      billable: true,
      chainId,
      environment: 'production',
      orgId: 'org_mpp_zone',
      signPayload: TxEnvelopeTempo.getFeePayerSignPayload(
        TxEnvelopeTempo.deserialize(transaction as TxEnvelopeTempo.Serialized),
        { sender: Tempo.accounts[0].address },
      ),
      transaction,
      transactionHash: Hash.keccak256(transaction),
    })
    const finalizer = Sponsorships.createFinalizer({
      db,
      rpc: ({ zone }) => {
        expect(zone?.id).toBe(chainId)
        return {}
      },
      zones: [TestApp.zone({ chainId, rpcUrl: runtime.zone.internalRpcUrl })],
    })
    expect(await finalizer.tick()).toMatchObject({ errors: 0, failed: 0, finalized: 0, pending: 1 })
  })
})