import { BigNumber } from 'ethers';
import { AxelarQueryAPI, Environment } from '@axelar-network/axelarjs-sdk';
import { getWalletConfigByChainId } from './utils/chainUtils';
import config from './config/config';
import { OmniteAxelarBridgeReceiver } from './contracts/OmniteAxelarBridgeReceiver';

export class Axelar {
    static estimateFees = async (
        sourceChainId: string,
        targetChainId: string,
        gas?: BigNumber
    ): Promise<BigNumber> => {
        console.debug({
            method: 'Axelar.estimateFees',
            sourceChainId,
            targetChainId,
            gas,
        });
        const sdkApi = new AxelarQueryAPI({
            environment: Environment.TESTNET,
        });

        const sourceChainConfig = getWalletConfigByChainId(sourceChainId);
        const targetChainConfig = getWalletConfigByChainId(targetChainId);

        const result = await sdkApi.estimateGasFee(
            sourceChainConfig.axelarChainId,
            targetChainConfig.axelarChainId,
            sourceChainConfig.gasToken,
            (gas || config.defaults.deploymentGas).toNumber()
        );

        console.debug({
            method: 'Axelar.estimateFees',
            estimateFees: result,
            bn: BigNumber.from(result),
        });

        return BigNumber.from(result);
    };

    /**
     * Responsible for calculating how much gas is needed to send a bytecode to the target chain.
     * @param  {string} sourceChainId
     * @param  {string} signerAddress
     * @param  {string} targetChainId
     * @param  {string} payload
     */
    static estimateReceiveGas = async (
        sourceChainId: string,
        signerAddress: string,
        targetChainId: string,
        payload: string
    ) => {
        const sourceChainConfig = getWalletConfigByChainId(sourceChainId);

        if (!sourceChainConfig) {
            throw new Error('Invalid source chain config');
        }

        console.debug({
            method: 'Axelar.estimateGasLimit',
            sourceChainId,
            signerAddress,
            targetChainId,
            payload,
        });

        const estimatedGasLimitResponse =
            await OmniteAxelarBridgeReceiver.estimateReceiveGas(
                targetChainId,
                sourceChainConfig.axelarChainId,
                signerAddress,
                payload
            );

        let estimatedGasLimit = BigNumber.from(estimatedGasLimitResponse);
        if (estimatedGasLimit.lte(100000)) {
            estimatedGasLimit = BigNumber.from(100000);
        }

        return estimatedGasLimit.mul(200).div(100);
    };
}