import {z} from 'zod'

export type CoreSortOrder = 'ASC' | 'DESC';

export type CoreTickerKind = 'Native' | 'Contract' | 'Token';

export type CoreTickerValidationStatusFilter = 'Validated' | 'NonValidated';

export type CoreLockStatus = 'Unlocked' | 'Locked' | 'Archived';

export type GetApiV1TickersArgs = {limit?: number | undefined, startingAfter?: string | undefined, sortBy?: ('id' | 'ledgerId' | 'kind' | 'name' | 'symbol') | undefined, sortOrder?: CoreSortOrder | undefined, ledgerId?: Array<string> | undefined, kind?: CoreTickerKind | undefined, name?: Array<string> | undefined, symbol?: Array<string> | undefined, validationStatus?: CoreTickerValidationStatusFilter | undefined, lock?: Array<CoreLockStatus> | undefined};

export type GetApiV1TickersOptions = {baseUrl: string, httpAuth?: string | undefined, fetch?: typeof fetch | undefined};

export const coreTickerKind = z.enum(["Native", "Contract", "Token"]);

export const coreAlgorandTickerProperties = z.object({type: z.literal("Native")});

export const coreTickerLedgerDetailsAlgorand = z.object({properties: coreAlgorandTickerProperties, type: z.literal("Algorand")});

export const coreBitcoinTickerProperties = z.object({type: z.literal("Native")});

export const coreTickerLedgerDetailsBitcoin = z.object({properties: coreBitcoinTickerProperties, type: z.literal("Bitcoin")});

export const coreCardanoTickerProperties = z.object({type: z.literal("Native")});

export const coreTickerLedgerDetailsCardano = z.object({properties: coreCardanoTickerProperties, type: z.literal("Cardano")});

export const coreEthereumTickerPropertiesERC1155 = z.object({address: z.string().min(1).max(512), tokenId: z.string(), type: z.literal("ERC1155")});

export const coreEthereumTickerPropertiesERC20 = z.object({address: z.string().min(1).max(512), type: z.literal("ERC20")});

export const coreEthereumTickerPropertiesERC721 = z.object({address: z.string().min(1).max(512), tokenId: z.string(), type: z.literal("ERC721")});

export const coreEthereumTickerPropertiesNative = z.object({type: z.literal("Native")});

export const coreEthereumTickerProperties = z.discriminatedUnion("type", [coreEthereumTickerPropertiesERC1155, coreEthereumTickerPropertiesERC20, coreEthereumTickerPropertiesERC721, coreEthereumTickerPropertiesNative]);

export const coreTickerLedgerDetailsEthereum = z.object({properties: coreEthereumTickerProperties, type: z.literal("Ethereum")});

export const coreHederaTickerPropertiesFungibleToken = z.object({id: z.string().min(5).max(20), type: z.literal("FungibleToken")});

export const coreHederaTickerPropertiesNative = z.object({type: z.literal("Native")});

export const coreHederaTickerPropertiesNonFungibleToken = z.object({id: z.string().min(5).max(20), serialNumber: z.number().int(), type: z.literal("NonFungibleToken")});

export const coreHederaTickerProperties = z.discriminatedUnion("type", [coreHederaTickerPropertiesFungibleToken, coreHederaTickerPropertiesNative, coreHederaTickerPropertiesNonFungibleToken]);

export const coreTickerLedgerDetailsHedera = z.object({properties: coreHederaTickerProperties, type: z.literal("Hedera")});

export const coreSolanaTickerPropertiesNative = z.object({type: z.literal("Native")});

export const coreSolanaTokenType = z.enum(["SPL", "SPL2022"]);

export const coreSolanaTickerPropertiesToken = z.object({mint: z.string().min(1).max(512), tokenType: coreSolanaTokenType, type: z.literal("Token")});

export const coreSolanaTickerProperties = z.discriminatedUnion("type", [coreSolanaTickerPropertiesNative, coreSolanaTickerPropertiesToken]);

export const coreTickerLedgerDetailsSolana = z.object({properties: coreSolanaTickerProperties, type: z.literal("Solana")});

export const coreStellarTickerPropertiesNative = z.object({type: z.literal("Native")});

export const coreStellarTickerPropertiesToken = z.object({code: z.string().min(1).max(100), issuer: z.string().min(1).max(512), type: z.literal("Token")});

export const coreStellarTickerProperties = z.discriminatedUnion("type", [coreStellarTickerPropertiesNative, coreStellarTickerPropertiesToken]);

export const coreTickerLedgerDetailsStellar = z.object({properties: coreStellarTickerProperties, type: z.literal("Stellar")});

export const coreSubstrateTickerProperties = z.object({type: z.literal("Native")});

export const coreTickerLedgerDetailsSubstrate = z.object({properties: coreSubstrateTickerProperties, type: z.literal("Substrate")});

export const coreTezosTickerProperties = z.object({type: z.literal("Native")});

export const coreTickerLedgerDetailsTezos = z.object({properties: coreTezosTickerProperties, type: z.literal("Tezos")});

export const coreTronTickerPropertiesNative = z.object({type: z.literal("Native")});

export const coreTronTickerPropertiesTRC20 = z.object({contractAddress: z.string().min(1).max(512), type: z.literal("TRC20")});

export const coreTronTickerProperties = z.discriminatedUnion("type", [coreTronTickerPropertiesNative, coreTronTickerPropertiesTRC20]);

