import * as TestApp from '../../../test/App.js'
import * as TestRuntime from '../../../test/runtime.js'
import * as TestViem from '../../../test/Viem.js'
import * as core_EarnVaults from '../../db/tables/earnVaults.js'
import * as RewardCampaigns from '../../db/tables/rewardCampaigns.js'
import * as Tidx from '../Tidx.js'
import * as Campaigns from './Campaigns.js'
import * as Runner from './Runner.js'

const vaultAddress = '0x1000000000000000000000000000000000000001'
const shareAddress = '0x2000000000000000000000000000000000000002'
const assetAddress = '0x3000000000000000000000000000000000000003'
const factoryAddress = '0x4000000000000000000000000000000000000004'
const funderAddress = '0x5000000000000000000000000000000000000005'
const treasuryAddress = '0x6000000000000000000000000000000000000006'

describe('due', () => {
  test('schedules unprovisioned campaigns and omits paused campaigns', async () => {
    const db = TestApp.database()
    const now = Date.now()
    await seedCampaign(db, Math.floor(now / 1_000))

    await expect(Runner.due(db, now)).resolves.toStrictEqual([
      { chainId: 4217, type: 'earn:reward:run', vaultAddress },
    ])

    await expect(
      RewardCampaigns.setPaused(db, { chainId: 4217, paused: true, vaultAddress }),
    ).resolves.toMatchObject({ paused: true })
    await expect(Runner.due(db, now)).resolves.toStrictEqual([])
  })
})

describe('run', () => {
  test('leaves paused campaigns idle without crossing execution boundaries', async () => {
    const db = TestApp.database()
    const now = Date.now()
    await seedCampaign(db, Math.floor(now / 1_000))
    await RewardCampaigns.setPaused(db, { chainId: 4217, paused: true, vaultAddress })
    const runtime = TestRuntime.get()

    await expect(
      Runner.run({
        db,
        factory: factoryAddress,
        fetch,
        getClient: (chainId) => TestViem.getClient({ chainId }),
        getTidx: (chainId) => Tidx.getClient({ chainId, tidx: { baseUrl: runtime.tidxUrl } }),
        message: { chainId: 4217, type: 'earn:reward:run', vaultAddress },
        now: Date.now,
        signerFetch: fetch,
        zones: [],
      }),
    ).resolves.toStrictEqual({ status: 'idle' })
  })
})

async function seedCampaign(db: ReturnType<typeof TestApp.database>, now: number) {
  await core_EarnVaults.upsert(db, {
    chainId: 4217,
    description: null,
    label: 'Runner test vault',
    privateInputTokens: [],
    privateOutputTokens: [],
    vaultAddress,
    zones: [],
  })
  return RewardCampaigns.upsert(db, {
    assetAddress,
    assetDecimals: 6,
    chainId: 4217,
    config: {
      boostRewards: {
        endTimestamp: now + 1_200,
        excludedAddresses: [],
        funding: { wallet: funderAddress },
        intervalSeconds: 300,
        perUserPrincipalCapAssets: '1000000',
        startTimestamp: now + 600,
        targetAnnualRateBps: 700,
        totalPrincipalCapAssets: '10000000',
        treasury: treasuryAddress,
      },
    } satisfies Campaigns.Config,
    earnShareAddress: shareAddress,
    earnShareDecimals: 18,
    now,
    vaultAddress,
  })
}