import * as TestApp from '../../../test/App.js'
import * as FundingCatalog from './fundingCatalog.js'

const catalog = {
  chains: [
    {
      aliases: ['eth'],
      id: 'eip155:1',
      name: 'Ethereum',
      parentChainId: null,
      rpcUrls: ['https://ethereum.example'],
      slug: 'ethereum',
    },
    {
      aliases: [],
      id: 'eip155:4217',
      name: 'Tempo',
      parentChainId: null,
      rpcUrls: ['https://tempo.example'],
      slug: 'tempo',
    },
  ],
  chainTokens: [
    {
      address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
      chainId: 'eip155:1',
      decimals: 6,
      name: null,
      standard: 'ERC-20',
      tokenId: 'usdc',
    },
    {
      address: '0x20c000000000000000000000b9537d11c60e8b50',
      chainId: 'eip155:4217',
      decimals: 6,
      name: null,
      standard: 'TIP-20',
      tokenId: 'usdce',
    },
  ],
  routes: [
    {
      destinationChainId: 'eip155:4217',
      destinationTokenId: 'usdce',
      providerId: 'relay',
      sourceChainId: 'eip155:1',
      sourceTokenId: 'usdc',
    },
  ],
  tokens: [
    {
      currency: 'USD',
      id: 'usdc',
      name: 'USD Coin',
      symbol: 'USDC',
    },
    {
      currency: 'USD',
      id: 'usdce',
      name: 'Bridged USDC (Stargate)',
      symbol: 'USDC.e',
    },
  ],
} as const satisfies FundingCatalog.publish.Input

describe('publish', () => {
  test('round-trips a complete funding catalog', async () => {
    const db = TestApp.database()
    const head = await FundingCatalog.publish(db, catalog)
    expect(await FundingCatalog.read(db)).toStrictEqual({
      catalog: head,
      chainTokens: catalog.chainTokens,
      chains: catalog.chains,
      // Optional route JSON persists as null.
      routes: catalog.routes.map((route) => ({
        ...route,
        capabilities: null,
        configuration: null,
      })),
      tokens: catalog.tokens,
    })
  })

  test('round-trips route capabilities', async () => {
    const db = TestApp.database()
    const capabilities = { transfer: { modes: ['exactSource'] } } as const
    await FundingCatalog.publish(db, {
      ...catalog,
      routes: [{ ...catalog.routes[0]!, capabilities }],
    })
    expect((await FundingCatalog.read(db)).routes[0]?.capabilities).toStrictEqual(capabilities)
  })

  test('round-trips route configuration', async () => {
    const db = TestApp.database()
    const configuration = { poolAddress: `0x${'11'.repeat(20)}` }
    await FundingCatalog.publish(db, {
      ...catalog,
      routes: [{ ...catalog.routes[0]!, configuration }],
    })
    expect((await FundingCatalog.read(db)).routes[0]?.configuration).toStrictEqual(configuration)
  })

  test('replaces rows and advances the catalog version', async () => {
    const db = TestApp.database()
    const first = await FundingCatalog.publish(db, catalog)
    const second = await FundingCatalog.publish(db, {
      chainTokens: [],
      chains: catalog.chains.slice(0, 1),
      routes: [],
      tokens: [],
    })
    expect(second.version > first.version).toBe(true)
    expect(await FundingCatalog.read(db)).toStrictEqual({
      catalog: second,
      chainTokens: [],
      chains: catalog.chains.slice(0, 1),
      routes: [],
      tokens: [],
    })
  })
})