/**
 * 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,
  getU8Decoder,
  getU8Encoder,
  transformEncoder,
  type Account,
  type Address,
  type Codec,
  type Decoder,
  type EncodedAccount,
  type Encoder,
  type FetchAccountConfig,
  type FetchAccountsConfig,
  type MaybeAccount,
  type MaybeEncodedAccount,
  type ReadonlyUint8Array,
} from '@solana/kit';
import {
  getU16F16Decoder,
  getU16F16Encoder,
  type U16F16,
  type U16F16Args,
} from '../../fixed/codecs';
import { findScanPatternPda, ScanPatternSeeds } from '../pdas';
import {
  getNameDecoder,
  getNameEncoder,
  getScanCostDecoder,
  getScanCostEncoder,
  getScanLootEntryDecoder,
  getScanLootEntryEncoder,
  getScanNoiseMapDecoder,
  getScanNoiseMapEncoder,
  getScanPatternIdDecoder,
  getScanPatternIdEncoder,
  getScanPatternStatusDecoder,
  getScanPatternStatusEncoder,
  type Name,
  type NameArgs,
  type ScanCost,
  type ScanCostArgs,
  type ScanLootEntry,
  type ScanLootEntryArgs,
  type ScanNoiseMap,
  type ScanNoiseMapArgs,
  type ScanPatternId,
  type ScanPatternIdArgs,
  type ScanPatternStatus,
  type ScanPatternStatusArgs,
} from '../types';

export const SCAN_PATTERN_DISCRIMINATOR = new Uint8Array([
  53, 211, 97, 30, 123, 229, 46, 55,
]);

export function getScanPatternDiscriminatorBytes() {
  return fixEncoderSize(getBytesEncoder(), 8).encode(
    SCAN_PATTERN_DISCRIMINATOR,
  );
}

export type ScanPattern = {
  discriminator: ReadonlyUint8Array;
  version: number;
  bump: number;
  scanPatternId: ScanPatternId;
  name: Name;
  gameId: Address;
  cooldownMultiplier: U16F16;
  /** Weight that is always added, if rolled scan is a failure */
  blankWeight: U16F16;
  /** Multiplied by scan power */
  blankXpValue: U16F16;
  status: ScanPatternStatus;
  /** All costs are paid per scan. */
  cost: Array<ScanCost>;
  /** One entry is chosen per scan. */
  lootTable: Array<ScanLootEntry>;
  noiseMaps: Array<ScanNoiseMap>;
};

export type ScanPatternArgs = {
  version: number;
  bump: number;
  scanPatternId: ScanPatternIdArgs;
  name: NameArgs;
  gameId: Address;
  cooldownMultiplier: U16F16Args;
  /** Weight that is always added, if rolled scan is a failure */
  blankWeight: U16F16Args;
  /** Multiplied by scan power */
  blankXpValue: U16F16Args;
  status: ScanPatternStatusArgs;
  /** All costs are paid per scan. */
  cost: Array<ScanCostArgs>;
  /** One entry is chosen per scan. */
  lootTable: Array<ScanLootEntryArgs>;
  noiseMaps: Array<ScanNoiseMapArgs>;
};

/** Gets the encoder for {@link ScanPatternArgs} account data. */
export function getScanPatternEncoder(): Encoder<ScanPatternArgs> {
  return transformEncoder(
    getStructEncoder([
      ['discriminator', fixEncoderSize(getBytesEncoder(), 8)],
      ['version', getU8Encoder()],
      ['bump', getU8Encoder()],
      ['scanPatternId', getScanPatternIdEncoder()],
      ['name', getNameEncoder()],
      ['gameId', getAddressEncoder()],
      ['cooldownMultiplier', getU16F16Encoder()],
      ['blankWeight', getU16F16Encoder()],
      ['blankXpValue', getU16F16Encoder()],
      ['status', getScanPatternStatusEncoder()],
      ['cost', getArrayEncoder(getScanCostEncoder())],
      ['lootTable', getArrayEncoder(getScanLootEntryEncoder())],
      ['noiseMaps', getArrayEncoder(getScanNoiseMapEncoder())],
    ]),
    (value) => ({ ...value, discriminator: SCAN_PATTERN_DISCRIMINATOR }),
  );
}

/** Gets the decoder for {@link ScanPattern} account data. */
export function getScanPatternDecoder(): Decoder<ScanPattern> {
  return getStructDecoder([
    ['discriminator', fixDecoderSize(getBytesDecoder(), 8)],
    ['version', getU8Decoder()],
    ['bump', getU8Decoder()],
    ['scanPatternId', getScanPatternIdDecoder()],
    ['name', getNameDecoder()],
    ['gameId', getAddressDecoder()],
    ['cooldownMultiplier', getU16F16Decoder()],
    ['blankWeight', getU16F16Decoder()],
    ['blankXpValue', getU16F16Decoder()],
    ['status', getScanPatternStatusDecoder()],
    ['cost', getArrayDecoder(getScanCostDecoder())],
    ['lootTable', getArrayDecoder(getScanLootEntryDecoder())],
    ['noiseMaps', getArrayDecoder(getScanNoiseMapDecoder())],
  ]);
}

/** Gets the codec for {@link ScanPattern} account data. */
export function getScanPatternCodec(): Codec<ScanPatternArgs, ScanPattern> {
  return combineCodec(getScanPatternEncoder(), getScanPatternDecoder());
}

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

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

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

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

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

export async function fetchScanPatternFromSeeds(
  rpc: Parameters<typeof fetchEncodedAccount>[0],
  seeds: ScanPatternSeeds,
  config: FetchAccountConfig & { programAddress?: Address } = {},
): Promise<Account<ScanPattern>> {
  const maybeAccount = await fetchMaybeScanPatternFromSeeds(rpc, seeds, config);
  assertAccountExists(maybeAccount);
  return maybeAccount;
}

export async function fetchMaybeScanPatternFromSeeds(
  rpc: Parameters<typeof fetchEncodedAccount>[0],
  seeds: ScanPatternSeeds,
  config: FetchAccountConfig & { programAddress?: Address } = {},
): Promise<MaybeAccount<ScanPattern>> {
  const { programAddress, ...fetchConfig } = config;
  const [address] = await findScanPatternPda(seeds, { programAddress });
  return await fetchMaybeScanPattern(rpc, address, fetchConfig);
}