import { PublicKey } from "@solana/web3.js";

import type {
  QuarryMetaWithReplicas,
  RedeemerInfo,
  RewarderConfig,
  RewarderInfo,
  RewarderMeta,
  TokenMeta,
} from "./types";

/**
 * Fetched information about a rewarder.
 */
export interface ParsedRewarderMeta
  extends Pick<RewarderMeta, "rewardsTokenInfo"> {
  /**
   * Rewarder authority.
   */
  authority: PublicKey;
  /**
   * Token being given out as rewards.
   */
  rewardsToken: ParsedTokenMeta;
  /**
   * Mint wrapper.
   */
  mintWrapper: PublicKey;
  /**
   * All quarries associated with the rewarder.
   */
  quarries: readonly ParsedQuarryMeta[];
}

/**
 * Parsed rewarder meta with associated info.
 */
export interface ParsedRewarderMetaWithInfo extends ParsedRewarderMeta {
  info?: ParsedRewarderInfo;
  quarries: readonly ParsedQuarryMetaWithReplicas[];
}

export interface ParsedTokenMeta {
  mint: PublicKey;
  decimals: number;
}

export interface ParsedQuarryMeta {
  quarry: PublicKey;
  stakedToken: ParsedTokenMeta;
  slug: string;
}

export type ParsedRewarderQuarry = {
  rewarder: PublicKey;
  quarry: PublicKey;
  rewardsToken: ParsedTokenMeta;
};

export type ParsedQuarryMetaWithReplicas = Pick<
  QuarryMetaWithReplicas,
  "slug" | "primaryTokenInfo" | "isReplica"
> &
  ParsedQuarryMeta & {
    primaryToken: ParsedTokenMeta;
    mergePool: PublicKey;
    replicaMint: PublicKey;
    primaryQuarries: readonly ParsedRewarderQuarry[];
    replicaQuarries: readonly ParsedRewarderQuarry[];
  };

/**
 * Information about the redeemer.
 */
export interface ParsedRedeemerInfo extends Pick<RedeemerInfo, "method"> {
  /**
   * Mint of the underlying reward token.
   */
  underlyingToken: PublicKey;
  /**
   * The address of the Redeemer PDA.
   */
  redeemerKey?: PublicKey;
  /**
   * The address of the Redeemer ATA.
   */
  redeemerVaultATA?: PublicKey;
}

/**
 * Parsed information about a rewarder.
 */
export type ParsedRewarderInfo = Omit<RewarderInfo, "address"> & {
  /**
   * Address of the rewarder.
   */
  address: PublicKey;
};

export type ParsedRewarderConfig = ParsedRewarderMetaWithInfo & {
  rewarder: PublicKey;
};

const parseRewarderInfo = ({
  address,
  ...rest
}: RewarderInfo): ParsedRewarderInfo => ({
  ...rest,
  address: new PublicKey(address),
});

const parseTokenMeta = ({ mint, ...rest }: TokenMeta): ParsedTokenMeta => ({
  ...rest,
  mint: new PublicKey(mint),
});

const parseRewarderQuarry = ({
  rewarder,
  quarry,
  rewardsToken,
}: {
  rewarder: string;
  quarry: string;
  rewardsToken: TokenMeta;
}): ParsedRewarderQuarry => {
  return {
    rewarder: new PublicKey(rewarder),
    quarry: new PublicKey(quarry),
    rewardsToken: parseTokenMeta(rewardsToken),
  };
};

const parseQuarry = ({
  quarry,
  stakedToken,

  primaryToken,
  mergePool,
  replicaMint,
  primaryQuarries,
  replicaQuarries,

  ...rest
}: QuarryMetaWithReplicas): ParsedQuarryMetaWithReplicas => {
  return {
    ...rest,

    quarry: new PublicKey(quarry),
    stakedToken: parseTokenMeta(stakedToken),

    primaryToken: parseTokenMeta(primaryToken),
    mergePool: new PublicKey(mergePool),
    replicaMint: new PublicKey(replicaMint),
    primaryQuarries: primaryQuarries.map(parseRewarderQuarry),
    replicaQuarries: replicaQuarries.map(parseRewarderQuarry),
  };
};

export const parseRewarderConfig = ({
  info,
  rewarder,
  quarries,
  authority,
  rewardsToken,
  mintWrapper,
  ...rest
}: RewarderConfig): ParsedRewarderConfig => {
  return {
    ...rest,
    info: info ? parseRewarderInfo(info) : undefined,
    rewarder: new PublicKey(rewarder),
    authority: new PublicKey(authority),
    rewardsToken: parseTokenMeta(rewardsToken),
    mintWrapper: new PublicKey(mintWrapper),
    quarries: quarries.map(parseQuarry),
  };
};

export type ParsedRewardersList = Record<string, ParsedRewarderConfig>;