/**
 * 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 { AtlasRewardConfigSeeds, findAtlasRewardConfigPda } from '../pdas';
import {
  getMedallionRewardConfigDecoder,
  getMedallionRewardConfigEncoder,
  getSalvageRewardEntryDecoder,
  getSalvageRewardEntryEncoder,
  getUpgradeLpRateDecoder,
  getUpgradeLpRateEncoder,
  type MedallionRewardConfig,
  type MedallionRewardConfigArgs,
  type SalvageRewardEntry,
  type SalvageRewardEntryArgs,
  type UpgradeLpRate,
  type UpgradeLpRateArgs,
} from '../types';

export const ATLAS_REWARD_CONFIG_DISCRIMINATOR = new Uint8Array([
  133, 168, 11, 79, 83, 109, 253, 162,
]);

export function getAtlasRewardConfigDiscriminatorBytes() {
  return fixEncoderSize(getBytesEncoder(), 8).encode(
    ATLAS_REWARD_CONFIG_DISCRIMINATOR,
  );
}

/** One immutable, fully authored reward configuration version. */
export type AtlasRewardConfig = {
  discriminator: ReadonlyUint8Array;
  version: number;
  bump: number;
  enabled: number;
  pad0: number;
  gameId: Address;
  configVersion: number;
  effectiveEpoch: bigint;
  createdAt: bigint;
  sourceFlags: number;
  pad1: Array<number>;
  epochLenSecs: number;
  claimSettlementWindowSecs: number;
  atlasBankInactivityExpirySecs: bigint;
  rewardLootReclaimSecs: bigint;
  factionPoolLever: bigint;
  kingSystemCurve: Array<Array<bigint>>;
  pveLpRateBps: number;
  pvpMedallionRateBps: number;
  salvageEvRateBps: number;
  repairKitLpRate: bigint;
  lossModelTargetBps: Array<number>;
  starbaseDestructionMedallions: Array<bigint>;
  activeMedallion: MedallionRewardConfig;
  medallionBuybackCapPerEpoch: bigint;
  rewardReserveLowBalanceThreshold: bigint;
  upgradeLpRateCount: number;
  salvageEntryCount: number;
  pad2: Array<number>;
  upgradeLpRates: Array<UpgradeLpRate>;
  salvageEntries: Array<SalvageRewardEntry>;
  reserved: Array<number>;
};

export type AtlasRewardConfigArgs = {
  version: number;
  bump: number;
  enabled: number;
  pad0: number;
  gameId: Address;
  configVersion: number;
  effectiveEpoch: number | bigint;
  createdAt: number | bigint;
  sourceFlags: number;
  pad1: Array<number>;
  epochLenSecs: number;
  claimSettlementWindowSecs: number;
  atlasBankInactivityExpirySecs: number | bigint;
  rewardLootReclaimSecs: number | bigint;
  factionPoolLever: number | bigint;
  kingSystemCurve: Array<Array<number | bigint>>;
  pveLpRateBps: number;
  pvpMedallionRateBps: number;
  salvageEvRateBps: number;
  repairKitLpRate: number | bigint;
  lossModelTargetBps: Array<number>;
  starbaseDestructionMedallions: Array<number | bigint>;
  activeMedallion: MedallionRewardConfigArgs;
  medallionBuybackCapPerEpoch: number | bigint;
  rewardReserveLowBalanceThreshold: number | bigint;
  upgradeLpRateCount: number;
  salvageEntryCount: number;
  pad2: Array<number>;
  upgradeLpRates: Array<UpgradeLpRateArgs>;
  salvageEntries: Array<SalvageRewardEntryArgs>;
  reserved: Array<number>;
};

