/**
 * 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,
  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 {
  findScanPatternNoiseMapUploadPda,
  ScanPatternNoiseMapUploadSeeds,
} from '../pdas';
import {
  getScanNoiseMapDecoder,
  getScanNoiseMapEncoder,
  getScanPatternIdDecoder,
  getScanPatternIdEncoder,
  type ScanNoiseMap,
  type ScanNoiseMapArgs,
  type ScanPatternId,
  type ScanPatternIdArgs,
} from '../types';

export const SCAN_PATTERN_NOISE_MAP_UPLOAD_DISCRIMINATOR = new Uint8Array([
  114, 219, 30, 30, 114, 208, 58, 70,
]);

export function getScanPatternNoiseMapUploadDiscriminatorBytes() {
  return fixEncoderSize(getBytesEncoder(), 8).encode(
    SCAN_PATTERN_NOISE_MAP_UPLOAD_DISCRIMINATOR,
  );
}

/**
 * Scan pattern noise-map upload staging account.
 *
 * Used to upload replacement noise maps in chunks without mutating the live
 * [`ScanPattern`] until an explicit commit step.
 */
export type ScanPatternNoiseMapUpload = {
  discriminator: ReadonlyUint8Array;
  version: number;
  gameId: Address;
  scanPatternId: ScanPatternId;
  expectedLen: number;
  bump: number;
  noiseMaps: Array<ScanNoiseMap>;
};

export type ScanPatternNoiseMapUploadArgs = {
  version: number;
  gameId: Address;
  scanPatternId: ScanPatternIdArgs;
  expectedLen: number;
  bump: number;
  noiseMaps: Array<ScanNoiseMapArgs>;
};

/** Gets the encoder for {@link ScanPatternNoiseMapUploadArgs} account data. */
export function getScanPatternNoiseMapUploadEncoder(): Encoder<ScanPatternNoiseMapUploadArgs> {
  return transformEncoder(
    getStructEncoder([
      ['discriminator', fixEncoderSize(getBytesEncoder(), 8)],
      ['version', getU8Encoder()],
      ['gameId', getAddressEncoder()],
      ['scanPatternId', getScanPatternIdEncoder()],
      ['expectedLen', getU16Encoder()],
      ['bump', getU8Encoder()],
      ['noiseMaps', getArrayEncoder(getScanNoiseMapEncoder())],
    ]),
    (value) => ({
      ...value,
      discriminator: SCAN_PATTERN_NOISE_MAP_UPLOAD_DISCRIMINATOR,
    }),
  );
}

/** Gets the decoder for {@link ScanPatternNoiseMapUpload} account data. */
export function getScanPatternNoiseMapUploadDecoder(): Decoder<ScanPatternNoiseMapUpload> {
  return getStructDecoder([
    ['discriminator', fixDecoderSize(getBytesDecoder(), 8)],
    ['version', getU8Decoder()],
    ['gameId', getAddressDecoder()],
    ['scanPatternId', getScanPatternIdDecoder()],
    ['expectedLen', getU16Decoder()],
    ['bump', getU8Decoder()],
    ['noiseMaps', getArrayDecoder(getScanNoiseMapDecoder())],
  ]);
}

/** Gets the codec for {@link ScanPatternNoiseMapUpload} account data. */
export function getScanPatternNoiseMapUploadCodec(): Codec<
  ScanPatternNoiseMapUploadArgs,
  ScanPatternNoiseMapUpload
> {
  return combineCodec(
    getScanPatternNoiseMapUploadEncoder(),
    getScanPatternNoiseMapUploadDecoder(),
  );
}

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

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

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

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

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

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

export async function fetchMaybeScanPatternNoiseMapUploadFromSeeds(
  rpc: Parameters<typeof fetchEncodedAccount>[0],
  seeds: ScanPatternNoiseMapUploadSeeds,
  config: FetchAccountConfig & { programAddress?: Address } = {},
): Promise<MaybeAccount<ScanPatternNoiseMapUpload>> {
  const { programAddress, ...fetchConfig } = config;
  const [address] = await findScanPatternNoiseMapUploadPda(seeds, {
    programAddress,
  });
  return await fetchMaybeScanPatternNoiseMapUpload(rpc, address, fetchConfig);
}