import { BigNumberish, ethers } from 'ethers';
import { ERC721Facet } from '../config/abi/ERC721/common/facets/ERC721Facet';
import { ERC721OmniteFacet } from '../config/abi/ERC721/common/facets/ERC721OmniteFacet';
import { ERC721LayerZeroBridgedableFacet } from '../config/abi/ERC721/common/facets/ERC721LayerZeroBridgedableFacet';
import { ERC721NonNative as BaseContract } from '../config/abi/ERC721/non-native/ERC721NonNative';
import { ERC721NonNativeTokenURIFacet } from '../config/abi/ERC721/non-native/facets/ERC721NonNativeTokenURIFacet';
import { ERC721NonNative__factory } from '../config/abi/factories/ERC721/non-native/ERC721NonNative__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 = ERC721NonNative__factory.createInterface();

export class ERC721NonNative extends DiamondContractInitializer<
    BaseContract,
    {
        common: ERC721Facet;
        omnite: ERC721OmniteFacet;
        layerZeroBridgable: ERC721LayerZeroBridgedableFacet;
        nonNativeTokenURI: ERC721NonNativeTokenURIFacet;
    }
> {
    className = ERC721NonNative.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 ERC721NonNative(chainId, iface, signer);
        instance.logCall('create', { address });

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

        return instance;
    }

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

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

    static encode = async (
        chainId: string,
        address: string,
        name: string,
        symbol: string,
        ownerAddress: string,
        contractURI: string
    ) => {
        const selfInstance = ERC721NonNative._newInstance(chainId, address);

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

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

        return selfInstance.contractInstance.encode(
            systemContextAddress,
            name,
            symbol,
            ownerAddress,
            contractURI,
            diamondCuts
        );
    };

    static getContractUri = async (
        chainId: string,
        address: string
    ): Promise<string> => {
        const selfInstance = ERC721NonNative._newInstance(chainId, address);
        return selfInstance.facets.omnite.contractURI();
    };

    static getTokenUri = async (
        chainId: string,
        address: string,
        tokenId: BigNumberish
    ): Promise<string> => {
        const selfInstance = ERC721NonNative._newInstance(chainId, address);
        return selfInstance.facets.nonNativeTokenURI.tokenURI(tokenId);
    };

    static getName = async (
        chainId: string,
        address: string
    ): Promise<string> => {
        const selfInstance = ERC721NonNative._newInstance(chainId, address);
        return selfInstance.facets.common.name();
    };

    getApproved = async (tokenId: BigNumberish) => {
        return this.facets.common.getApproved(tokenId);
    };

    approve = async (to: string, tokenId: BigNumberish) => {
        return this.facets.common.approve(to, tokenId);
    };

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

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