import type { StandardSchemaV1 } from '@standard-schema/spec'
import type { Resolver as _DidResolver } from 'iso-did'
import type { DID, DIDURLObject, VerifiableDID } from 'iso-did/types'
import type { ISigner } from 'iso-signatures/types'
import type { Resolver } from 'iso-signatures/verifiers/resolver.js'
import type { CID } from 'multiformats'
import type { Capability } from './capability'
import type { Delegation } from './delegation'
import type { Invocation } from './invocation'
import type { Store } from './store'
import type { Policy } from './types/policy'

export type { StandardSchemaV1 } from '@standard-schema/spec'
export type { DID, DIDURL, DIDURLObject } from 'iso-did/types'
export type { ISigner } from 'iso-signatures/types'
export * from './rpc/types'
export * from './types/envelope'
export * from './types/policy'
export * from './types/varsig'

export type ResolveProof = (proof: CID) => Promise<Delegation>
export type IsRevoked = (cid: CID) => Promise<boolean>
export type VerifierResolver = Resolver
export type DidResolver = _DidResolver

export type CborPrimitive =
  | string
  | number
  | boolean
  | null
  | bigint
  | Uint8Array
  | ArrayBuffer
export type CborArray = CborValue[] | readonly CborValue[]
export type CborObject =
  | { [Key in string]: CborValue }
  | { [Key in string]?: CborValue | undefined }

export type CborValue = CborPrimitive | CborArray | CborObject

/**
 * Delegation
 */

export interface DelegationOptions<Schema extends StandardSchemaV1> {
  iss: ISigner
  aud: DID
  sub: DID | null
  pol: Policy<StandardSchemaV1.InferOutput<Schema>>
  /**
   * Expiration time in seconds or null for no expiration
   */
  exp?: number | null
  /**
   * Time to live in seconds, expiration thats precedence over ttl
   * @default 300
   */
  ttl?: number
  /**
   * Not before time in seconds
   * Delegation is not valid before this time
   */
  nbf?: number
  nonce?: Uint8Array
  cmd: string
  meta?: CborObject
  /**
   * The current time in seconds. Mostly used for testing.
   * @default Math.floor(Date.now() / 1000)
   */
  now?: number
}

export interface DelegationValidateOptions {
  isRevoked?: IsRevoked
  didResolver?: DidResolver
  verifierResolver: VerifierResolver
  /**
   * The current time in seconds. Mostly used for testing.
   * @default Math.floor(Date.now() / 1000)
   */
  now?: number
}

export interface DelegationFromOptions extends DelegationValidateOptions {
  bytes: Uint8Array
}

/**
 * Invocation
 */

/**
 * Invocation options
 */
export interface InvocationOptions extends DelegationValidateOptions {
  iss: ISigner
  aud?: DID
  sub: DID
  cmd: string
  args: CborObject
  /**
   * Proofs of the chain of authority
   */
  prf: Delegation[]
  /**
   * Expiration time in seconds or null for no expiration
   */
  exp?: number | null
  /**
   * Time to live in seconds, expiration thats precedence over ttl
   * @default 300
   */
  ttl?: number
  /**
   * Issued at time in seconds
   */
  iat?: number
  nbf?: number
  nonce?: Uint8Array
  cause?: CID
  meta?: CborObject
}

export interface InvocationFromOptions extends DelegationValidateOptions {
  bytes: Uint8Array
  audience?: VerifiableDID
  resolveProof: ResolveProof
}

/**
 * Capability types
 */

/**
 * Capability options
 */
export interface CapabilityOptions<
  Schema extends StandardSchemaV1,
  Cmd extends string = string,
> {
  schema: Schema
  cmd: Cmd
}

/**
 * Delegate a capability
 */
export interface CapabilityDelegateOptions<Schema extends StandardSchemaV1>
  extends Omit<DelegationOptions<Schema>, 'cmd'> {
  /**
   * Store to add the delegation to
   */
  store: Store
}

/**
 * Invoke a capability
 */
export interface CapabilityInvokeOptions<Schema extends StandardSchemaV1>
  extends Omit<InvocationOptions, 'cmd' | 'args' | 'prf'> {
  args: StandardSchemaV1.InferOutput<Schema>
  /**
   * Store to resolve proofs from
   */
  store: Store
}

/**
 * Store types
 */

/**
 * Resolve proofs options
 */
export interface StoreProofsOptions {
  aud?: DID
  sub: DID | null
  cmd: string
  args: CborObject
}

/**
 * Server types
 */
export type Promisable<T> = T | PromiseLike<T>

export interface HandlerOptions<Schema extends StandardSchemaV1> {
  args: StandardSchemaV1.InferOutput<Schema>
  store: Store
}

export type Handler<Schema extends StandardSchemaV1, Output> = (
  options: HandlerOptions<Schema>
) => Promisable<Output>

export interface RouteOptions<
  Cap extends Capability<StandardSchemaV1>,
  Output,
> {
  capability: Cap
  handler: Handler<Cap['schema'], Output>
}

export type RouteOutput<Cap extends Capability<StandardSchemaV1>, Output> = {
  cap: Cap
  fn: (options: RouteHandlerOptions) => Promisable<Output>
}

/**
 * Infer the protocol from a router
 */
export type InferProtocol<
  Routes extends Record<
    string,
    RouteOutput<Capability<StandardSchemaV1>, unknown>
  >,
> = {
  [K in keyof Routes]: Routes[K] extends RouteOutput<infer Cap, infer Output>
    ? {
        cmd: Cap['cmd'] extends K ? Cap['cmd'] : never
        in: StandardSchemaV1.InferOutput<Cap['schema']>
        out: Output
      }
    : never
}[keyof Routes]

export type Protocol<
  Cap extends Capability<StandardSchemaV1> = Capability<StandardSchemaV1>,
> = {
  cmd: Cap['cmd']
  in: StandardSchemaV1.InferOutput<Cap['schema']>
  out: unknown
}[]

/**
 * Creates a router type that validates:
 * 1. Router keys match capability commands
 * 2. Router values are RouteOutput types that match the capability
 */
export type Router<Caps extends readonly Capability<StandardSchemaV1>[]> = {
  [K in Caps[number]['cmd']]: Caps extends readonly (infer Cap)[]
    ? Cap extends Capability<StandardSchemaV1>
      ? Cap['cmd'] extends K
        ? RouteOutput<Cap, unknown>
        : never
      : never
    : never
}

export interface RouteHandlerOptions {
  request: Request
  issuer: ISigner
  invocation: Invocation
  store: Store
}

/**
 * Client type that provides type-safe request methods based on router inference
 */
export type RouterClient<
  Router extends InferProtocol<
    Record<string, RouteOutput<Capability<StandardSchemaV1>, unknown>>
  >,
> = {
  request<Cmd extends Router['cmd']>(
    cmd: Cmd,
    args: Extract<Router, { cmd: Cmd }>['in']
  ): Promise<Extract<Router, { cmd: Cmd }>['out']>
}

export type ClientOptions = {
  url: string
  issuer: ISigner
  audience: DIDURLObject
  store: Store
  capabilities: Capability<StandardSchemaV1, string>[]
  verifierResolver: VerifierResolver
}