import { ethers } from 'ethers';
import { OmniteLayerZeroBridgeReceiver__factory } from '../config/abi/factories/OmniteLayerZeroBridgeReceiver__factory';
import { OmniteLayerZeroBridgeReceiver as BaseContract } from '../config/abi/OmniteLayerZeroBridgeReceiver';
import { ContractInitializer } from './ContractInitializer';

const iface = OmniteLayerZeroBridgeReceiver__factory.createInterface();

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

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

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

        return instance;
    };

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

    /**
     * Experimental wait for contract deployment
     *
     * @param  {string} chainId
     * @param  {number} watchSourceLayerZeroChainId
     * @returns Promise
     */
    static waitContractDeployed = async (
        chainId: string,
        watchSourceLayerZeroChainId: number
    ): Promise<string> => {
        const selfInstance =
            OmniteLayerZeroBridgeReceiver._newInstance(chainId);

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

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

                    unsubscribe();
                    resolve(_calledContract);
                }
            );
        });
    };

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

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

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