// Method dispatch: get_info / get_balance / make_invoice /
// lookup_invoice live here directly, pay_invoice in pay.ts (it carries
// the budget logic). Bearers always come IN through deps.getBearers and
// results go OUT through deps.applyChangeset - this engine never touches
// wallet state itself.

import {noteK1, sameInvoice} from 'lnurlcash-kit'

import type {Bearer} from '../types'
import type {PreparedMint} from '../ops'
import {prepareMint} from '../ops'
import {PollAbortedError} from '../ops/shared'

import type {PendingInvoice, RequestContext} from './context'
import {invoiceResult, invoiceRetireAfter, resolvePaymentHash, settleAndClaim} from './invoices'
import {handlePayInvoice} from './pay'
import type {NwcRequest, NwcResponse} from './protocol'
import {NWC_METHODS, errResult, okResult} from './protocol'

const MAX_PENDING_MINT_OUTPUTS = 20

// the same eligibility carve applies - the balance answers "what could
// this wallet actually pay with right now"
const spendable = (bearer: Bearer): boolean =>
  !bearer.spent && bearer.callback !== '' && !bearer.deviceId && !!noteK1(bearer.url)

const handleGetInfo = (ctx: RequestContext): NwcResponse =>
  okResult('get_info', {
    alias: 'sattle',
    color: '#55ffcc',
    pubkey: ctx.connection().walletServicePubkey,
    // a bearer-note wallet has no chain view of its own - the network is
    // whatever the mints' invoices say, mainnet in practice. No honest
    // block height/hash exists, so those fields are simply absent.
    network: 'mainnet',
    methods: [...NWC_METHODS],
    notifications: [],
  })

const handleGetBalance = (ctx: RequestContext): NwcResponse =>
  okResult('get_balance', {
    balance: ctx.deps
      .getBearers()
      .filter(spendable)
      .reduce((sum, b) => sum + b.amount, 0),
  })

