/**
 * 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,
  getU128Decoder,
  getU128Encoder,
  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 { findScanSignalPda, ScanSignalSeeds } from '../pdas';
import {
  getCargoIdDecoder,
  getCargoIdEncoder,
  getRegionIdDecoder,
  getRegionIdEncoder,
  getScanPatternIdDecoder,
  getScanPatternIdEncoder,
  type CargoId,
  type CargoIdArgs,
  type RegionId,
  type RegionIdArgs,
  type ScanPatternId,
  type ScanPatternIdArgs,
} from '../types';

export const SCAN_SIGNAL_DISCRIMINATOR = new Uint8Array([
  152, 164, 77, 4, 154, 247, 20, 187,
]);

export function getScanSignalDiscriminatorBytes() {
  return fixEncoderSize(getBytesEncoder(), 8).encode(SCAN_SIGNAL_DISCRIMINATOR);
}

export type ScanSignal = {
  discriminator: ReadonlyUint8Array;
  version: number;
  bump: number;
  status: number;
  focus: number;
  gameId: Address;
  ownerProfile: Address;
  ownerCharacter: Address;
  fleet: Address;
  controllerProfile: Address;
  controllerCharacter: Address;
  sequence: bigint;
  regionId: RegionId;
  scanPatternId: ScanPatternId;
  policyRevision: number;
  profileRevision: number;
  policyHash: Array<number>;
  profileHash: Array<number>;
  commitSlot: bigint;
  revealSlots: Array<bigint>;
  eligibilityBitmap: bigint;
  location: Array<bigint>;
  chargeHash: Array<number>;
  cooldownUntil: bigint;
  detectedAt: bigint;
  effectiveScanPower: number;
  contactChanceBps: number;
  exhaustionBps: number;
  chargedItemCount: number;
  flags: number;
  exhaustionDecaySecs: number;
  reserved0: Array<number>;
  seed: bigint;
  target: Array<bigint>;
  targetRadius: bigint;
  expiresAt: bigint;
  cargoId: CargoId;
  rarity: number;
  quantityMode: number;
  category: number;
  lootRowIndex: number;
  reserved1: Array<number>;
  baseQuantity: bigint;
  nominalQuantity: bigint;
  acceptedQuantity: bigint;
  clippedQuantity: bigint;
  rewardXp: bigint;
  xpAwarded: bigint;
  resolvedAt: bigint;
  terminalAt: bigint;
  lastRegion: RegionId;
  consecutiveRecoveries: number;
  lastRecoveryAt: bigint;
  reserved2: Array<number>;
};

export type ScanSignalArgs = {
  version: number;
  bump: number;
  status: number;
  focus: number;
  gameId: Address;
  ownerProfile: Address;
  ownerCharacter: Address;
  fleet: Address;
  controllerProfile: Address;
  controllerCharacter: Address;
  sequence: number | bigint;
  regionId: RegionIdArgs;
  scanPatternId: ScanPatternIdArgs;
  policyRevision: number;
  profileRevision: number;
  policyHash: Array<number>;
  profileHash: Array<number>;
  commitSlot: number | bigint;
  revealSlots: Array<number | bigint>;
  eligibilityBitmap: number | bigint;
  location: Array<number | bigint>;
  chargeHash: Array<number>;
  cooldownUntil: number | bigint;
  detectedAt: number | bigint;
  effectiveScanPower: number;
  contactChanceBps: number;
  exhaustionBps: number;
  chargedItemCount: number;
  flags: number;
  exhaustionDecaySecs: number;
  reserved0: Array<number>;
  seed: number | bigint;
  target: Array<number | bigint>;
  targetRadius: number | bigint;
  expiresAt: number | bigint;
  cargoId: CargoIdArgs;
  rarity: number;
  quantityMode: number;
  category: number;
  lootRowIndex: number;
  reserved1: Array<number>;
  baseQuantity: number | bigint;
  nominalQuantity: number | bigint;
  acceptedQuantity: number | bigint;
  clippedQuantity: number | bigint;
  rewardXp: number | bigint;
  xpAwarded: number | bigint;
  resolvedAt: number | bigint;
  terminalAt: number | bigint;
  lastRegion: RegionIdArgs;
  consecutiveRecoveries: number;
  lastRecoveryAt: number | bigint;
  reserved2: Array<number>;
};

/** Gets the encoder for {@link ScanSignalArgs} account data. */
export function getScanSignalEncoder(): FixedSizeEncoder<ScanSignalArgs> {
  return transformEncoder(
    getStructEncoder([
      ['discriminator', fixEncoderSize(getBytesEncoder(), 8)],
      ['version', getU8Encoder()],
      ['bump', getU8Encoder()],
      ['status', getU8Encoder()],
      ['focus', getU8Encoder()],
      ['gameId', getAddressEncoder()],
      ['ownerProfile', getAddressEncoder()],
      ['ownerCharacter', getAddressEncoder()],
      ['fleet', getAddressEncoder()],
      ['controllerProfile', getAddressEncoder()],
      ['controllerCharacter', getAddressEncoder()],
      ['sequence', getU64Encoder()],
      ['regionId', getRegionIdEncoder()],
      ['scanPatternId', getScanPatternIdEncoder()],
      ['policyRevision', getU32Encoder()],
      ['profileRevision', getU32Encoder()],
      ['policyHash', getArrayEncoder(getU8Encoder(), { size: 32 })],
      ['profileHash', getArrayEncoder(getU8Encoder(), { size: 32 })],
      ['commitSlot', getU64Encoder()],
      ['revealSlots', getArrayEncoder(getU64Encoder(), { size: 3 })],
      ['eligibilityBitmap', getU64Encoder()],
      ['location', getArrayEncoder(getI64Encoder(), { size: 2 })],
      ['chargeHash', getArrayEncoder(getU8Encoder(), { size: 32 })],
      ['cooldownUntil', getI64Encoder()],
      ['detectedAt', getI64Encoder()],
      ['effectiveScanPower', getU32Encoder()],
      ['contactChanceBps', getU16Encoder()],
      ['exhaustionBps', getU16Encoder()],
      ['chargedItemCount', getU8Encoder()],
      ['flags', getU8Encoder()],
      ['exhaustionDecaySecs', getU32Encoder()],
      ['reserved0', getArrayEncoder(getU8Encoder(), { size: 2 })],
      ['seed', getU128Encoder()],
      ['target', getArrayEncoder(getI64Encoder(), { size: 2 })],
      ['targetRadius', getI64Encoder()],
      ['expiresAt', getI64Encoder()],
      ['cargoId', getCargoIdEncoder()],
      ['rarity', getU8Encoder()],
      ['quantityMode', getU8Encoder()],
      ['category', getU8Encoder()],
      ['lootRowIndex', getU8Encoder()],
      ['reserved1', getArrayEncoder(getU8Encoder(), { size: 2 })],
      ['baseQuantity', getU64Encoder()],
      ['nominalQuantity', getU64Encoder()],
      ['acceptedQuantity', getU64Encoder()],
      ['clippedQuantity', getU64Encoder()],
      ['rewardXp', getU64Encoder()],
      ['xpAwarded', getU64Encoder()],
      ['resolvedAt', getI64Encoder()],
      ['terminalAt', getI64Encoder()],
      ['lastRegion', getRegionIdEncoder()],
      ['consecutiveRecoveries', getU16Encoder()],
      ['lastRecoveryAt', getI64Encoder()],
      ['reserved2', getArrayEncoder(getU8Encoder(), { size: 4 })],
    ]),
    (value) => ({ ...value, discriminator: SCAN_SIGNAL_DISCRIMINATOR }),
  );
}

