import { Program, BN } from "@project-serum/anchor";
import { Keypair, PublicKey } from "@solana/web3.js";
import { PsyStake } from "../target/types/psy_stake";

export const deriveStakePool = async (
  program: Program<PsyStake>,
  stakingTokenMint: PublicKey,
  uniqueSeed: BN
) => {
  return await PublicKey.findProgramAddress(
    [
      stakingTokenMint.toBuffer(),
      uniqueSeed.toBuffer("le", 2),
      Buffer.from("StakePool"),
    ],
    program.programId
  );
};

export const deriveStakingTokenAccount = async (
  program: Program<PsyStake>,
  stakePool: PublicKey
) => {
  return await PublicKey.findProgramAddress(
    [stakePool.toBuffer(), Buffer.from("StakingTokenPool")],
    program.programId
  );
};

export const deriveRewardPool = async (
  program: Program<PsyStake>,
  stakePool: PublicKey,
  poolId: number
) => {
  return await PublicKey.findProgramAddress(
    [
      new BN(poolId).toBuffer("le", 1),
      stakePool.toBuffer(),
      Buffer.from("RewardPool"),
    ],
    program.programId
  );
};

export const deriveRewardRecord = async (
  program: Program<PsyStake>,
  rewardPool: PublicKey,
  startingEpoch: number
) => {
  return await PublicKey.findProgramAddress(
    [
      rewardPool.toBuffer(),
      new BN(startingEpoch).toBuffer("le", 2),
      Buffer.from("RewardRecord"),
    ],
    program.programId
  );
};

export const deriveRewardTokenAccount = async (
  program: Program<PsyStake>,
  rewardPool: PublicKey
) => {
  return await PublicKey.findProgramAddress(
    [rewardPool.toBuffer(), Buffer.from("RewardTokenAccount")],
    program.programId
  );
};

export const deriveAllocatedTokenAccount = async (
  program: Program<PsyStake>,
  rewardPool: PublicKey
) => {
  return await PublicKey.findProgramAddress(
    [rewardPool.toBuffer(), Buffer.from("AllocatedTokenAccount")],
    program.programId
  );
};

export const deriveStakingRecord = async (
  program: Program<PsyStake>,
  recordOwner: PublicKey,
  stakePool: PublicKey
) => {
  return await PublicKey.findProgramAddress(
    [
      recordOwner.toBuffer(),
      stakePool.toBuffer(),
      Buffer.from("StakingRecord"),
    ],
    program.programId
  );
};

export const deriveRewardPoolPdas = async (
  program: Program<PsyStake>,
  stakePool: PublicKey,
  poolId: number,
  startingEpoch: number
) => {
  const [rewardPool, rewardPoolBump] = await deriveRewardPool(
    program,
    stakePool,
    poolId
  );
  const [rewardRecord, rewardRecordBump] = await deriveRewardRecord(
    program,
    rewardPool,
    startingEpoch
  );
  const [rewardTokenAccount, rewardTokenAccountBump] =
    await deriveRewardTokenAccount(program, rewardPool);
  const [allocatedTokenAccount, allocatedTokenAccountBump] =
    await deriveAllocatedTokenAccount(program, rewardPool);

  return {
    rewardPool,
    rewardPoolBump,
    rewardRecord,
    rewardRecordBump,
    rewardTokenAccount,
    rewardTokenAccountBump,
    allocatedTokenAccount,
    allocatedTokenAccountBump,
  };
};