const handleMakeInvoice = async (
  ctx: RequestContext,
  params: Record<string, unknown>,
): Promise<NwcResponse> => {
  const amountMsat = Number(params.amount)
  if (!Number.isInteger(amountMsat) || amountMsat <= 0) {
    return errResult('make_invoice', 'OTHER', 'Amount must be a positive whole number of msat.')
  }
  const mint = ctx.deps.getDefaultMint()
  if (!mint) {
    return errResult('make_invoice', 'INTERNAL', 'No default mint is configured.')
  }
  const now = ctx.nowSeconds()
  if (
    ctx.deps
      .getBearers()
      .some(
        (bearer) =>
          !bearer.spent &&
          bearer.pendingMint?.retireAfter !== undefined &&
          bearer.pendingMint.retireAfter <= now,
      )
  ) {
    await ctx.deps.recoverPendingMints(ctx.assertOwner)
  }
  const pendingOutputs = ctx.deps
    .getBearers()
    .filter((bearer) => bearer.pendingMint && !bearer.spent).length
  if (pendingOutputs >= MAX_PENDING_MINT_OUTPUTS) {
    return errResult('make_invoice', 'QUOTA_EXCEEDED', 'Too many unpaid invoices are pending.')
  }
  let prepared: PreparedMint
  let stagedOutput: Bearer | undefined
  try {
    prepared = await prepareMint(mint, amountMsat, {
      ...(ctx.deps.kit ?? {}),
      assertOwner: ctx.assertOwner,
      allocateOutputSecrets: (server, count) =>
        ctx.deps.allocateOutputSecrets(server, count, ctx.assertOwner),
      persistOutput: async (note) => {
        stagedOutput = await ctx.deps.persistMintOutput(note, ctx.assertOwner)
      },
    })
  } catch (err) {
    if (stagedOutput) {
      try {
        await ctx.deps.discardMintOutput(stagedOutput, ctx.assertOwner)
      } catch (cleanupError) {
        return errResult(
          'make_invoice',
          'INTERNAL',
          cleanupError instanceof Error ? cleanupError.message : String(cleanupError),
        )
      }
    }
    return errResult('make_invoice', 'INTERNAL', err instanceof Error ? err.message : String(err))
  }
  if (!stagedOutput) {
    return errResult('make_invoice', 'INTERNAL', 'The pending mint output was not persisted.')
  }
  const retireAfter = invoiceRetireAfter(prepared.invoice)
  if (retireAfter !== null) {
    try {
      await ctx.deps.setMintOutputRetirement(
        stagedOutput,
        retireAfter,
        ctx.assertOwner,
      )
    } catch (error) {
      try {
        await ctx.deps.discardMintOutput(stagedOutput, ctx.assertOwner)
      } catch (cleanupError) {
        return errResult(
          'make_invoice',
          'INTERNAL',
          cleanupError instanceof Error ? cleanupError.message : String(cleanupError),
        )
      }
      return errResult(
        'make_invoice',
        'INTERNAL',
        error instanceof Error ? error.message : String(error),
      )
    }
  }
  const entry: PendingInvoice = {
    invoice: prepared.invoice,
    paymentHash: resolvePaymentHash(prepared),
    amountMsat: prepared.grossMsat,
    createdAt: ctx.nowSeconds(),
    prepared,
    stagedOutput,
    state: 'pending',
  }
  if (typeof params.description === 'string' && params.description) {
    entry.description = params.description
  }
  const expiry = Number(params.expiry)
  if (Number.isInteger(expiry) && expiry > 0) {
    entry.expiresAt = entry.createdAt + expiry
  }
  ctx.invoices.set(entry.paymentHash, entry)
  // phase two runs in the background; the invoice goes out now and
  // lookup_invoice reports the settlement the service-owned claim observes
  const started = ctx.startBackground(() =>
    settleAndClaim(ctx, entry).catch((err) => {
      entry.state = 'failed'
      // an interrupted claim poll is normal service teardown (stop
      // aborted it), not a background failure worth surfacing
      if (err instanceof PollAbortedError) return
      ctx.deps.onError?.(err, ctx.connection())
    }),
  )
  if (!started) {
    entry.state = 'failed'
    return errResult('make_invoice', 'INTERNAL', 'The wallet service is stopping.')
  }
  return okResult('make_invoice', invoiceResult(entry))
}

const handleLookupInvoice = (ctx: RequestContext, params: Record<string, unknown>): NwcResponse => {
  const invoiceParam = typeof params.invoice === 'string' ? params.invoice : undefined
  const hashParam =
    typeof params.payment_hash === 'string' ? params.payment_hash.toLowerCase() : undefined
  if (!invoiceParam && !hashParam) {
    return errResult('lookup_invoice', 'OTHER', 'Provide an invoice or a payment hash.')
  }
  let entry = hashParam ? ctx.invoices.get(hashParam) : undefined
  if (!entry && invoiceParam) {
    for (const candidate of ctx.invoices.values()) {
      if (sameInvoice(candidate.invoice, invoiceParam)) {
        entry = candidate
        break
      }
    }
  }
  if (!entry) {
    return errResult('lookup_invoice', 'NOT_FOUND', 'Unknown invoice.')
  }
  return okResult('lookup_invoice', invoiceResult(entry))
}

export const dispatch = async (ctx: RequestContext, request: NwcRequest): Promise<NwcResponse> => {
  switch (request.method) {
    case 'get_info':
      return handleGetInfo(ctx)
    case 'get_balance':
      return handleGetBalance(ctx)
    case 'make_invoice':
      return await handleMakeInvoice(ctx, request.params)
    case 'pay_invoice':
      return await handlePayInvoice(ctx, request.params)
    case 'lookup_invoice':
      return handleLookupInvoice(ctx, request.params)
    default:
      return errResult(request.method, 'NOT_IMPLEMENTED', `Unknown method: ${request.method}.`)
  }
}