import {
  findMinerAddress,
  findMinterAddress,
  findQuarryAddress,
  findRegistryAddress,
} from "@quarryprotocol/quarry-sdk";
import { serializeKeys } from "@saberhq/sail";
import type { PublicKey } from "@saberhq/solana-contrib";
import { getATAAddress } from "@saberhq/token-utils";

export const createRewarderQuarryAddressesQuery = (
  rewarder: PublicKey | null | undefined,
  tokens: PublicKey[]
) => ({
  queryKey: [
    "react-quarry",
    "rewarderQuarryAddresses",
    rewarder?.toString(),
    ...serializeKeys(tokens),
  ],
  queryFn: async () => {
    if (!rewarder) {
      return null;
    }
    return await Promise.all(
      tokens.map(async (token) => {
        const [quarry] = await findQuarryAddress(rewarder, token);
        return quarry;
      })
    );
  },
  enabled: rewarder !== undefined,
  staleTime: Infinity,
});

export const createQuarryAddressQuery = (
  rewarder: PublicKey | null | undefined,
  token: PublicKey | null | undefined
) => ({
  queryKey: [
    "react-quarry",
    "quarryAddress",
    rewarder?.toString(),
    token?.toString(),
  ],
  queryFn: async () => {
    if (!rewarder || !token) {
      return null;
    }
    const [quarry] = await findQuarryAddress(rewarder, token);
    return quarry;
  },
  enabled: rewarder !== undefined && token !== undefined,
  staleTime: Infinity,
});

export const createMinerAddressQuery = (
  quarry: PublicKey | null | undefined,
  owner: PublicKey | null | undefined
) => ({
  queryKey: [
    "react-quarry",
    "minerAddress",
    quarry?.toString(),
    owner?.toString(),
  ],
  queryFn: async () => {
    if (!quarry || !owner) {
      return null;
    }
    const [miner] = await findMinerAddress(quarry, owner);
    return miner;
  },
  enabled: quarry !== undefined && owner !== undefined,
  staleTime: Infinity,
});

export const createMinterAddressQuery = (
  mintWrapper: PublicKey | null | undefined,
  rewarder: PublicKey | null | undefined
) => ({
  queryKey: [
    "react-quarry",
    "minterAddress",
    mintWrapper?.toString(),
    rewarder?.toString(),
  ],
  queryFn: async () => {
    if (!mintWrapper || !rewarder) {
      return null;
    }
    const [minter] = await findMinterAddress(mintWrapper, rewarder);
    return minter;
  },
  enabled: mintWrapper !== undefined && rewarder !== undefined,
  staleTime: Infinity,
});

export const createRegistryAddressQuery = (
  rewarder: PublicKey | null | undefined
) => ({
  queryKey: ["react-quarry", "registryAddress", rewarder?.toString()],
  queryFn: async () => {
    if (!rewarder) {
      return null;
    }
    const [registry] = await findRegistryAddress(rewarder);
    return registry;
  },
  enabled: rewarder !== undefined,
  staleTime: Infinity,
});

export const createATAQuery = (
  mint: PublicKey | null | undefined,
  owner: PublicKey | null | undefined
) => ({
  queryKey: ["react-quarry", "ata", mint?.toString(), owner?.toString()],
  queryFn: async () => {
    if (!owner || !mint) {
      return null;
    }
    return await getATAAddress({ mint, owner });
  },
  enabled: owner !== undefined && mint !== undefined,
  staleTime: Infinity,
});