import toast from "react-hot-toast";

import { UNISWAP_V2_ROUTER, WETH_ADDRESSES } from "../../constants/addresses";
import { abi as RouterAbi } from "../../abi/UniswapV2Router.json";
import { getTokenAddress, executeOnChainTransaction } from "../helpers";

const swapMessages = {
    replacedMsg: "Swap transaction was replaced. Wait for inclusion please.",
    successMsg: "Swap executed successfully! Wait for balances update.",
    errorMsg: "Swap tokens failed. Check logs for error detalization.",
};

const addMessages = {
    replacedMsg: "Add liquidity transaction was replaced. Wait for inclusion please.",
    successMsg: "Liquidity added successfully! You should get LP tokens to your wallet.",
    errorMsg: "Adding liquidity failed. Check logs for error detalization.",
};

export const swapExactETHForTokens = async ({
    chainId,
    amountADesired,
    amountBMin,
    tokenNameTop,
    tokenNameBottom,
    destination,
    address,
    deadline
}) => {
    const args = [
        amountBMin,
        [WETH_ADDRESSES[chainId], getTokenAddress(chainId, tokenNameBottom)],
        destination,
        deadline
    ];

    await executeOnChainTransaction({
        chainId,
        args,
        abi: RouterAbi,
        address: UNISWAP_V2_ROUTER[chainId],
        functionName: "swapExactETHForTokens",
        account: address,
        messages: swapMessages,
        value: amountADesired,
    });
}

export const swapExactTokensForETH = async ({
    chainId,
    amountADesired,
    amountBMin,
    tokenNameTop,
    tokenNameBottom,
    destination,
    address,
    deadline
}) => {
    const args = [
        amountADesired,
        amountBMin,
        [getTokenAddress(chainId, tokenNameTop), WETH_ADDRESSES[chainId]],
        destination,
        deadline
    ];

    await executeOnChainTransaction({
        chainId,
        args,
        abi: RouterAbi,
        address: UNISWAP_V2_ROUTER[chainId],
        functionName: "swapExactTokensForETH",
        account: address,
        messages: swapMessages,
    });
}

export const swapExactTokensForTokens = async ({
    chainId,
    amountADesired,
    amountBMin,
    tokenNameTop,
    tokenNameBottom,
    destination,
    address,
    deadline
}) => {
    const args = [
        amountADesired,
        amountBMin,
        [getTokenAddress(chainId, tokenNameTop), getTokenAddress(chainId, tokenNameBottom)],
        destination,
        deadline
    ];

    await executeOnChainTransaction({
        chainId,
        args,
        abi: RouterAbi,
        address: UNISWAP_V2_ROUTER[chainId],
        functionName: "swapExactTokensForTokens",
        account: address,
        messages: swapMessages,
    });
}

export const addLiquidity = async ({
    chainId,
    tokenNameTop,
    tokenNameBottom,
    amountADesired,
    amountBDesired,
    amountAMin,
    amountBMin,
    address,
    destination,
    deadline,
}) => {
    const args = [
        getTokenAddress(chainId, tokenNameTop),
        getTokenAddress(chainId, tokenNameBottom),
        amountADesired,
        amountBDesired,
        amountAMin,
        amountBMin,
        destination,
        deadline
    ];

    await executeOnChainTransaction({
        chainId,
        args,
        abi: RouterAbi,
        address: UNISWAP_V2_ROUTER[chainId],
        functionName: "addLiquidity",
        account: address,
        messages: addMessages,
    });
}

export const addLiquidityETH = async ({
    chainId,
    tokenNameTop,
    tokenNameBottom,
    amountADesired,
    amountBDesired,
    amountAMin,
    amountBMin,
    address,
    destination,
    deadline,
}) => {
    let token = getTokenAddress(chainId, tokenNameTop);
    let amountTokenDesired = amountADesired;
    let amountETHDesired = amountBDesired;
    let amountTokenMin = amountAMin;
    let amountETHMin = amountBMin;

    if (token === undefined) {
        token = getTokenAddress(chainId, tokenNameBottom);
        amountTokenDesired = amountBDesired;
        amountETHDesired = amountADesired;
        amountTokenMin = amountBMin;
        amountETHMin = amountAMin;
    }

    const args = [
        token,
        amountTokenDesired,
        amountTokenMin,
        amountETHMin,
        destination,
        deadline
    ];

    await executeOnChainTransaction({
        chainId,
        args,
        abi: RouterAbi,
        address: UNISWAP_V2_ROUTER[chainId],
        functionName: "addLiquidityETH",
        account: address,
        messages: addMessages,
        value: amountETHDesired,
    });
}