import { Hono } from 'hono'

import type * as App from '../../App.js'
import type * as RoutesDepositAddress from '../../internal/routes/DepositAddress.js'
import type * as RoutesObservability from '../../internal/routes/Observability.js'
import type * as RoutesProvider from '../../internal/routes/Provider.js'
import type * as RoutesTransferReconciliation from '../../internal/routes/TransferReconciliation.js'
import type * as RoutesTransferSubsidy from '../../internal/routes/TransferSubsidy.js'
import type * as Webhooks from '../../internal/Webhooks.js'
import * as Metadata from '../metadata.js'
import { chains } from './routes/chains.js'
import { depositAddresses } from './routes/deposit-addresses.js'
import { providers } from './routes/providers.js'
import { quotes } from './routes/quotes.js'
import { transfers } from './routes/transfers.js'

/**
 * Mounts the Routes API, including quotes, inventory, reusable
 * deposit addresses, detected deposits, and transfers.
 *
 * ```ts
 * App.create(options).route('/', data()).route('/', routes())
 * ```
 */
export function routes(options: routes.Options = {}) {
  const app = new Hono<App.Environment>()
    .route('/', quotes())
    .route('/', chains())
    .route('/', providers())
    .route('/', depositAddresses(options))
    .route('/', transfers(options))
  return Metadata.defaultChain(Metadata.attach(app, openapi))
}

export declare namespace routes {
  /** Routes group configuration. */
  type Options = {
    /** Enqueues one deposit address for asynchronous reconciliation. */
    dispatchDepositReconciliation?:
      | ((message: RoutesProvider.Webhook.receive.Dispatchable) => Promise<void>)
      | undefined
    /** Enqueues one registered transfer for destination reconciliation. */
    dispatchTransferReconciliation?:
      | ((message: RoutesTransferReconciliation.Message) => Promise<void>)
      | undefined
    /** Enqueues webhook updates staged with transfer mutations. */
    dispatchTransferUpdates?:
      | ((references: readonly Webhooks.QueueReference[]) => Promise<number>)
      | undefined
    /** Records completed route lifecycle intervals. */
    recordLifecycleInterval?:
      | ((interval: RoutesObservability.LifecycleInterval) => Promise<void>)
      | undefined
    /** Read-only destination subsidy inventory, when settlement is configured. */
    transferSubsidy?: RoutesTransferSubsidy.Inventory | undefined
    /** Registers a created address with a source-chain observer. */
    registerDepositAddress?: ((address: RoutesDepositAddress.Public) => Promise<void>) | undefined
  }
}

const openapi = {
  tags: [
    {
      name: 'Chains',
      description: 'Source chains and stablecoins supported by Routes.',
      'x-pagePath': 'routes/chains',
    },
    {
      name: 'Deposit Addresses',
      description: 'Reusable route addresses and deposits detected at those addresses.',
      'x-pagePath': 'routes/deposit-addresses',
    },
    {
      name: 'Providers',
      description: 'Providers available through Routes.',
      'x-pagePath': 'routes/providers',
    },
    {
      name: 'Quotes',
      description: 'Live quotes for routing assets between supported chains.',
      'x-pagePath': 'routes/quotes',
    },
    {
      name: 'Route Transfers',
      description: 'Transfers routed between supported chains.',
      'x-displayName': 'Transfers',
      'x-pagePath': 'routes/transfers',
    },
  ],
  'x-tagGroups': [
    {
      name: 'Routes API',
      tags: ['Chains', 'Deposit Addresses', 'Providers', 'Quotes', 'Route Transfers'],
    },
  ],
} satisfies App.create.Metadata