/** Gets the encoder for {@link AtlasRewardConfigArgs} account data. */
export function getAtlasRewardConfigEncoder(): FixedSizeEncoder<AtlasRewardConfigArgs> {
  return transformEncoder(
    getStructEncoder([
      ['discriminator', fixEncoderSize(getBytesEncoder(), 8)],
      ['version', getU8Encoder()],
      ['bump', getU8Encoder()],
      ['enabled', getU8Encoder()],
      ['pad0', getU8Encoder()],
      ['gameId', getAddressEncoder()],
      ['configVersion', getU32Encoder()],
      ['effectiveEpoch', getU64Encoder()],
      ['createdAt', getI64Encoder()],
      ['sourceFlags', getU16Encoder()],
      ['pad1', getArrayEncoder(getU8Encoder(), { size: 2 })],
      ['epochLenSecs', getU32Encoder()],
      ['claimSettlementWindowSecs', getU32Encoder()],
      ['atlasBankInactivityExpirySecs', getU64Encoder()],
      ['rewardLootReclaimSecs', getU64Encoder()],
      ['factionPoolLever', getU64Encoder()],
      [
        'kingSystemCurve',
        getArrayEncoder(getArrayEncoder(getU64Encoder(), { size: 10 }), {
          size: 7,
        }),
      ],
      ['pveLpRateBps', getU32Encoder()],
      ['pvpMedallionRateBps', getU32Encoder()],
      ['salvageEvRateBps', getU32Encoder()],
      ['repairKitLpRate', getU64Encoder()],
      ['lossModelTargetBps', getArrayEncoder(getU16Encoder(), { size: 3 })],
      [
        'starbaseDestructionMedallions',
        getArrayEncoder(getU64Encoder(), { size: 7 }),
      ],
      ['activeMedallion', getMedallionRewardConfigEncoder()],
      ['medallionBuybackCapPerEpoch', getU64Encoder()],
      ['rewardReserveLowBalanceThreshold', getU64Encoder()],
      ['upgradeLpRateCount', getU8Encoder()],
      ['salvageEntryCount', getU8Encoder()],
      ['pad2', getArrayEncoder(getU8Encoder(), { size: 6 })],
      [
        'upgradeLpRates',
        getArrayEncoder(getUpgradeLpRateEncoder(), { size: 32 }),
      ],
      [
        'salvageEntries',
        getArrayEncoder(getSalvageRewardEntryEncoder(), { size: 32 }),
      ],
      ['reserved', getArrayEncoder(getU8Encoder(), { size: 64 })],
    ]),
    (value) => ({ ...value, discriminator: ATLAS_REWARD_CONFIG_DISCRIMINATOR }),
  );
}

/** Gets the decoder for {@link AtlasRewardConfig} account data. */
export function getAtlasRewardConfigDecoder(): FixedSizeDecoder<AtlasRewardConfig> {
  return getStructDecoder([
    ['discriminator', fixDecoderSize(getBytesDecoder(), 8)],
    ['version', getU8Decoder()],
    ['bump', getU8Decoder()],
    ['enabled', getU8Decoder()],
    ['pad0', getU8Decoder()],
    ['gameId', getAddressDecoder()],
    ['configVersion', getU32Decoder()],
    ['effectiveEpoch', getU64Decoder()],
    ['createdAt', getI64Decoder()],
    ['sourceFlags', getU16Decoder()],
    ['pad1', getArrayDecoder(getU8Decoder(), { size: 2 })],
    ['epochLenSecs', getU32Decoder()],
    ['claimSettlementWindowSecs', getU32Decoder()],
    ['atlasBankInactivityExpirySecs', getU64Decoder()],
    ['rewardLootReclaimSecs', getU64Decoder()],
    ['factionPoolLever', getU64Decoder()],
    [
      'kingSystemCurve',
      getArrayDecoder(getArrayDecoder(getU64Decoder(), { size: 10 }), {
        size: 7,
      }),
    ],
    ['pveLpRateBps', getU32Decoder()],
    ['pvpMedallionRateBps', getU32Decoder()],
    ['salvageEvRateBps', getU32Decoder()],
    ['repairKitLpRate', getU64Decoder()],
    ['lossModelTargetBps', getArrayDecoder(getU16Decoder(), { size: 3 })],
    [
      'starbaseDestructionMedallions',
      getArrayDecoder(getU64Decoder(), { size: 7 }),
    ],
    ['activeMedallion', getMedallionRewardConfigDecoder()],
    ['medallionBuybackCapPerEpoch', getU64Decoder()],
    ['rewardReserveLowBalanceThreshold', getU64Decoder()],
    ['upgradeLpRateCount', getU8Decoder()],
    ['salvageEntryCount', getU8Decoder()],
    ['pad2', getArrayDecoder(getU8Decoder(), { size: 6 })],
    [
      'upgradeLpRates',
      getArrayDecoder(getUpgradeLpRateDecoder(), { size: 32 }),
    ],
    [
      'salvageEntries',
      getArrayDecoder(getSalvageRewardEntryDecoder(), { size: 32 }),
    ],
    ['reserved', getArrayDecoder(getU8Decoder(), { size: 64 })],
  ]);
}

/** Gets the codec for {@link AtlasRewardConfig} account data. */
export function getAtlasRewardConfigCodec(): FixedSizeCodec<
  AtlasRewardConfigArgs,
  AtlasRewardConfig
> {
  return combineCodec(
    getAtlasRewardConfigEncoder(),
    getAtlasRewardConfigDecoder(),
  );
}

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

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

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

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

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

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

export async function fetchMaybeAtlasRewardConfigFromSeeds(
  rpc: Parameters<typeof fetchEncodedAccount>[0],
  seeds: AtlasRewardConfigSeeds,
  config: FetchAccountConfig & { programAddress?: Address } = {},
): Promise<MaybeAccount<AtlasRewardConfig>> {
  const { programAddress, ...fetchConfig } = config;
  const [address] = await findAtlasRewardConfigPda(seeds, { programAddress });
  return await fetchMaybeAtlasRewardConfig(rpc, address, fetchConfig);
}