/**
 * 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,
  getI64Decoder,
  getI64Encoder,
  getStructDecoder,
  getStructEncoder,
  getU16Decoder,
  getU16Encoder,
  getU32Decoder,
  getU32Encoder,
  getU64Decoder,
  getU64Encoder,
  getU8Decoder,
  getU8Encoder,
  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 { findScanPatternPolicyPda, ScanPatternPolicySeeds } from '../pdas';
import {
  getResearchTagDecoder,
  getResearchTagEncoder,
  getScanPatternIdDecoder,
  getScanPatternIdEncoder,
  type ResearchTag,
  type ResearchTagArgs,
  type ScanPatternId,
  type ScanPatternIdArgs,
} from '../types';

export const SCAN_PATTERN_POLICY_DISCRIMINATOR = new Uint8Array([
  73, 104, 134, 68, 216, 131, 153, 184,
]);

export function getScanPatternPolicyDiscriminatorBytes() {
  return fixEncoderSize(getBytesEncoder(), 8).encode(
    SCAN_PATTERN_POLICY_DISCRIMINATOR,
  );
}

export type ScanPatternPolicy = {
  discriminator: ReadonlyUint8Array;
  version: number;
  bump: number;
  gameId: Address;
  scanPatternId: ScanPatternId;
  status: number;
  strategy: number;
  revision: number;
  contentHash: Array<number>;
  contactChanceBps: number;
  maxRarity: number;
  requiredResearchTagCount: number;
  requiredResearchTags: Array<ResearchTag>;
  targetRadius: bigint;
  signalTtlSecs: number;
  noContactXp: bigint;
  recoveryXp: bigint;
  exhaustionPerRecoveryBps: number;
  maxExhaustionBps: number;
  exhaustionDecaySecs: number;
  valueBudget: bigint;
  allowedFocusCategoryMask: number;
  reserved: Array<number>;
};

export type ScanPatternPolicyArgs = {
  version: number;
  bump: number;
  gameId: Address;
  scanPatternId: ScanPatternIdArgs;
  status: number;
  strategy: number;
  revision: number;
  contentHash: Array<number>;
  contactChanceBps: number;
  maxRarity: number;
  requiredResearchTagCount: number;
  requiredResearchTags: Array<ResearchTagArgs>;
  targetRadius: number | bigint;
  signalTtlSecs: number;
  noContactXp: number | bigint;
  recoveryXp: number | bigint;
  exhaustionPerRecoveryBps: number;
  maxExhaustionBps: number;
  exhaustionDecaySecs: number;
  valueBudget: number | bigint;
  allowedFocusCategoryMask: number;
  reserved: Array<number>;
};

/** Gets the encoder for {@link ScanPatternPolicyArgs} account data. */
export function getScanPatternPolicyEncoder(): FixedSizeEncoder<ScanPatternPolicyArgs> {
  return transformEncoder(
    getStructEncoder([
      ['discriminator', fixEncoderSize(getBytesEncoder(), 8)],
      ['version', getU8Encoder()],
      ['bump', getU8Encoder()],
      ['gameId', getAddressEncoder()],
      ['scanPatternId', getScanPatternIdEncoder()],
      ['status', getU8Encoder()],
      ['strategy', getU8Encoder()],
      ['revision', getU32Encoder()],
      ['contentHash', getArrayEncoder(getU8Encoder(), { size: 32 })],
      ['contactChanceBps', getU16Encoder()],
      ['maxRarity', getU8Encoder()],
      ['requiredResearchTagCount', getU8Encoder()],
      [
        'requiredResearchTags',
        getArrayEncoder(getResearchTagEncoder(), { size: 4 }),
      ],
      ['targetRadius', getI64Encoder()],
      ['signalTtlSecs', getU32Encoder()],
      ['noContactXp', getU64Encoder()],
      ['recoveryXp', getU64Encoder()],
      ['exhaustionPerRecoveryBps', getU16Encoder()],
      ['maxExhaustionBps', getU16Encoder()],
      ['exhaustionDecaySecs', getU32Encoder()],
      ['valueBudget', getU64Encoder()],
      ['allowedFocusCategoryMask', getU8Encoder()],
      ['reserved', getArrayEncoder(getU8Encoder(), { size: 16 })],
    ]),
    (value) => ({ ...value, discriminator: SCAN_PATTERN_POLICY_DISCRIMINATOR }),
  );
}

/** Gets the decoder for {@link ScanPatternPolicy} account data. */
export function getScanPatternPolicyDecoder(): FixedSizeDecoder<ScanPatternPolicy> {
  return getStructDecoder([
    ['discriminator', fixDecoderSize(getBytesDecoder(), 8)],
    ['version', getU8Decoder()],
    ['bump', getU8Decoder()],
    ['gameId', getAddressDecoder()],
    ['scanPatternId', getScanPatternIdDecoder()],
    ['status', getU8Decoder()],
    ['strategy', getU8Decoder()],
    ['revision', getU32Decoder()],
    ['contentHash', getArrayDecoder(getU8Decoder(), { size: 32 })],
    ['contactChanceBps', getU16Decoder()],
    ['maxRarity', getU8Decoder()],
    ['requiredResearchTagCount', getU8Decoder()],
    [
      'requiredResearchTags',
      getArrayDecoder(getResearchTagDecoder(), { size: 4 }),
    ],
    ['targetRadius', getI64Decoder()],
    ['signalTtlSecs', getU32Decoder()],
    ['noContactXp', getU64Decoder()],
    ['recoveryXp', getU64Decoder()],
    ['exhaustionPerRecoveryBps', getU16Decoder()],
    ['maxExhaustionBps', getU16Decoder()],
    ['exhaustionDecaySecs', getU32Decoder()],
    ['valueBudget', getU64Decoder()],
    ['allowedFocusCategoryMask', getU8Decoder()],
    ['reserved', getArrayDecoder(getU8Decoder(), { size: 16 })],
  ]);
}

/** Gets the codec for {@link ScanPatternPolicy} account data. */
export function getScanPatternPolicyCodec(): FixedSizeCodec<
  ScanPatternPolicyArgs,
  ScanPatternPolicy
> {
  return combineCodec(
    getScanPatternPolicyEncoder(),
    getScanPatternPolicyDecoder(),
  );
}

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

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

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

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

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

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

export async function fetchMaybeScanPatternPolicyFromSeeds(
  rpc: Parameters<typeof fetchEncodedAccount>[0],
  seeds: ScanPatternPolicySeeds,
  config: FetchAccountConfig & { programAddress?: Address } = {},
): Promise<MaybeAccount<ScanPatternPolicy>> {
  const { programAddress, ...fetchConfig } = config;
  const [address] = await findScanPatternPolicyPda(seeds, { programAddress });
  return await fetchMaybeScanPatternPolicy(rpc, address, fetchConfig);
}