/** Gets the decoder for {@link ScanSignal} account data. */
export function getScanSignalDecoder(): FixedSizeDecoder<ScanSignal> {
  return getStructDecoder([
    ['discriminator', fixDecoderSize(getBytesDecoder(), 8)],
    ['version', getU8Decoder()],
    ['bump', getU8Decoder()],
    ['status', getU8Decoder()],
    ['focus', getU8Decoder()],
    ['gameId', getAddressDecoder()],
    ['ownerProfile', getAddressDecoder()],
    ['ownerCharacter', getAddressDecoder()],
    ['fleet', getAddressDecoder()],
    ['controllerProfile', getAddressDecoder()],
    ['controllerCharacter', getAddressDecoder()],
    ['sequence', getU64Decoder()],
    ['regionId', getRegionIdDecoder()],
    ['scanPatternId', getScanPatternIdDecoder()],
    ['policyRevision', getU32Decoder()],
    ['profileRevision', getU32Decoder()],
    ['policyHash', getArrayDecoder(getU8Decoder(), { size: 32 })],
    ['profileHash', getArrayDecoder(getU8Decoder(), { size: 32 })],
    ['commitSlot', getU64Decoder()],
    ['revealSlots', getArrayDecoder(getU64Decoder(), { size: 3 })],
    ['eligibilityBitmap', getU64Decoder()],
    ['location', getArrayDecoder(getI64Decoder(), { size: 2 })],
    ['chargeHash', getArrayDecoder(getU8Decoder(), { size: 32 })],
    ['cooldownUntil', getI64Decoder()],
    ['detectedAt', getI64Decoder()],
    ['effectiveScanPower', getU32Decoder()],
    ['contactChanceBps', getU16Decoder()],
    ['exhaustionBps', getU16Decoder()],
    ['chargedItemCount', getU8Decoder()],
    ['flags', getU8Decoder()],
    ['exhaustionDecaySecs', getU32Decoder()],
    ['reserved0', getArrayDecoder(getU8Decoder(), { size: 2 })],
    ['seed', getU128Decoder()],
    ['target', getArrayDecoder(getI64Decoder(), { size: 2 })],
    ['targetRadius', getI64Decoder()],
    ['expiresAt', getI64Decoder()],
    ['cargoId', getCargoIdDecoder()],
    ['rarity', getU8Decoder()],
    ['quantityMode', getU8Decoder()],
    ['category', getU8Decoder()],
    ['lootRowIndex', getU8Decoder()],
    ['reserved1', getArrayDecoder(getU8Decoder(), { size: 2 })],
    ['baseQuantity', getU64Decoder()],
    ['nominalQuantity', getU64Decoder()],
    ['acceptedQuantity', getU64Decoder()],
    ['clippedQuantity', getU64Decoder()],
    ['rewardXp', getU64Decoder()],
    ['xpAwarded', getU64Decoder()],
    ['resolvedAt', getI64Decoder()],
    ['terminalAt', getI64Decoder()],
    ['lastRegion', getRegionIdDecoder()],
    ['consecutiveRecoveries', getU16Decoder()],
    ['lastRecoveryAt', getI64Decoder()],
    ['reserved2', getArrayDecoder(getU8Decoder(), { size: 4 })],
  ]);
}

/** Gets the codec for {@link ScanSignal} account data. */
export function getScanSignalCodec(): FixedSizeCodec<
  ScanSignalArgs,
  ScanSignal
> {
  return combineCodec(getScanSignalEncoder(), getScanSignalDecoder());
}

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

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

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

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

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

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

export async function fetchMaybeScanSignalFromSeeds(
  rpc: Parameters<typeof fetchEncodedAccount>[0],
  seeds: ScanSignalSeeds,
  config: FetchAccountConfig & { programAddress?: Address } = {},
): Promise<MaybeAccount<ScanSignal>> {
  const { programAddress, ...fetchConfig } = config;
  const [address] = await findScanSignalPda(seeds, { programAddress });
  return await fetchMaybeScanSignal(rpc, address, fetchConfig);
}