import { Address } from "@celo/utils/lib/address";
import { balanceOfMulticall, Multicall } from "@node-fi/multicall";
import axios from "axios";
import BigNumber from "bignumber.js";

import { NodeRoute, RouterResponse, SmartRouter } from "../Routing";
import { Token } from "../Tokens";
import { formatRouteRequest } from "../constants";
import { Wallet } from "../wallet";

import {
  DepositTransactionDetails,
  EarnPosition,
  LendingMarketDetails,
} from "./EarnPosition";

export class LendingMarket extends EarnPosition {
  private debtToken: Token;
  constructor({ debtToken, ...base }: LendingMarketDetails, wallet?: Wallet) {
    super(base, wallet);
    this.debtToken = new Token(base.chainId, debtToken, 18);
  }

  balanceOfMulticall = (owner: string): Multicall<BigNumber> =>
    balanceOfMulticall(this.debtToken.address, owner);

  async getExpectedDeposit(
    tokenIn: string,
    amountIn: string
  ): Promise<{
    expectedOut?: BigNumber;
    routerAddress?: string;
    routes?: NodeRoute[];
    error?: string;
  }> {
    try {
      const url = formatRouteRequest();
      const response = await axios.get<RouterResponse>(url);
      const { expectedOut, details, routerAddress } = response.data;
      return {
        expectedOut: new BigNumber(expectedOut),
        routes: [details],
        routerAddress,
      };
    } catch (e) {
      if (axios.isAxiosError(e)) {
        return { error: e.message };
      }
      return { error: "true" };
    }
  }

  async withdrawToSelectedToken(
    amountToWithdraw: BigNumber,
    tokenOut: string
  ): Promise<{
    directOutput?: { [address: Address]: BigNumber };
    expectedOut?: BigNumber | undefined;
    routerAddress?: string | undefined;
    underlyingRoutes?: NodeRoute[] | undefined;
    error?: string | undefined;
  }> {
    try {
      const url = formatRouteRequest();
      const response = await axios.get<RouterResponse>(url);
      const { expectedOut, details, routerAddress } = response.data;
      return {
        expectedOut: new BigNumber(expectedOut),
        underlyingRoutes: [details],
        routerAddress,
      };
    } catch (e) {
      if (axios.isAxiosError(e)) {
        return { error: e.message };
      }
      return { error: "true" };
    }
  }

  async withdrawToUnderlying(amountToWithdraw: BigNumber): Promise<{
    directOutput?: { [address: string]: BigNumber } | undefined;
    error?: string | undefined;
  }> {
    try {
      const url = formatRouteRequest();
      const response = await axios.get<RouterResponse>(url);
      const { expectedOut, details, routerAddress } = response.data;
      return {
        directOutput: {
          [this.base.depositToken]: new BigNumber(expectedOut),
        },
      };
    } catch (e) {
      if (axios.isAxiosError(e)) {
        return { error: e.message };
      }
      return { error: "true" };
    }
  }

  public formatTransaction(
    details: DepositTransactionDetails,
    to: Address,
    slippage: number
  ): { to: string; data: string; gas: string } | undefined {
    const { routes, expectedOut, routerAddress } = details;
    if (!routes || !expectedOut || !routerAddress) return undefined;
    return SmartRouter.formatTransaction(
      routes[0],
      to,
      slippage,
      routerAddress
    );
  }

  canDirectlySwap(): boolean {
    return true;
  }

  public additionalTransactionsForDeposit(): {
    to: string;
    data: string;
    gas: string;
  }[] {
    return [];
  }
}