import { useEtherStore } from "@/store/ether";
import { Contract, ethers } from "ethers";

import p2pix from "@/utils/smart_contract_files/P2PIX.json";
import { formatEther } from "ethers/lib/utils";
import { getContract } from "./provider";
import type { ValidDeposit } from "@/model/ValidDeposit";
import { getP2PixAddress, getTokenAddress } from "./addresses";
import { NetworkEnum } from "@/model/NetworkEnum";

const getNetworksLiquidity = async (): Promise<void> => {
  const etherStore = useEtherStore();

  const goerliProvider = new ethers.providers.JsonRpcProvider(
    import.meta.env.VITE_GOERLI_API_URL,
    5
  ); // goerli provider
  const mumbaiProvider = new ethers.providers.JsonRpcProvider(
    import.meta.env.VITE_MUMBAI_API_URL,
    80001
  ); // mumbai provider

  const p2pContractGoerli = new ethers.Contract(
    getP2PixAddress(NetworkEnum.ethereum),
    p2pix.abi,
    goerliProvider
  );
  const p2pContractMumbai = new ethers.Contract(
    getP2PixAddress(NetworkEnum.polygon),
    p2pix.abi,
    mumbaiProvider
  );

  etherStore.setLoadingNetworkLiquidity(true);
  const depositListGoerli = await getValidDeposits(
    getTokenAddress(NetworkEnum.ethereum),
    p2pContractGoerli
  );

  const depositListMumbai = await getValidDeposits(
    getTokenAddress(NetworkEnum.polygon),
    p2pContractMumbai
  );

  etherStore.setDepositsValidListGoerli(depositListGoerli);
  etherStore.setDepositsValidListMumbai(depositListMumbai);
  etherStore.setLoadingNetworkLiquidity(false);
};

const getValidDeposits = async (
  token: string,
  contract?: Contract
): Promise<ValidDeposit[]> => {
  let p2pContract: Contract;

  if (contract) {
    p2pContract = contract;
  } else {
    p2pContract = getContract(true);
  }

  const filterDeposits = p2pContract.filters.DepositAdded(null);
  const eventsDeposits = await p2pContract.queryFilter(filterDeposits);

  if (!contract) p2pContract = getContract(); // get metamask provider contract
  const depositList: { [key: string]: ValidDeposit } = {};

  await Promise.all(
    eventsDeposits.map(async (deposit) => {
      // Get liquidity only for the selected token
      if (deposit.args?.token != token) return null;

      const mappedBalance = await p2pContract.getBalance(
        deposit.args?.seller,
        token
      );

      const mappedPixTarget = await p2pContract.getPixTarget(
        deposit.args?.seller,
        token
      );

      let validDeposit: ValidDeposit | null = null;

      if (mappedBalance._hex) {
        validDeposit = {
          token: token,
          blockNumber: deposit.blockNumber,
          remaining: Number(formatEther(mappedBalance._hex)),
          seller: deposit.args?.seller,
          pixKey: Number(mappedPixTarget._hex),
        };
      }

      if (validDeposit)
        depositList[deposit.args?.seller + token] = validDeposit;
    })
  );

  return Object.values(depositList);
};

export { getValidDeposits, getNetworksLiquidity };