import { useContracts } from "../../useContracts/useContracts";
import { useTokenDetails } from "../../useTokenDetails/useTokenDetails";
import { usePool } from "../../pools/usePool/usePool";
import { useEffect } from "react";
import { parseUnits } from "ethers/lib/utils";
import { doTransaction } from "../../../utils/transactions/transactions";
import { useUserPositions } from "../useUserPositions/useUserPositions";
import {
  DepositMode,
  useCommonDepositLogic,
} from "../useCommonDepositLogic/useCommonDepositLogic";
import { useDepositHelper } from "../useDepositHelper/useDepositHelper";
import { usePollForPositionChange } from "../usePollForPositionChange/usePollForPositionChange";
import { UserPosition } from "../../../state";

/**
 * A hook to deposit to an existing position (deposit), with approval if required
 */
export const useDeposit = (positionId: number) => {
  const { depositHelper, reliquary } = useContracts();
  const { userPositions } = useUserPositions();
  const { fetchTokenDetails } = useTokenDetails();
  const poll = usePollForPositionChange(positionId);

  const position = userPositions[positionId];

  const pool = usePool(position.poolId);

  const { approveDepositHelperForAllRelics, depositHelperIsApprovedForRelics } =
    useDepositHelper();

  const {
    allowance,
    amount,
    approve,
    decimalPlaces,
    depositAsset,
    isDepositHelperUsed,
    mode,
    setAmount,
    setIsDepositHelperUsed,
    setMode,
    underlyingAsset,
    userBalance,
    setUseNativeToken,
    useNativeToken,
  } = useCommonDepositLogic(pool.poolId);

  const deposit = async () => {
    try {
      if (isDepositHelperUsed && !depositHelperIsApprovedForRelics) {
        await approveDepositHelperForAllRelics();
        setMode(DepositMode.APPROVING);
      }

      if (allowance < parseFloat(amount)) {
        await approve(DepositMode.DEPOSITING);
      }

      setMode(DepositMode.DEPOSITING);

      //deposit helper will have .weth() pointing to wftm address
      const receipt = await doTransaction(() => {
        const depositAmount = parseUnits(amount, decimalPlaces);
        if (useNativeToken) {
          return depositHelper.deposit(depositAmount, positionId, {
            value: depositAmount,
          });
        } else {
          return (isDepositHelperUsed ? depositHelper : reliquary).deposit(
            depositAmount,
            positionId
          );
        }
      });

      const positionDidChangeFromDeposit = (pos: UserPosition) =>
        pos.amount > position.amount;

      const updatedPosition = await poll(positionDidChangeFromDeposit);

      fetchTokenDetails(depositAsset);
      setMode(DepositMode.IDLE);
      setAmount("");
      return { updatedPosition, receipt };
    } catch (e: any) {
      setMode(DepositMode.IDLE);
      setAmount("");
      throw e;
    }
  };

  useEffect(() => {
    fetchTokenDetails(pool.lpAddress);
  }, [pool.lpAddress]);

  return {
    allowance,
    amount,
    approve,
    deposit,
    depositAsset,
    isDepositHelperUsed,
    mode,
    setAmount,
    setIsDepositHelperUsed,
    underlyingAsset,
    userBalance,
    setUseNativeToken,
  };
};