import * as TestApp from '../../../test/App.js'
import * as EarnVaults from './earnVaults.js'

const input = {
  chainId: 42_431,
  description: 'Bridge test PATHUSD deposited into Tempo Earn.',
  label: 'btPATHUSD Earn',
  privateInputTokens: [
    '0x20c00000000000000000000057F242B21a53ae4D',
    '0x20c0000000000000000000005B77A125d795262A',
  ],
  privateOutputTokens: ['0x20c00000000000000000000057F242B21a53ae4D'],
  vaultAddress: '0x2f05f4d3625B2eFFb383eFbEDAFd2D8F04371636',
  zones: [
    {
      chainId: 1_424_310_003,
      deploymentBlock: 31_730_087,
      earnRouter: '0xeBEdC74FFeEAD186ACC6caC05Eb82fB9e093a7c7',
    },
  ],
} as const satisfies EarnVaults.upsert.Options

describe('upsert', () => {
  test('inserts flattened curated fields and generates a stable slug', async () => {
    vi.useFakeTimers()
    try {
      vi.setSystemTime('2026-01-01T00:00:00.000Z')
      const record = await EarnVaults.upsert(TestApp.database(), input)
      const { slug, ...stored } = record
      expect(slug).toMatch(/^btpathusd-earn-[0-9a-z]{8}$/)
      expect(stored).toMatchInlineSnapshot(`
        {
          "chainId": 42431,
          "createdAt": "2026-01-01T00:00:00.000Z",
          "description": "Bridge test PATHUSD deposited into Tempo Earn.",
          "label": "btPATHUSD Earn",
          "privateInputTokens": [
            "0x20c00000000000000000000057F242B21a53ae4D",
            "0x20c0000000000000000000005B77A125d795262A",
          ],
          "privateOutputTokens": [
            "0x20c00000000000000000000057F242B21a53ae4D",
          ],
          "updatedAt": "2026-01-01T00:00:00.000Z",
          "vaultAddress": "0x2f05f4d3625b2effb383efbedafd2d8f04371636",
          "zones": [
            {
              "chainId": 1424310003,
              "deploymentBlock": 31730087,
              "earnRouter": "0xebedc74ffeead186acc6cac05eb82fb9e093a7c7",
            },
          ],
        }
      `)
    } finally {
      vi.useRealTimers()
    }
  })

  test('updates mutable fields while preserving createdAt', async () => {
    vi.useFakeTimers()
    try {
      vi.setSystemTime('2026-01-01T00:00:00.000Z')
      const db = TestApp.database()
      const created = await EarnVaults.upsert(db, input)
      vi.setSystemTime('2026-01-02T00:00:00.000Z')
      const updated = await EarnVaults.upsert(db, {
        ...input,
        description: null,
        label: 'Renamed Vault',
        privateInputTokens: [],
        privateOutputTokens: [],
        slug: 'replacement-slug',
      })
      const { slug, ...stored } = updated
      expect(slug).toBe('replacement-slug')
      expect(stored.createdAt).toBe(created.createdAt)
      expect({
        createdAt: stored.createdAt,
        description: stored.description,
        label: stored.label,
        privateInputTokens: stored.privateInputTokens,
        privateOutputTokens: stored.privateOutputTokens,
        updatedAt: stored.updatedAt,
        zones: stored.zones,
      }).toMatchInlineSnapshot(`
        {
          "createdAt": "2026-01-01T00:00:00.000Z",
          "description": null,
          "label": "Renamed Vault",
          "privateInputTokens": [],
          "privateOutputTokens": [],
          "updatedAt": "2026-01-02T00:00:00.000Z",
          "zones": [
            {
              "chainId": 1424310003,
              "deploymentBlock": 31730087,
              "earnRouter": "0xebedc74ffeead186acc6cac05eb82fb9e093a7c7",
            },
          ],
        }
      `)

      expect(updated.slug).toBe('replacement-slug')
    } finally {
      vi.useRealTimers()
    }
  })

  test('supports chain ids above the Postgres integer range', async () => {
    const chainId = 4_217_000_001
    const db = TestApp.database()
    const record = await EarnVaults.upsert(db, { ...input, chainId })
    expect(record.chainId).toBe(chainId)
    expect(
      await EarnVaults.get(db, {
        chainId,
        vaultAddress: input.vaultAddress,
      }),
    ).toStrictEqual(record)
  })
})

describe('get', () => {
  test('reads case-insensitively and returns undefined when absent', async () => {
    const db = TestApp.database()
    const record = await EarnVaults.upsert(db, input)
    expect(
      await EarnVaults.get(db, {
        chainId: input.chainId,
        vaultAddress: input.vaultAddress.toUpperCase(),
      }),
    ).toStrictEqual(record)
    expect(
      await EarnVaults.get(db, {
        chainId: 1,
        vaultAddress: input.vaultAddress,
      }),
    ).toBeUndefined()
  })
})

describe('list', () => {
  test('filters by chain and returns stable order', async () => {
    const db = TestApp.database()
    const second = {
      ...input,
      vaultAddress: '0xaa0000000000000000000000000000000000000e',
    } as const satisfies EarnVaults.upsert.Options
    const third = {
      ...input,
      chainId: 4217,
      vaultAddress: '0xaa0000000000000000000000000000000000000f',
    } as const satisfies EarnVaults.upsert.Options
    await EarnVaults.upsert(db, second)
    await EarnVaults.upsert(db, input)
    await EarnVaults.upsert(db, third)

    expect(
      (await EarnVaults.list(db)).map(({ chainId, vaultAddress }) => ({
        chainId,
        vaultAddress,
      })),
    ).toMatchInlineSnapshot(`
      [
        {
          "chainId": 4217,
          "vaultAddress": "0xaa0000000000000000000000000000000000000f",
        },
        {
          "chainId": 42431,
          "vaultAddress": "0x2f05f4d3625b2effb383efbedafd2d8f04371636",
        },
        {
          "chainId": 42431,
          "vaultAddress": "0xaa0000000000000000000000000000000000000e",
        },
      ]
    `)
    expect(await EarnVaults.list(db, { chainId: third.chainId })).toHaveLength(1)
  })
})

describe('remove', () => {
  test('physically deletes one curated vault', async () => {
    const db = TestApp.database()
    const created = await EarnVaults.upsert(db, input)
    expect(
      await EarnVaults.remove(db, {
        chainId: input.chainId,
        vaultAddress: input.vaultAddress.toUpperCase(),
      }),
    ).toStrictEqual(created)
    expect(
      await EarnVaults.get(db, {
        chainId: input.chainId,
        vaultAddress: input.vaultAddress,
      }),
    ).toBeUndefined()
    expect(
      await EarnVaults.remove(db, {
        chainId: input.chainId,
        vaultAddress: input.vaultAddress,
      }),
    ).toBeUndefined()
  })
})