import { ethers } from 'ethers';
import { OmniteAxelarBridgeReceiver__factory } from '../config/abi/factories/OmniteAxelarBridgeReceiver__factory';
import { OmniteAxelarBridgeReceiver as BaseContract } from '../config/abi/OmniteAxelarBridgeReceiver';
import { ContractInitializer } from './ContractInitializer';

const iface = OmniteAxelarBridgeReceiver__factory.createInterface();

export class OmniteAxelarBridgeReceiver extends ContractInitializer<BaseContract> {
    className = OmniteAxelarBridgeReceiver.name;

    static create = (
        signer: ethers.providers.JsonRpcSigner,
        chainId: string
    ) => {
        const instance = new OmniteAxelarBridgeReceiver(chainId, iface, signer);

        instance.address = instance.contractAddress.omniteAxelarBridgeReceiver;
        instance.initialize();

        return instance;
    };

    static _newInstance = (chainId: string) => {
        const selfInstance = new OmniteAxelarBridgeReceiver(chainId, iface);
        selfInstance.address =
            selfInstance.contractAddress.omniteAxelarBridgeReceiver;
        selfInstance.initialize();
        return selfInstance;
    };

    static waitContractDeployed = async (
        chainId: string,
        watchSourceAxelarChainId: number
    ): Promise<string> => {
        const selfInstance = OmniteAxelarBridgeReceiver._newInstance(chainId);

        const unsubscribe = () =>
            selfInstance.contractInstance.removeAllListeners(
                'ContractDeployed'
            );

        return new Promise((resolve, _reject) => {
            selfInstance.contractInstance.on(
                'ContractDeployed',
                (
                    sourceAxelarChainId: number,
                    _fromAddress: string,
                    _nonce: string,
                    _calledContract: string
                ) => {
                    console.debug({
                        event: 'ContractDeployed',
                        sourceAxelarChainId,
                        watchSourceAxelarChainId,
                        _fromAddress,
                        _nonce,
                        _calledContract,
                        config: selfInstance.chainConfig,
                    });
                    if (sourceAxelarChainId !== watchSourceAxelarChainId) {
                        return;
                    }

                    unsubscribe();
                    resolve('');
                }
            );
        });
    };

    static estimateReceiveGas = async (
        chainId: string,
        sourceAxelarChainName: string,
        fromAddress: string,
        payload: ethers.utils.BytesLike
    ) => {
        const selfInstance = OmniteAxelarBridgeReceiver._newInstance(chainId);

        selfInstance.logCall('estimateReceiveGas', {
            chainId,
            sourceAxelarChainName,
            fromAddress,
            payload,
        });

        return selfInstance.contractInstance.callStatic.estimateReceiveGas(
            sourceAxelarChainName,
            fromAddress,
            payload
        );
    };
}