import { BN } from '@coral-xyz/anchor';
import { Mint } from '@solana/spl-token';
import { PublicKey } from '@solana/web3.js';
import { VsrClient } from './voteStakeRegistryClient';

export type TokenProgramAccount<T> = {
  publicKey: PublicKey;
  account: T;
};

export interface Voter {
  deposits: Deposit[];
  voterAuthority: PublicKey;
  registrar: PublicKey;
  //there are more fields but no use for them on ui yet
}

export interface votingMint {
  baselineVoteWeightScaledFactor: BN;
  digitShift: number;
  grantAuthority: PublicKey;
  lockupSaturationSecs: BN;
  maxExtraLockupVoteWeightScaledFactor: BN;
  mint: PublicKey;
}

export type LockupType = 'none' | 'monthly' | 'cliff' | 'constant' | 'daily';
export interface Registrar {
  governanceProgramId: PublicKey;
  realm: PublicKey;
  realmAuthority: PublicKey;
  realmGoverningTokenMint: PublicKey;
  votingMints: votingMint[];
  //there are more fields but no use for them on ui yet
}
interface LockupKind {
  none: object;
  daily: object;
  monthly: object;
  cliff: object;
  constant: object;
}
interface Lockup {
  endTs: BN;
  kind: LockupKind;
  startTs: BN;
}
export interface Deposit {
  allowClawback: boolean;
  amountDepositedNative: BN;
  amountInitiallyLockedNative: BN;
  isUsed: boolean;
  lockup: Lockup;
  votingMintConfigIdx: number;
}

export interface DepositWithMintAccount extends Deposit {
  mint: TokenProgramAccount<Mint>;
  index: number;
  available: BN;
  vestingRate: BN | null;
  currentlyLocked: BN;
  nextVestingTimestamp: BN | null;
  votingPower: BN;
  votingPowerBaseline: BN;
}

export const emptyPk = '11111111111111111111111111111111';

export const getRegistrarPDA = async (
  realmPk: PublicKey,
  mint: PublicKey,
  clientProgramId: PublicKey,
) => {
  const [registrar, registrarBump] = await PublicKey.findProgramAddress(
    [realmPk.toBuffer(), Buffer.from('registrar'), mint.toBuffer()],
    clientProgramId,
  );
  return {
    registrar,
    registrarBump,
  };
};

export const getVoterPDA = async (
  registrar: PublicKey,
  walletPk: PublicKey,
  clientProgramId: PublicKey,
) => {
  const [voter, voterBump] = await PublicKey.findProgramAddress(
    [registrar.toBuffer(), Buffer.from('voter'), walletPk.toBuffer()],
    clientProgramId,
  );

  return {
    voter,
    voterBump,
  };
};

export const getVoterWeightPDA = async (
  registrar: PublicKey,
  walletPk: PublicKey,
  clientProgramId: PublicKey,
) => {
  const [voterWeightPk, voterWeightBump] = await PublicKey.findProgramAddress(
    [
      registrar.toBuffer(),
      Buffer.from('voter-weight-record'),
      walletPk.toBuffer(),
    ],
    clientProgramId,
  );

  return {
    voterWeightPk,
    voterWeightBump,
  };
};

export const tryGetVoter = async (voterPk: PublicKey, client: VsrClient) => {
  try {
    const voter = await client?.program.account.voter.fetch(voterPk);
    return voter as unknown as Voter;
  } catch (e) {
    return null;
  }
};
export const tryGetRegistrar = async (
  registrarPk: PublicKey,
  client: VsrClient,
) => {
  try {
    const existingRegistrar = await client.program.account.registrar.fetch(
      registrarPk,
    );
    return existingRegistrar as unknown as Registrar;
  } catch (e) {
    return null;
  }
};