/**
 * 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 {
  combineCodec,
  fixDecoderSize,
  fixEncoderSize,
  getArrayDecoder,
  getArrayEncoder,
  getBytesDecoder,
  getBytesEncoder,
  getI64Decoder,
  getI64Encoder,
  getOptionDecoder,
  getOptionEncoder,
  getStructDecoder,
  getStructEncoder,
  getU16Decoder,
  getU16Encoder,
  getU32Decoder,
  getU32Encoder,
  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
  SolanaError,
  transformEncoder,
  type AccountMeta,
  type AccountSignerMeta,
  type Address,
  type Codec,
  type Decoder,
  type Encoder,
  type Instruction,
  type InstructionWithAccounts,
  type InstructionWithData,
  type Option,
  type OptionOrNullable,
  type ReadonlyAccount,
  type ReadonlySignerAccount,
  type ReadonlyUint8Array,
  type TransactionSigner,
  type WritableAccount,
} from '@solana/kit';
import {
  getAccountMetaFactory,
  type ResolvedInstructionAccount,
} from '@solana/program-client-core';
import { SAGE_PROGRAM_ADDRESS } from '../programs';
import {
  getNameDecoder,
  getNameEncoder,
  getRegionIdDecoder,
  getRegionIdEncoder,
  getResearchTagDecoder,
  getResearchTagEncoder,
  getRiskZoneBorshDecoder,
  getRiskZoneBorshEncoder,
  type Name,
  type NameArgs,
  type RegionId,
  type RegionIdArgs,
  type ResearchTag,
  type ResearchTagArgs,
  type RiskZoneBorsh,
  type RiskZoneBorshArgs,
} from '../types';

export const CREATE_REGION_DISCRIMINATOR = new Uint8Array([
  108, 252, 183, 41, 46, 77, 84, 66,
]);

export function getCreateRegionDiscriminatorBytes() {
  return fixEncoderSize(getBytesEncoder(), 8).encode(
    CREATE_REGION_DISCRIMINATOR,
  );
}

export type CreateRegionInstruction<
  TProgram extends string = typeof SAGE_PROGRAM_ADDRESS,
  TAccountProfileSigner extends string | AccountMeta<string> = string,
  TAccountProfileProfile extends string | AccountMeta<string> = string,
  TAccountProfileCertificate extends string | AccountMeta<string> = string,
  TAccountProfileProgram extends string | AccountMeta<string> =
    'C4PRoFNroxxzdgeCoM31LJjYRg7kT6ymogSTAT99iD1u',
  TAccountGame extends string | AccountMeta<string> = string,
  TAccountRegionTracker extends string | AccountMeta<string> = string,
  TAccountKingTracker extends string | AccountMeta<string> = string,
  TAccountSystemProgram extends string | AccountMeta<string> =
    '11111111111111111111111111111111',
  TRemainingAccounts extends readonly AccountMeta<string>[] = [],
> = Instruction<TProgram> &
  InstructionWithData<ReadonlyUint8Array> &
  InstructionWithAccounts<
    [
      TAccountProfileSigner extends string
        ? ReadonlySignerAccount<TAccountProfileSigner> &
            AccountSignerMeta<TAccountProfileSigner>
        : TAccountProfileSigner,
      TAccountProfileProfile extends string
        ? WritableAccount<TAccountProfileProfile>
        : TAccountProfileProfile,
      TAccountProfileCertificate extends string
        ? ReadonlyAccount<TAccountProfileCertificate>
        : TAccountProfileCertificate,
      TAccountProfileProgram extends string
        ? ReadonlyAccount<TAccountProfileProgram>
        : TAccountProfileProgram,
      TAccountGame extends string
        ? ReadonlyAccount<TAccountGame>
        : TAccountGame,
      TAccountRegionTracker extends string
        ? WritableAccount<TAccountRegionTracker>
        : TAccountRegionTracker,
      TAccountKingTracker extends string
        ? ReadonlyAccount<TAccountKingTracker>
        : TAccountKingTracker,
      TAccountSystemProgram extends string
        ? ReadonlyAccount<TAccountSystemProgram>
        : TAccountSystemProgram,
      ...TRemainingAccounts,
    ]
  >;

export type CreateRegionInstructionData = {
  discriminator: ReadonlyUint8Array;
  /** Unique identifier for the region */
  id: RegionId;
  /** The name of the region */
  name: Name;
  /** The risk zone for this region. */
  riskZone: RiskZoneBorsh;
  /** IDs of regions connected by at least one cross-region system warp lane */
  connections: Option<Array<RegionId>>;
  /** Coordinate points defining the region's border */
  border: Array<Array<bigint>>;
  /** Technology IDs required for scanning in this region */
  scanningResearchRequirements: Option<Array<ResearchTag>>;
  /** Technology IDs required for mining in this region */
  miningResearchRequirements: Option<Array<ResearchTag>>;
  /** XP modifier for this region */
  xpModifier: number;
  /** Index of the key in the profile with region management permissions */
  keyIndex: number;
};

