/**
 * This code was AUTOGENERATED using the Codama library.
 * Please DO NOT EDIT THIS FILE, instead use visitors
 * to add features, then rerun Codama to update it.
 *
 * @see https://github.com/codama-idl/codama
 */

import {
  assertAccountExists,
  assertAccountsExist,
  combineCodec,
  decodeAccount,
  fetchEncodedAccount,
  fetchEncodedAccounts,
  fixDecoderSize,
  fixEncoderSize,
  getAddressDecoder,
  getAddressEncoder,
  getArrayDecoder,
  getArrayEncoder,
  getBytesDecoder,
  getBytesEncoder,
  getStructDecoder,
  getStructEncoder,
  getU16Decoder,
  getU16Encoder,
  transformEncoder,
  type Account,
  type Address,
  type EncodedAccount,
  type FetchAccountConfig,
  type FetchAccountsConfig,
  type FixedSizeCodec,
  type FixedSizeDecoder,
  type FixedSizeEncoder,
  type MaybeAccount,
  type MaybeEncodedAccount,
  type ReadonlyUint8Array,
} from "@solana/kit";
import {
  getTwapEnabledBitmaskDecoder,
  getTwapEnabledBitmaskEncoder,
  type TwapEnabledBitmask,
  type TwapEnabledBitmaskArgs,
} from "../types";

export const ORACLE_MAPPINGS_DISCRIMINATOR = new Uint8Array([
  40, 244, 110, 80, 255, 214, 243, 188,
]);

export function getOracleMappingsDiscriminatorBytes() {
  return fixEncoderSize(getBytesEncoder(), 8).encode(
    ORACLE_MAPPINGS_DISCRIMINATOR,
  );
}

export type OracleMappings = {
  discriminator: ReadonlyUint8Array;
  priceInfoAccounts: Array<Address>;
  priceTypes: ReadonlyUint8Array;
  twapSourceOrRefPriceToleranceBps: Array<number>;
  twapEnabledBitmask: Array<TwapEnabledBitmask>;
  refPrice: Array<number>;
  generic: Array<ReadonlyUint8Array>;
};

export type OracleMappingsArgs = {
  priceInfoAccounts: Array<Address>;
  priceTypes: ReadonlyUint8Array;
  twapSourceOrRefPriceToleranceBps: Array<number>;
  twapEnabledBitmask: Array<TwapEnabledBitmaskArgs>;
  refPrice: Array<number>;
  generic: Array<ReadonlyUint8Array>;
};

/** Gets the encoder for {@link OracleMappingsArgs} account data. */
export function getOracleMappingsEncoder(): FixedSizeEncoder<OracleMappingsArgs> {
  return transformEncoder(
    getStructEncoder([
      ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
      [
        "priceInfoAccounts",
        getArrayEncoder(getAddressEncoder(), { size: 512 }),
      ],
      ["priceTypes", fixEncoderSize(getBytesEncoder(), 512)],
      [
        "twapSourceOrRefPriceToleranceBps",
        getArrayEncoder(getU16Encoder(), { size: 512 }),
      ],
      [
        "twapEnabledBitmask",
        getArrayEncoder(getTwapEnabledBitmaskEncoder(), { size: 512 }),
      ],
      ["refPrice", getArrayEncoder(getU16Encoder(), { size: 512 })],
      [
        "generic",
        getArrayEncoder(fixEncoderSize(getBytesEncoder(), 20), { size: 512 }),
      ],
    ]),
    (value) => ({ ...value, discriminator: ORACLE_MAPPINGS_DISCRIMINATOR }),
  );
}

/** Gets the decoder for {@link OracleMappings} account data. */
export function getOracleMappingsDecoder(): FixedSizeDecoder<OracleMappings> {
  return getStructDecoder([
    ["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
    ["priceInfoAccounts", getArrayDecoder(getAddressDecoder(), { size: 512 })],
    ["priceTypes", fixDecoderSize(getBytesDecoder(), 512)],
    [
      "twapSourceOrRefPriceToleranceBps",
      getArrayDecoder(getU16Decoder(), { size: 512 }),
    ],
    [
      "twapEnabledBitmask",
      getArrayDecoder(getTwapEnabledBitmaskDecoder(), { size: 512 }),
    ],
    ["refPrice", getArrayDecoder(getU16Decoder(), { size: 512 })],
    [
      "generic",
      getArrayDecoder(fixDecoderSize(getBytesDecoder(), 20), { size: 512 }),
    ],
  ]);
}

/** Gets the codec for {@link OracleMappings} account data. */
export function getOracleMappingsCodec(): FixedSizeCodec<
  OracleMappingsArgs,
  OracleMappings
> {
  return combineCodec(getOracleMappingsEncoder(), getOracleMappingsDecoder());
}

export function decodeOracleMappings<TAddress extends string = string>(
  encodedAccount: EncodedAccount<TAddress>,
): Account<OracleMappings, TAddress>;
export function decodeOracleMappings<TAddress extends string = string>(
  encodedAccount: MaybeEncodedAccount<TAddress>,
): MaybeAccount<OracleMappings, TAddress>;
export function decodeOracleMappings<TAddress extends string = string>(
  encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>,
): Account<OracleMappings, TAddress> | MaybeAccount<OracleMappings, TAddress> {
  return decodeAccount(
    encodedAccount as MaybeEncodedAccount<TAddress>,
    getOracleMappingsDecoder(),
  );
}

export async function fetchOracleMappings<TAddress extends string = string>(
  rpc: Parameters<typeof fetchEncodedAccount>[0],
  address: Address<TAddress>,
  config?: FetchAccountConfig,
): Promise<Account<OracleMappings, TAddress>> {
  const maybeAccount = await fetchMaybeOracleMappings(rpc, address, config);
  assertAccountExists(maybeAccount);
  return maybeAccount;
}

export async function fetchMaybeOracleMappings<
  TAddress extends string = string,
>(
  rpc: Parameters<typeof fetchEncodedAccount>[0],
  address: Address<TAddress>,
  config?: FetchAccountConfig,
): Promise<MaybeAccount<OracleMappings, TAddress>> {
  const maybeAccount = await fetchEncodedAccount(rpc, address, config);
  return decodeOracleMappings(maybeAccount);
}

export async function fetchAllOracleMappings(
  rpc: Parameters<typeof fetchEncodedAccounts>[0],
  addresses: Array<Address>,
  config?: FetchAccountsConfig,
): Promise<Account<OracleMappings>[]> {
  const maybeAccounts = await fetchAllMaybeOracleMappings(
    rpc,
    addresses,
    config,
  );
  assertAccountsExist(maybeAccounts);
  return maybeAccounts;
}

export async function fetchAllMaybeOracleMappings(
  rpc: Parameters<typeof fetchEncodedAccounts>[0],
  addresses: Array<Address>,
  config?: FetchAccountsConfig,
): Promise<MaybeAccount<OracleMappings>[]> {
  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
  return maybeAccounts.map((maybeAccount) =>
    decodeOracleMappings(maybeAccount),
  );
}

export function getOracleMappingsSize(): number {
  return 29704;
}