import { BigNumberish, ethers } from 'ethers';
import { ERC721LayerZeroBridgedableFacet } from '../config/abi/ERC721/common/facets/ERC721LayerZeroBridgedableFacet';
import { ERC721NonNativeWrapper as BaseContract } from '../config/abi/ERC721/non-native-wrapper/ERC721NonNativeWrapper';
import { ERC721WrapperFacet } from '../config/abi/ERC721/non-native-wrapper/facets/ERC721WrapperFacet';
import { ERC721NonNativeWrapper__factory } from '../config/abi/factories/ERC721/non-native-wrapper/ERC721NonNativeWrapper__factory';
import config from '../config/config';
import { ChainId } from '../config/constants';
import { normalizeChainId } from '../utils/chainUtils';
import { FacetId } from './constants';
import { DiamondContractInitializer } from './DiamondContractInitializer';

const iface = ERC721NonNativeWrapper__factory.createInterface();
export class NonNativeWrapper extends DiamondContractInitializer<
    BaseContract,
    {
        layerZeroBridgeable: ERC721LayerZeroBridgedableFacet;
        wrapper: ERC721WrapperFacet;
    }
> {
    className = NonNativeWrapper.name;

    static async create(
        signer: ethers.providers.JsonRpcSigner,
        address: string
    ) {
        const chainId = normalizeChainId(await signer.getChainId());
        if (!chainId) {
            throw new Error('Cannot fetch chainId from signer');
        }

        const instance = new NonNativeWrapper(chainId, iface, signer);
        instance.logCall('create', { address });

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

        return instance;
    }

    static _newInstance = (chainId: string, address: string) => {
        const selfInstance = new NonNativeWrapper(chainId, iface);

        selfInstance.address = address;
        selfInstance.initialize();
        return selfInstance;
    };

    static originalContract = async (
        chainId: string,
        address: string
    ): Promise<string> => {
        const selfInstance = NonNativeWrapper._newInstance(chainId, address);

        return selfInstance.facets.wrapper.originalContract();
    };

    static encode = async (
        chainId: string,
        address: string,
        originalContractAddress: string
    ) => {
        const selfInstance = NonNativeWrapper._newInstance(chainId, address);

        const systemContextAddress = config.getChainConfig(chainId as ChainId)
            .contractAddress.systemContext;

        const diamondCuts = await selfInstance.getFacetCuts(
            FacetId.ERC721OmniteNonNativeWrapperFacetsPack
        );

        return selfInstance.contractInstance.encode(
            systemContextAddress,
            originalContractAddress,
            diamondCuts
        );
    };

    moveTo = async (
        layerZeroChainId: BigNumberish,
        destinationBridge: string,
        tokenId: BigNumberish,
        gasAmount: BigNumberish,
        value: BigNumberish
    ) => {
        this.logCall('moveTo', {
            layerZeroChainId,
            destinationBridge,
            tokenId,
            gasAmount,
            value,
        });

        return this.facets.layerZeroBridgeable.moveToViaLayerZero(
            layerZeroChainId,
            destinationBridge,
            tokenId,
            gasAmount,
            { value }
        );
    };
}