export type CreateRegionInstructionDataArgs = {
  /** Unique identifier for the region */
  id: RegionIdArgs;
  /** The name of the region */
  name: NameArgs;
  /** The risk zone for this region. */
  riskZone: RiskZoneBorshArgs;
  /** IDs of regions connected by at least one cross-region system warp lane */
  connections: OptionOrNullable<Array<RegionIdArgs>>;
  /** Coordinate points defining the region's border */
  border: Array<Array<number | bigint>>;
  /** Technology IDs required for scanning in this region */
  scanningResearchRequirements: OptionOrNullable<Array<ResearchTagArgs>>;
  /** Technology IDs required for mining in this region */
  miningResearchRequirements: OptionOrNullable<Array<ResearchTagArgs>>;
  /** XP modifier for this region */
  xpModifier: number;
  /** Index of the key in the profile with region management permissions */
  keyIndex: number;
};

export function getCreateRegionInstructionDataEncoder(): Encoder<CreateRegionInstructionDataArgs> {
  return transformEncoder(
    getStructEncoder([
      ['discriminator', fixEncoderSize(getBytesEncoder(), 8)],
      ['id', getRegionIdEncoder()],
      ['name', getNameEncoder()],
      ['riskZone', getRiskZoneBorshEncoder()],
      ['connections', getOptionEncoder(getArrayEncoder(getRegionIdEncoder()))],
      [
        'border',
        getArrayEncoder(getArrayEncoder(getI64Encoder(), { size: 2 })),
      ],
      [
        'scanningResearchRequirements',
        getOptionEncoder(getArrayEncoder(getResearchTagEncoder())),
      ],
      [
        'miningResearchRequirements',
        getOptionEncoder(getArrayEncoder(getResearchTagEncoder())),
      ],
      ['xpModifier', getU32Encoder()],
      ['keyIndex', getU16Encoder()],
    ]),
    (value) => ({ ...value, discriminator: CREATE_REGION_DISCRIMINATOR }),
  );
}

export function getCreateRegionInstructionDataDecoder(): Decoder<CreateRegionInstructionData> {
  return getStructDecoder([
    ['discriminator', fixDecoderSize(getBytesDecoder(), 8)],
    ['id', getRegionIdDecoder()],
    ['name', getNameDecoder()],
    ['riskZone', getRiskZoneBorshDecoder()],
    ['connections', getOptionDecoder(getArrayDecoder(getRegionIdDecoder()))],
    ['border', getArrayDecoder(getArrayDecoder(getI64Decoder(), { size: 2 }))],
    [
      'scanningResearchRequirements',
      getOptionDecoder(getArrayDecoder(getResearchTagDecoder())),
    ],
    [
      'miningResearchRequirements',
      getOptionDecoder(getArrayDecoder(getResearchTagDecoder())),
    ],
    ['xpModifier', getU32Decoder()],
    ['keyIndex', getU16Decoder()],
  ]);
}

