/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
import * as core_KeyAuthorization from '../../tempo/KeyAuthorization.js'
import * as z_Address from '../Address.js'
import * as z_Hex from '../Hex.js'
import {
  uintBigintNumberish,
  uintNumberNumberish,
} from '../internal/Integer.js'
import * as z from 'zod/mini'
import * as z_SignatureEnvelope from './SignatureEnvelope.js'

/** RPC token spending limit schema. */
export const RpcTokenLimit = z.object({
  limit: z_Hex.Hex,
  period: z.optional(z.nullable(z_Hex.Hex)),
  token: z_Address.Address,
})

/** RPC selector rule schema. */
export const RpcSelectorRule = z.object({
  recipients: z.optional(z.nullable(z.readonly(z.array(z_Address.Address)))),
  selector: z_Hex.Hex,
})

/** RPC call scope schema. */
export const RpcCallScope = z.object({
  selectorRules: z.optional(z.nullable(z.readonly(z.array(RpcSelectorRule)))),
  target: z_Address.Address,
})

/** RPC key authorization schema. */
export const Rpc = z
  .object({
    account: z.optional(z.nullable(z_Address.Address)),
    allowedCalls: z.optional(z.nullable(z.readonly(z.array(RpcCallScope)))),
    chainId: z_Hex.Hex,
    expiry: z.optional(z.nullable(z_Hex.Hex)),
    isAdmin: z.optional(z.nullable(z.boolean())),
    keyId: z_Address.Address,
    keyType: z.union([z_SignatureEnvelope.Type, z.literal('multisig')]),
    limits: z.optional(z.nullable(z.readonly(z.array(RpcTokenLimit)))),
    signature: z.union([
      z_SignatureEnvelope.PrimitiveRpc,
      z_SignatureEnvelope.MultisigRpc,
    ]),
    witness: z.optional(z.nullable(z_Hex.Hex)),
  })
  .check(
    z.refine(
      (value) => value.keyType !== 'multisig' || value.account != null,
      'multisig key grants require a parent account binding',
    ),
  )

/** Token spending limit schema. */
export const TokenLimit = z.object({
  limit: z.bigint(),
  period: z.optional(z.number()),
  token: z_Address.Address,
})

/** Encode-only token spending limit schema accepting numberish `toRpc` inputs. */
export const TokenLimitToRpc = z.object({
  limit: uintBigintNumberish(),
  period: z.optional(uintNumberNumberish()),
  token: z_Address.Address,
})

/** Call scope schema. */
export const Scope = z.object({
  address: z_Address.Address,
  recipients: z.optional(z.readonly(z.array(z_Address.Address))),
  selector: z.optional(z.union([z_Hex.Hex, z.string()])),
})

const domainShape = {
  address: z_Address.Address,
  chainId: z.bigint(),
  expiry: z.optional(z.number()),
  limits: z.optional(z.readonly(z.array(TokenLimit))),
  scopes: z.optional(z.readonly(z.array(Scope))),
  signature: z.union([
    z_SignatureEnvelope.Primitive,
    z_SignatureEnvelope.Multisig,
  ]),
  type: z.union([z_SignatureEnvelope.Type, z.literal('multisig')]),
  witness: z.optional(z_Hex.Hex),
}

/** Decoded key authorization schema. */
export const Domain = z
  .object({
    ...domainShape,
    account: z.optional(z_Address.Address),
    isAdmin: z.optional(z.boolean()),
  })
  .check(
    z.refine(
      (value) => value.type !== 'multisig' || value.account != null,
      'multisig key grants require a parent account binding',
    ),
  )

const domainToRpcShape = {
  ...domainShape,
  chainId: uintBigintNumberish(),
  expiry: z.optional(uintNumberNumberish()),
  limits: z.optional(z.readonly(z.array(TokenLimitToRpc))),
}

/** Encode-only decoded key authorization schema accepting numberish `toRpc` inputs. */
export const DomainToRpc = z
  .object({
    ...domainToRpcShape,
    account: z.optional(z_Address.Address),
    isAdmin: z.optional(z.boolean()),
  })
  .check(
    z.refine(
      (value) => value.type !== 'multisig' || value.account != null,
      'multisig key grants require a parent account binding',
    ),
  )

/** Codec decoding an RPC key authorization into a signed key authorization. */
export const KeyAuthorization = z.codec(Rpc, Domain, {
  decode: (value) => core_KeyAuthorization.fromRpc(value as never) as never,
  encode: (value) => core_KeyAuthorization.toRpc(value as never) as never,
})

/** Encode-only key authorization codec accepting numberish `toRpc` inputs. */
export const KeyAuthorizationToRpc = z.codec(Rpc, DomainToRpc, {
  decode: (value) => core_KeyAuthorization.fromRpc(value as never) as never,
  encode: (value) => core_KeyAuthorization.toRpc(value as never) as never,
})

/** Signed key authorization schema. */
export const Signed = KeyAuthorization

/** Encode-only signed key authorization schema accepting numberish `toRpc` inputs. */
export const SignedToRpc = KeyAuthorizationToRpc