import * as ApiKey from '../../ApiKey.js'
import * as App from '../../App.js'
import * as Db from '../../db/Db.js'
import type * as Auth from '../../internal/Auth.js'
import * as Viem from '../../internal/Viem.js'
import * as Zones from '../Zones.js'

import * as Data from './App.js'
import * as ZoneSelection from './ZoneSelection.js'
import * as Activities from './routes/activities.js'

describe('transaction activity Zone query', () => {
  test('accepts the Zones include with an optional parent chain', () => {
    expect(
      Activities.schema.getTransactionActivities.Query.parse({ include: 'zones' }).include,
    ).toStrictEqual(['zones'])
    expect(
      Activities.schema.getTransactionActivities.Query.parse({
        chainId: '4217',
        include: 'zones',
      }),
    ).toMatchObject({ chainId: 4217, include: ['zones'] })
    expect(
      Activities.schema.getTransactionActivities.Query.safeParse({ includeZones: 'true' }).success,
    ).toBe(false)
  })

  test('opts in only activity routes and accepts a parent chain', async () => {
    const app = App.create({
      auth: false,
      db: Db.postgres({ connectionString: 'postgresql://unused@127.0.0.1:1/unused' }),
      zones: [Zones.zoneModeratoInternal],
    }).route('/', Data.data({ webhook: false }))
    const address = '0x0000000000000000000000000000000000000001'
    const hash = `0x${'00'.repeat(32)}`
    const addressScoped = await app.request(
      `/v1/addresses/${address}/activities?include=zones&chainId=${Viem.chainId.testnet}`,
    )
    const forbidden = await app.request(`/v1/transactions/${hash}/activities?include=zones`)
    const scoped = await app.request(
      `/v1/transactions/${hash}/activities?include=zones&chainId=${Viem.chainId.testnet}`,
    )
    const unsupported = await app.request('/v1/tokenlist?include=zones')

    expect(forbidden.status).toBe(403)
    expect(forbidden.headers.get('cache-control')).toBe('no-store')
    expect(await addressScoped.json()).toMatchObject({ error: { code: 'api_key_forbidden' } })
    expect(await scoped.json()).toMatchObject({ error: { code: 'api_key_forbidden' } })
    expect(await unsupported.json()).toMatchObject({ error: { code: 'query_invalid' } })
  })
})

describe('readableChainIds', () => {
  test('intersects the parent chain, scopes, and configured routable Zones', () => {
    const principal = apiKeyPrincipal({
      scopes: [
        'data:read',
        `zone:${Zones.zoneMainnetInternal.id}:read`,
        `zone:${Zones.zoneModeratoInternal.id}:write`,
      ],
    })

    expect(
      ZoneSelection.readableChainIds({
        parentChainId: Viem.chainId.testnet,
        principal,
        zones: new Map(Zones.chains.map((zone) => [zone.id, zone])),
      }),
    ).toStrictEqual([Zones.zoneModeratoInternal.id])
    expect(
      ZoneSelection.readableChainIds({
        parentChainId: Viem.chainId.mainnet,
        principal,
        zones: new Map(Zones.chains.map((zone) => [zone.id, zone])),
      }),
    ).toStrictEqual([Zones.zoneMainnetInternal.id])
  })

  test('lets wildcard keys read every configured routable Zone of the parent chain', () => {
    expect(
      ZoneSelection.readableChainIds({
        parentChainId: Viem.chainId.testnet,
        principal: apiKeyPrincipal({ scopes: ['*'] }),
        zones: new Map(Zones.chains.map((zone) => [zone.id, zone])),
      }),
    ).toStrictEqual([Zones.zoneModeratoInternal.id])
  })

  test('filters sandbox keys by each Zone parent chain', () => {
    const principal = apiKeyPrincipal({
      environment: 'sandbox',
      scopes: [
        'data:read',
        `zone:${Zones.zoneMainnetInternal.id}:read`,
        `zone:${Zones.zoneModeratoInternal.id}:read`,
      ],
    })

    expect(
      ZoneSelection.readableChainIds({
        parentChainId: Viem.chainId.testnet,
        principal,
        zones: new Map(Zones.chains.map((zone) => [zone.id, zone])),
      }),
    ).toStrictEqual([Zones.zoneModeratoInternal.id])
    expect(
      ZoneSelection.readableChainIds({
        parentChainId: Viem.chainId.mainnet,
        principal,
        zones: new Map(Zones.chains.map((zone) => [zone.id, zone])),
      }),
    ).toStrictEqual([])
  })

  test('requires data read access and both upstreams', () => {
    const zone = {
      ...Zones.zoneModeratoInternal,
      id: 1_424_310_099,
      rpcUrls: { default: { http: ['https://zone.rpc.test'] } },
    }
    const zones = new Map([[zone.id, zone]])

    expect(
      ZoneSelection.readableChainIds({
        parentChainId: zone.sourceId,
        principal: apiKeyPrincipal({ scopes: [`zone:${zone.id}:read`] }),
        zones,
      }),
    ).toStrictEqual([])
    expect(
      ZoneSelection.readableChainIds({
        parentChainId: zone.sourceId,
        principal: apiKeyPrincipal({ scopes: ['data:read', `zone:${zone.id}:read`] }),
        zones,
      }),
    ).toStrictEqual([])
  })
})

describe('uniqueMatch', () => {
  test('selects one match after every chain completes', () => {
    expect(
      ZoneSelection.uniqueMatch([
        { chainId: 1, value: null },
        { chainId: 2, value: 'receipt' },
      ]),
    ).toStrictEqual({ chainId: 2, kind: 'selected', value: 'receipt' })
  })

  test('distinguishes no match from ambiguous matches', () => {
    expect(ZoneSelection.uniqueMatch([{ chainId: 1, value: null }])).toStrictEqual({
      kind: 'not_found',
    })
    expect(
      ZoneSelection.uniqueMatch([
        { chainId: 1, value: 'first' },
        { chainId: 2, value: 'second' },
      ]),
    ).toStrictEqual({ kind: 'ambiguous' })
  })

  test('fails the selection when any chain lookup fails', () => {
    const cause = new Error('unavailable')
    expect(
      ZoneSelection.uniqueMatch([
        { chainId: 1, value: 'receipt' },
        { cause, chainId: 2 },
      ]),
    ).toStrictEqual({ failures: [{ cause, chainId: 2 }], kind: 'failed' })
  })
})

function apiKeyPrincipal(
  options: apiKeyPrincipal.Options,
): Extract<Auth.Principal, { type: 'api_key' }> {
  const apiKey = ApiKey.schema.ApiKey.parse({
    environment: options.environment,
    id: 'key_test',
    orgId: 'org_test',
    scopes: options.scopes,
  })
  return {
    apiKey,
    environment: apiKey.environment,
    id: apiKey.id,
    orgId: apiKey.orgId,
    type: 'api_key',
  }
}

declare namespace apiKeyPrincipal {
  type Options = {
    environment?: 'production' | 'sandbox' | undefined
    scopes: readonly string[]
  }
}