export function getCreateRegionInstructionDataCodec(): Codec<
  CreateRegionInstructionDataArgs,
  CreateRegionInstructionData
> {
  return combineCodec(
    getCreateRegionInstructionDataEncoder(),
    getCreateRegionInstructionDataDecoder(),
  );
}

export type CreateRegionInput<
  TAccountProfileSigner extends string = string,
  TAccountProfileProfile extends string = string,
  TAccountProfileCertificate extends string = string,
  TAccountProfileProgram extends string = string,
  TAccountGame extends string = string,
  TAccountRegionTracker extends string = string,
  TAccountKingTracker extends string = string,
  TAccountSystemProgram extends string = string,
> = {
  profileSigner: TransactionSigner<TAccountProfileSigner>;
  profileProfile: Address<TAccountProfileProfile>;
  profileCertificate?: Address<TAccountProfileCertificate>;
  profileProgram?: Address<TAccountProfileProgram>;
  game: Address<TAccountGame>;
  /** Region tracker account storing all regions */
  regionTracker: Address<TAccountRegionTracker>;
  kingTracker: Address<TAccountKingTracker>;
  /** Solana System program for account creation */
  systemProgram?: Address<TAccountSystemProgram>;
  id: CreateRegionInstructionDataArgs['id'];
  name: CreateRegionInstructionDataArgs['name'];
  riskZone: CreateRegionInstructionDataArgs['riskZone'];
  connections: CreateRegionInstructionDataArgs['connections'];
  border: CreateRegionInstructionDataArgs['border'];
  scanningResearchRequirements: CreateRegionInstructionDataArgs['scanningResearchRequirements'];
  miningResearchRequirements: CreateRegionInstructionDataArgs['miningResearchRequirements'];
  xpModifier: CreateRegionInstructionDataArgs['xpModifier'];
  keyIndex: CreateRegionInstructionDataArgs['keyIndex'];
};

export function getCreateRegionInstruction<
  TAccountProfileSigner extends string,
  TAccountProfileProfile extends string,
  TAccountProfileCertificate extends string,
  TAccountProfileProgram extends string,
  TAccountGame extends string,
  TAccountRegionTracker extends string,
  TAccountKingTracker extends string,
  TAccountSystemProgram extends string,
  TProgramAddress extends Address = typeof SAGE_PROGRAM_ADDRESS,
>(
  input: CreateRegionInput<
    TAccountProfileSigner,
    TAccountProfileProfile,
    TAccountProfileCertificate,
    TAccountProfileProgram,
    TAccountGame,
    TAccountRegionTracker,
    TAccountKingTracker,
    TAccountSystemProgram
  >,
  config?: { programAddress?: TProgramAddress },
): CreateRegionInstruction<
  TProgramAddress,
  TAccountProfileSigner,
  TAccountProfileProfile,
  TAccountProfileCertificate,
  TAccountProfileProgram,
  TAccountGame,
  TAccountRegionTracker,
  TAccountKingTracker,
  TAccountSystemProgram
