import { Address } from "../../common/tokenList";
import { RawRoute } from "../core/getRoute";
import { SwapSlippageConfig, SwapResult } from "../core/swap";

// Types resolved from consumer's ethers
type Signer = import("ethers").Signer;
type TransactionReceipt = import("ethers").TransactionReceipt;
import { CalldataResult } from "../helpers/generateCalldata";
import { TotalAmountInDetails } from "../helpers/getTotalAmountIn";
import { TotalAmountOutDetails } from "../helpers/getTotalAmountOut";
import { SymphonyConfig } from "../constants/config";
import { RouteDetails } from "../helpers/getRouteDetails";
import { RoutePayload } from "../core/getRoute";

export class Route {
  amountIn: bigint;
  amountInFormatted: string;
  includesNative: boolean;
  pathCount: number;
  pathPercentages: number[];
  amountOut: bigint;
  amountOutFormatted: string;
  route: RawRoute;
  rebate?: string;
  tokenIn: Address;
  tokenOut: Address;
  tokenInUsd: number;
  tokenOutUsd: number;
  swapFee: string;
  priceImpactPercentage: number;
  options: { isRaw: boolean };
  private getSigner: () => Signer;

  constructor(
    routePayload: RoutePayload,
    getSigner: () => Signer,
    options?: { isRaw: boolean }
  );

  swap(params?: {
    route?: RawRoute;
    includesNative?: boolean;
    signer?: Signer;
    options?: {
      skipApproval?: boolean;
      skipCheckApproval?: boolean;
      wait?: number;
      isRaw?: boolean;
      outTokenDecimals?: number | undefined;
    };
    slippage?: SwapSlippageConfig;
  }): Promise<SwapResult>;

  generateCalldata(params?: {
    from?: Signer | Address;
    route?: RawRoute;
    includesNative?: boolean;
    slippage?: SwapSlippageConfig;
    options?: {
      isRaw?: boolean;
      outTokenDecimals?: number | undefined;
    };
  }): Promise<CalldataResult>;

  checkApproval(params?: {
    variable?: RawRoute;
    signer?: Signer;
    includesNative?: boolean;
    options?: {
      isRaw?: boolean;
      chainId?: number;
    };
  }): Promise<boolean>;

  giveApproval(params?: {
    variable?: RawRoute;
    signer?: Signer;
    amount?: string | bigint;
    options?: {
      isRaw?: boolean;
      chainId?: number;
      wait?: number;
    };
  }): Promise<TransactionReceipt>;

  refresh(): Promise<Route>;

  getTotalAmountIn(route?: RawRoute): Promise<TotalAmountInDetails>;
  getTotalAmountOut(route?: RawRoute): Promise<TotalAmountOutDetails>;
  getTokenIn(): Address | undefined;
  getTokenOut(): Address | undefined;
  getSwapTypes(): number[][] | undefined;
  getRouteDetails(): Promise<RouteDetails>;
  getConfig(): SymphonyConfig;
  setConfig(options: any): void;
}