import { BigNumber, ethers } from 'ethers';
import { OmniteAxelarBridgeSender__factory } from '../config/abi/factories/OmniteAxelarBridgeSender__factory';
import {
    IOmniteAxelarBridge,
    IOmniteAxelarBridgeSender,
    OmniteAxelarBridgeSender as BaseContract,
} from '../config/abi/OmniteAxelarBridgeSender';
import { DeployBlueprintName } from '../types';
import { normalizeChainId } from '../utils/chainUtils';
import { FacetId } from './constants';
import { ContractFactory } from './ContractFactory';
import { ContractInitializer } from './ContractInitializer';
import { DiamondFacetsRegistry } from './DiamondFacetsRegistry';
import { ERC721Native } from './ERC721Native';

const iface = OmniteAxelarBridgeSender__factory.createInterface();
export class OmniteAxelarBridgeSender extends ContractInitializer<BaseContract> {
    className = OmniteAxelarBridgeSender.name;

    static async create(signer: ethers.providers.JsonRpcSigner) {
        const chainId = normalizeChainId(await signer.getChainId());
        if (!chainId) {
            throw new Error('chainId is not defined');
        }
        const instance = new OmniteAxelarBridgeSender(chainId, iface, signer);

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

        return instance;
    }

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

    deployExternalCollectionOnNewChains = async (
        collectionId: string,
        deploymentParams: Array<IOmniteAxelarBridge.DeploymentParamsStruct>,
        params: IOmniteAxelarBridgeSender.DeployExternalParamsStruct,
        value: BigNumber
    ) => {
        this.logCall('deployExternalCollectionOnNewChains', {
            collectionId,
            deploymentParams,
            params,
            value,
        });
        return this.contractInstance.deployExternalCollectionOnNewChains(
            collectionId,
            deploymentParams,
            params,
            { value }
        );
    };

    deployNativeCollection = async (
        deploymentParams: Array<IOmniteAxelarBridge.DeploymentParamsStruct>,
        params: IOmniteAxelarBridgeSender.DeployNativeParamsStruct,
        value: BigNumber
    ) => {
        this.logCall('deployNativeCollection', {
            deploymentParams,
            params,
            value,
        });

        return this.contractInstance.deployNativeCollection(
            deploymentParams,
            params,
            {
                value,
            }
        );

        // Working hardcoded deployment
        // const blueprintAddress = await ContractFactory.getLatestBlueprint(
        //     this.chainConfig.chainId,
        //     'ERC721Native' as any
        // );
        // const facets = await DiamondFacetsRegistry.getFacetCutData(
        //     this.chainConfig.chainId,
        //     FacetId.ERC721OmniteCoreFacetsPack
        // );
        // const [, facetCuts] = facets;
        // const diamondCut = facetCuts.map((v: any) => {
        //     return {
        //         action: 0,
        //         facetAddress: v.facetAddress,
        //         functionSelectors: v.functionSelectors,
        //     };
        // });
        // const encodedParams = await ERC721Native.encodeRaw(
        //     this.chainConfig.chainId,
        //     blueprintAddress,
        //     this.chainConfig.contractAddress.systemContext,
        //     'name',
        //     'symbol',
        //     params.refundAddress as string,
        //     0,
        //     100,
        //     'contractUri',
        //     'baseContractUri',
        //     diamondCut
        // );
        // return this.contractInstance.deployNativeCollection(
        //     [
        //         {
        //             chain: 'binance',
        //             bridgeAddress: 'string',
        //             value: ethers.utils.parseEther('0'),
        //             ctorParams: encodedParams,
        //             originalContractAddress: ethers.constants.AddressZero,
        //         },
        //     ],
        //     {
        //         collectionName: 'name',
        //         refundAddress: params.owner,
        //         gasAmount: ethers.utils.parseEther('0'),
        //         owner: params.owner,
        //     },
        //     {
        //         value: ethers.utils.parseEther('0'),
        //     }
        // );
    };

    populateDeployNativeCollection = async (
        deploymentParams: Array<IOmniteAxelarBridge.DeploymentParamsStruct>,
        params: IOmniteAxelarBridgeSender.DeployNativeParamsStruct,
        value: BigNumber
    ) => {
        this.logCall('deployNativeCollection', {
            deploymentParams,
            params,
            value,
        });

        return this.contractInstance.populateTransaction.deployNativeCollection(
            deploymentParams,
            params,
            {
                value,
            }
        );
    };

    // deployExternalCollection = async (
    //     deploymentParams: Array<IOmniteAxelarBridge.DeploymentParamsStruct>,
    //     params: IOmniteAxelarBridgeSender.DeployExternalParamsStruct,
    //     value: BigNumber
    // ) => {
    //     this.logCall('deployExternalCollection', {
    //         deploymentParams,
    //         params,
    //         value,
    //     });
    //     return this.contractInstance.deployExternalCollection(
    //         deploymentParams,
    //         params,
    //         {
    //             value,
    //         }
    //     );
    // };

    // deployCrowdsale = async (
    //     deploymentParams: IOmniteAxelarBridge.DeploymentParamsStruct,
    //     grantRoleParams: IBridge.GrantRoleParamsStruct,
    //     refundAddress: string,
    //     gasAmount: ethers.BigNumberish,
    //     owner: string,
    //     crowdsaleSalt: ethers.utils.BytesLike,
    //     value: BigNumber
    // ) => {
    //     this.logCall('deployCrowdsale', {
    //         address: this.address,
    //         deploymentParams,
    //         grantRoleParams,
    //         refundAddress,
    //         gasAmount,
    //         owner,
    //         crowdsaleSalt,
    //     });

    //     return this.contractInstance.deployCrowdsale(
    //         deploymentParams,
    //         grantRoleParams,
    //         refundAddress,
    //         gasAmount,
    //         owner,
    //         crowdsaleSalt,
    //         { value }
    //     );
    // };

    static deployTokenContractEncode = async (
        chainId: string,
        blueprintName: DeployBlueprintName,
        collectionId: ethers.utils.BytesLike,
        ctorParams: ethers.utils.BytesLike,
        collectionName: string,
        ownerAddress: string
    ) => {
        const instance = OmniteAxelarBridgeSender._newInstance(chainId);
        instance.logCall('deployTokenContractEncode', {
            chainId,
            blueprintName,
            collectionId,
            ctorParams,
            collectionName,
            ownerAddress,
        });

        if (blueprintName === DeployBlueprintName.SimpleNftCrowdsale) {
            throw new Error('Invalid blueprint');
        } else {
            return instance.contractInstance.deployTokenContractEncode(
                blueprintName,
                collectionId,
                ctorParams,
                collectionName,
                ownerAddress
            );
        }
    };

    static mintOnTargetChainEncode = async (
        chainId: string,
        collectionId: ethers.utils.BytesLike,
        ownerAddress: string,
        mintId: ethers.BigNumberish,
        tokenUri: string
    ) => {
        const instance = OmniteAxelarBridgeSender._newInstance(chainId);
        instance.logCall('mintOnTargetChainEncode', {
            chainId,
            collectionId,
            ownerAddress,
            mintId,
            tokenUri,
        });
        return instance.contractInstance.mintOnTargetChainEncode(
            collectionId,
            ownerAddress,
            mintId,
            tokenUri
        );
    };
}