import {
  findMinerAddress,
  findQuarryAddress,
} from "@quarryprotocol/quarry-sdk";
import { useSolana } from "@saberhq/use-solana";
import type { PublicKey } from "@solana/web3.js";
import { useMemo } from "react";
import { useQuery } from "react-query";
import { createContainer } from "unstated-next";

import {
  useAllRewards,
  useBatchedMiners,
  useGetAllClaimableAmounts,
  useRewarder,
} from "../..";

export * from "./useMinerKeys";

export interface UseMinerArgs {
  minerAuthority?: PublicKey;
}

const useMinerInternal = ({ minerAuthority }: UseMinerArgs = {}) => {
  const { rewarderKey, allStakedTokenMints, rewardToken, quarries } =
    useRewarder();
  const { publicKey } = useSolana();
  const owner = minerAuthority ?? publicKey;

  const { data: minerKeys } = useQuery(
    [
      "react-quarry",
      "rewarderMinerKeys",
      rewarderKey.toString(),
      owner?.toString(),
    ],
    async (): Promise<(PublicKey | null)[]> => {
      return await Promise.all(
        allStakedTokenMints?.map(async (stakedTokenMint) => {
          if (!owner) {
            return null;
          }
          const [quarry] = await findQuarryAddress(
            rewarderKey,
            stakedTokenMint
          );
          const [miner] = await findMinerAddress(quarry, owner);
          return miner;
        }) ?? []
      );
    },
    { staleTime: Infinity }
  );
  const { data: minersData, isLoading: minersLoading } =
    useBatchedMiners(minerKeys);

  const quarriesData = useMemo(
    () => quarries?.map((q) => q.quarry),
    [quarries]
  );
  const { getAllClaimableAmounts } = useGetAllClaimableAmounts({
    token: rewardToken ?? null,
    quarriesData,
    minersData,
  });
  const rewards = useAllRewards({ getAllClaimableAmounts });

  return {
    owner,
    rewards,
    minersData,
    minersLoading,
  };
};

/**
 * Information about a Miner for a Rewarder.
 */
export const { useContainer: useMiner, Provider: MinerProvider } =
  createContainer(useMinerInternal);