import * as core_Idempotency from '../../../internal/Idempotency.js'
import * as Ttl from '../../../internal/Ttl.js'
import type * as Mpp from '../Mpp.js'

/**
 * API-level retry coordination for `POST /v1/mpp/broadcast`, backed by the
 * shared coordinator in `internal/Idempotency.ts`.
 *
 * MPPX consumes payment proofs, preventing settlement replay. This module instead lets a caller recover a successful receipt after a transport timeout.
 */

/** Identity for one caller-supplied idempotent broadcast request. */
export type Identity = core_Idempotency.Identity

const broadcast = core_Idempotency.create<Mpp.BroadcastResponse>({
  namespace: 'mpp:relay:v1',
  // Covers the confirmation wait after a credential has passed its
  // five-second validity window.
  pendingTtl: Ttl.minutes(1),
  // Retains a successful settlement receipt for client recovery after
  // transport failures.
  receiptTtl: Ttl.days(1),
})

/** Returns a stable digest without retaining credential contents in durable state. */
export function inputHash(input: Mpp.RelayInput) {
  return core_Idempotency.inputHash(input)
}

/** Claims a broadcast request or returns its current outcome. */
export function claim(options: claim.Options): Promise<claim.Result> {
  return broadcast.claim(options)
}

export declare namespace claim {
  /** Outcome from attempting to claim an idempotency key. */
  type Result = core_Idempotency.claim.Result<Mpp.BroadcastResponse>

  /** Dependencies for claiming one idempotency key. */
  type Options = core_Idempotency.claim.Options
}

/** Persists a successful response for an owned request claim. */
export function complete(options: complete.Options): Promise<void> {
  return broadcast.complete(options)
}

export declare namespace complete {
  /** Dependencies for persisting one terminal broadcast response. */
  type Options = core_Idempotency.complete.Options<Mpp.BroadcastResponse>
}

/** Releases an owned retryable request claim. */
export function release(options: release.Options): Promise<void> {
  return broadcast.release(options)
}

export declare namespace release {
  /** Dependencies for releasing one idempotency claim. */
  type Options = core_Idempotency.release.Options
}