> {
  // Program address.
  const programAddress = config?.programAddress ?? SAGE_PROGRAM_ADDRESS;

  // Original accounts.
  const originalAccounts = {
    profileSigner: { value: input.profileSigner ?? null, isWritable: false },
    profileProfile: { value: input.profileProfile ?? null, isWritable: true },
    profileCertificate: {
      value: input.profileCertificate ?? null,
      isWritable: false,
    },
    profileProgram: { value: input.profileProgram ?? null, isWritable: false },
    game: { value: input.game ?? null, isWritable: false },
    regionTracker: { value: input.regionTracker ?? null, isWritable: true },
    kingTracker: { value: input.kingTracker ?? null, isWritable: false },
    systemProgram: { value: input.systemProgram ?? null, isWritable: false },
  };
  const accounts = originalAccounts as Record<
    keyof typeof originalAccounts,
    ResolvedInstructionAccount
  >;

  // Original args.
  const args = { ...input };

  // Resolve default values.
  if (!accounts.profileProgram.value) {
    accounts.profileProgram.value =
      'C4PRoFNroxxzdgeCoM31LJjYRg7kT6ymogSTAT99iD1u' as Address<'C4PRoFNroxxzdgeCoM31LJjYRg7kT6ymogSTAT99iD1u'>;
  }
  if (!accounts.systemProgram.value) {
    accounts.systemProgram.value =
      '11111111111111111111111111111111' as Address<'11111111111111111111111111111111'>;
  }

  const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
  return Object.freeze({
    accounts: [
      getAccountMeta('profileSigner', accounts.profileSigner),
      getAccountMeta('profileProfile', accounts.profileProfile),
      getAccountMeta('profileCertificate', accounts.profileCertificate),
      getAccountMeta('profileProgram', accounts.profileProgram),
      getAccountMeta('game', accounts.game),
      getAccountMeta('regionTracker', accounts.regionTracker),
      getAccountMeta('kingTracker', accounts.kingTracker),
      getAccountMeta('systemProgram', accounts.systemProgram),
    ],
    data: getCreateRegionInstructionDataEncoder().encode(
      args as CreateRegionInstructionDataArgs,
    ),
    programAddress,
  } as CreateRegionInstruction<
    TProgramAddress,
    TAccountProfileSigner,
    TAccountProfileProfile,
    TAccountProfileCertificate,
    TAccountProfileProgram,
    TAccountGame,
    TAccountRegionTracker,
    TAccountKingTracker,
    TAccountSystemProgram
  >);
}

export type ParsedCreateRegionInstruction<
  TProgram extends string = typeof SAGE_PROGRAM_ADDRESS,
  TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[],
> = {
  programAddress: Address<TProgram>;
  accounts: {
    profileSigner: TAccountMetas[0];
    profileProfile: TAccountMetas[1];
    profileCertificate?: TAccountMetas[2] | undefined;
    profileProgram: TAccountMetas[3];
    game: TAccountMetas[4];
    /** Region tracker account storing all regions */
    regionTracker: TAccountMetas[5];
    kingTracker: TAccountMetas[6];
    /** Solana System program for account creation */
    systemProgram: TAccountMetas[7];
  };
  data: CreateRegionInstructionData;
};

export function parseCreateRegionInstruction<
  TProgram extends string,
  TAccountMetas extends readonly AccountMeta[],
>(
  instruction: Instruction<TProgram> &
    InstructionWithAccounts<TAccountMetas> &
    InstructionWithData<ReadonlyUint8Array>,
): ParsedCreateRegionInstruction<TProgram, TAccountMetas> {
  if (instruction.accounts.length < 8) {
    throw new SolanaError(
      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
      {
        actualAccountMetas: instruction.accounts.length,
        expectedAccountMetas: 8,
      },
    );
  }
  let accountIndex = 0;
  const getNextAccount = () => {
    const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;
    accountIndex += 1;
    return accountMeta;
  };
  const getNextOptionalAccount = () => {
    const accountMeta = getNextAccount();
    return accountMeta.address === SAGE_PROGRAM_ADDRESS
      ? undefined
      : accountMeta;
  };
  return {
    programAddress: instruction.programAddress,
    accounts: {
      profileSigner: getNextAccount(),
      profileProfile: getNextAccount(),
      profileCertificate: getNextOptionalAccount(),
      profileProgram: getNextAccount(),
      game: getNextAccount(),
      regionTracker: getNextAccount(),
      kingTracker: getNextAccount(),
      systemProgram: getNextAccount(),
    },
    data: getCreateRegionInstructionDataDecoder().decode(instruction.data),
  };
}