import { useContext, useRef, useState } from 'react';
import { TokenBalance, TransactionRequirement } from '@imtbl/checkout-sdk';
import { CryptoFiatContext } from '../../../context/crypto-fiat-context/CryptoFiatContext';
import { fetchFundingBalances } from '../functions/fetchFundingBalances';
import { FundingBalance, FundingBalanceResult } from '../types';
import { useSaleContext } from '../context/SaleContextProvider';
import { getPricingBySymbol } from '../utils/pricing';

export const useFundingBalances = () => {
  const fetching = useRef(false);
  const {
    fromTokenAddress,
    orderQuote,
    provider,
    checkout,
    selectedCurrency,
  } = useSaleContext();
  const { cryptoFiatState } = useContext(CryptoFiatContext);
  const [transactionRequirement, setTransactionRequirement] = useState<
  TransactionRequirement | undefined
  >();
  const [fundingBalances, setFundingBalances] = useState<FundingBalance[]>([]);
  const [fundingBalancesResult, setFundingBalancesResult] = useState<
  FundingBalanceResult[]
  >([]);
  const [loadingBalances, setLoadingBalances] = useState(false);
  const [gasFees, setGasFees] = useState<TokenBalance | undefined>();
  const [fundingBalancesError, setFundingBalancesError] = useState<Error | null>(null);

  const queryFundingBalances = () => {
    if (
      !fromTokenAddress
      || !provider
      || !checkout
      || !orderQuote
      || !selectedCurrency
    ) return;

    if (fetching.current || loadingBalances) return;

    (async () => {
      fetching.current = true;
      setLoadingBalances(true);
      setFundingBalancesError(null);
      try {
        const results = await fetchFundingBalances({
          provider,
          checkout,
          currencies: orderQuote.currencies,
          routingOptions: { bridge: false, onRamp: false, swap: true },
          baseCurrency: selectedCurrency,
          getAmountByCurrency: (currency) => {
            const pricing = getPricingBySymbol(currency.name, orderQuote.totalAmount, cryptoFiatState.conversions);
            return pricing ? pricing.amount.toString() : '';
          },
          getIsGasless: () => provider.ethereumProvider?.isPassport || false,
          onFundingBalance: (foundBalances) => {
            setFundingBalances([...foundBalances]);
          },
          onFundingRequirement: (requirement) => {
            setTransactionRequirement(requirement);
          },
          onUpdateGasFees: (fees) => {
            setGasFees(fees);
          },
        });

        setFundingBalancesResult(results);
      } catch (err) {
        setFundingBalancesError(err instanceof Error ? err : new Error(String(err)));
      } finally {
        setLoadingBalances(false);
        fetching.current = false;
      }
    })();
  };

  return {
    fundingBalances,
    loadingBalances,
    fundingBalancesResult,
    fundingBalancesError,
    transactionRequirement,
    gasFees,
    queryFundingBalances,
  };
};