import { BigNumber, ethers } from 'ethers';
import { SimpleNftCrowdsale__factory } from '../config/abi/factories/SimpleNftCrowdsale__factory';
import { SimpleNftCrowdsale as BaseContract } from '../config/abi/SimpleNftCrowdsale';
import { normalizeChainId } from '.././utils/chainUtils';
import { ContractInitializer } from './ContractInitializer';

const iface = SimpleNftCrowdsale__factory.createInterface();

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

    static async create(
        signer: ethers.providers.JsonRpcSigner,
        address: string
    ) {
        const chainId = normalizeChainId(await signer.getChainId());
        if (!chainId) {
            throw new Error('Invalid chain id');
        }
        const instance = new SimpleNftCrowdsale(chainId, iface, signer);

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

        return instance;
    }

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

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

    private purchaseTokenFor = async (price: BigNumber) => {
        this.logCall('purchaseTokenFor', { price: price.toString() });

        return this.contractInstance.purchaseTokenFor(
            await this.signer.getAddress(),
            { value: price }
        );
    };

    purchaseSingleToken = async () => {
        const price = await this.contractInstance.currentPrice();

        return this.purchaseTokenFor(price);
    };

    static encodeGrantRoleExtension = async (
        chainId: string,
        address: string,
        roleReceiver: string,
        role: string,
        signedAt: ethers.BigNumberish,
        signer: string,
        signature: ethers.utils.BytesLike
    ): Promise<string> => {
        const selfInstance = SimpleNftCrowdsale._newInstance(chainId, address);
        selfInstance.logCall('encodeGrantRoleExtension', {
            chainId,
            address,
            roleReceiver,
            role,
            signedAt,
            signer,
            signature,
        });

        return selfInstance.contractInstance.encodeGrantRoleExtension(
            roleReceiver,
            role,
            signedAt,
            signer,
            signature
        );
    };

    static decodeGrantRoleExtension = async (
        chainId: string,
        address: string,
        extensionData: ethers.utils.BytesLike
    ) => {
        const selfInstance = SimpleNftCrowdsale._newInstance(chainId, address);

        return selfInstance.contractInstance.decodeGrantRoleExtension(
            extensionData
        );
    };

    static encodeInitializer(
        chainId: string,
        address: string,
        currentPrice: ethers.BigNumberish,
        maxCap: ethers.BigNumberish,
        startingId: ethers.BigNumberish,
        wallet: string,
        nftAddress: string,
        publicSaleTime: ethers.BigNumberish,
        owner: string,
        extensionType: ethers.BigNumberish,
        extensionData: ethers.utils.BytesLike
    ) {
        const selfInstance = SimpleNftCrowdsale._newInstance(chainId, address);
        selfInstance.logCall('encodeInitializer', {
            chainId,
            address,
            currentPrice,
            maxCap,
            startingId,
            wallet,
            nftAddress,
            publicSaleTime,
            owner,
            extensionType,
            extensionData,
        });

        return selfInstance.contractInstance.encodeInitializer(
            currentPrice,
            maxCap,
            startingId,
            wallet,
            nftAddress,
            publicSaleTime,
            owner,
            extensionType,
            extensionData
        );
    }

    static maxCap = async (chainId: string, address: string) => {
        const selfInstance = SimpleNftCrowdsale._newInstance(chainId, address);
        selfInstance.logCall('maxCap', { chainId, address });
        return selfInstance.contractInstance.maxCap();
    };

    static currentPrice = async (chainId: string, address: string) => {
        const selfInstance = SimpleNftCrowdsale._newInstance(chainId, address);
        return selfInstance.contractInstance.currentPrice();
    };

    static nftTokenAddress = async (chainId: string, address: string) => {
        const selfInstance = SimpleNftCrowdsale._newInstance(chainId, address);
        return selfInstance.contractInstance.nftTokenAddress();
    };

    static currentTokenId = async (chainId: string, address: string) => {
        const selfInstance = SimpleNftCrowdsale._newInstance(chainId, address);
        return selfInstance.contractInstance.currentTokenId();
    };

    static startingId = async (chainId: string, address: string) => {
        const selfInstance = SimpleNftCrowdsale._newInstance(chainId, address);
        return selfInstance.contractInstance.startingId();
    };
}