export const coreTickerLedgerDetailsTron = z.object({properties: coreTronTickerProperties, type: z.literal("Tron")});

export const coreXrplTickerPropertiesFungibleToken = z.object({currencyCode: z.string().min(1).max(100), issuer: z.string().min(25).max(35), type: z.literal("FungibleToken")});

export const coreXrplTickerPropertiesMultiPurposeToken = z.object({issuanceId: z.string(), type: z.literal("MultiPurposeToken")});

export const coreXrplTickerPropertiesNative = z.object({type: z.literal("Native")});

export const coreXrplTickerProperties = z.discriminatedUnion("type", [coreXrplTickerPropertiesFungibleToken, coreXrplTickerPropertiesMultiPurposeToken, coreXrplTickerPropertiesNative]);

export const coreTickerLedgerDetailsXRPL = z.object({properties: coreXrplTickerProperties, type: z.literal("XRPL")});

export const coreTickerLedgerDetails = z.discriminatedUnion("type", [coreTickerLedgerDetailsAlgorand, coreTickerLedgerDetailsBitcoin, coreTickerLedgerDetailsCardano, coreTickerLedgerDetailsEthereum, coreTickerLedgerDetailsHedera, coreTickerLedgerDetailsSolana, coreTickerLedgerDetailsStellar, coreTickerLedgerDetailsSubstrate, coreTickerLedgerDetailsTezos, coreTickerLedgerDetailsTron, coreTickerLedgerDetailsXRPL]);

export const coreLockStatus = z.enum(["Unlocked", "Locked", "Archived"]);

export const coreUserReference = z.object({id: z.string(), domainId: z.string()});

export const coreStringsMap = z.record(z.string(), z.string());

export const coreEntityMetadata = z.object({description: z.string().max(250).optional(), revision: z.number().int().gte(1), createdAt: z.string(), createdBy: coreUserReference.optional(), lastModifiedAt: z.string(), lastModifiedBy: coreUserReference.optional(), customProperties: coreStringsMap});

export const coreApiTickerData = z.object({id: z.string(), ledgerId: z.string().min(1).max(100), kind: coreTickerKind, name: z.string().min(1).max(100), decimals: z.number().int().optional(), symbol: z.string().min(1).max(100).optional(), ledgerDetails: coreTickerLedgerDetails, lock: coreLockStatus, metadata: coreEntityMetadata.optional()});

export const coreApiTicker = z.object({id: z.string(), ledgerId: z.string().min(1).max(100), kind: coreTickerKind, name: z.string().min(1).max(100), decimals: z.number().int().optional(), symbol: z.string().min(1).max(100).optional(), ledgerDetails: coreTickerLedgerDetails, data: coreApiTickerData, signature: z.string().optional()});

export const coreTickersCollection = z.object({items: z.array(coreApiTicker), count: z.number().int(), currentStartingAfter: z.string().optional(), nextStartingAfter: z.string().optional()});

export const validateResponse = async <Output>(
  schema: {
    readonly '~standard': {
      readonly validate: (value: unknown) => ({ readonly value: Output; readonly issues?: undefined } | { readonly issues: ReadonlyArray<{ readonly message: string; readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined }> }) | Promise<{ readonly value: Output; readonly issues?: undefined } | { readonly issues: ReadonlyArray<{ readonly message: string; readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined }> }>
    }
  },
  value: unknown
): Promise<Output> => {
  const result = await schema['~standard'].validate(value)

  if (result.issues !== undefined) {
    const detail = result.issues
      .map(({ message, path }) =>
        path?.length
          ? `${path.map((segment) => String(typeof segment === 'object' ? segment.key : segment)).join('.')}: ${message}`
          : message
      )
      .join('; ')

    throw new Error(`Response does not match the schema: ${detail}`, { cause: { issues: result.issues } })
  }

  return result.value
};

/**
 * List tickers
 * 
 * GET /v1/tickers
 */
export const getApiV1Tickers = async (args: GetApiV1TickersArgs, options: GetApiV1TickersOptions) => {
const {baseUrl, fetch: fetchFn = fetch, httpAuth} = options ?? {}

const query = new URLSearchParams()
const headers = new Headers()
headers.set('accept', "application/json")

if (args.limit != null) query.append("limit", String(args.limit))
if (args.startingAfter != null) query.append("startingAfter", String(args.startingAfter))
if (args.sortBy != null) query.append("sortBy", String(args.sortBy))
if (args.sortOrder != null) query.append("sortOrder", String(args.sortOrder))
for (const item of args.ledgerId ?? []) query.append("ledgerId", String(item))
if (args.kind != null) query.append("kind", String(args.kind))
for (const item of args.name ?? []) query.append("name", String(item))
for (const item of args.symbol ?? []) query.append("symbol", String(item))
if (args.validationStatus != null) query.append("validationStatus", String(args.validationStatus))
for (const item of args.lock ?? []) query.append("lock", String(item))
if (httpAuth !== undefined) headers.set('authorization', `Bearer ${httpAuth}`)

const url = `${baseUrl.replace(/\/+$/, '')}/v1/tickers${query.size > 0 ? `?${query}` : ''}`

const res = await fetchFn(url, {method: "GET", headers})

if (!res.ok) throw new Error(`Request failed with status ${res.status}`, {cause: {status: res.status, body: await res.text()}})

return validateResponse(coreTickersCollection, await res.json())
};