import {
    AssetInfoWithTrace,
    AssetTransferObject,
    CallbackStatus,
    TransferAssetBridge
} from "@axelar-network/axelarjs-sdk";

export class AxelarAPI {

    private environment: string;
    private axelarJsSDK: TransferAssetBridge;

    constructor(environment: string) {
        this.environment = environment;
        this.axelarJsSDK = new TransferAssetBridge(environment);
    }

    public async getOneTimeMessageToSign(sigerAddress: string): Promise<{validationMsg: string; otc: string;}> {

        try {
            return await this.axelarJsSDK.getOneTimeCode(sigerAddress);
        } catch (e: any) {
            throw e;
        }

    }

    public async getDepositAddress(payload: AssetTransferObject, showAlerts: boolean = true): Promise<AssetInfoWithTrace> {

        try {
            return this.axelarJsSDK.getDepositAddress(payload, showAlerts);
        } catch (e: any) {
            throw e;
        }
        
    }

}

    const environment: string = "testnet"; /*environment should be one of local | devnet | testnet | mainnet*/
    
    const api: AxelarAPI = new AxelarAPI(environment);

    /*below is sample implementation using ethers.js, but you can use whatever you want*/
    const provider = new ethers.providers.Web3Provider(window.ethereum, "any"); //2nd param is network type
    const signerAuthority = provider.getSigner();
    const signerAuthorityAddress = signerAuthority.getAddress();

    const getNoncedMessageToSign = async () => {
        const signerAuthorityAddress = await signerAuthority.getAddress();
        const {validationMsg, otc} = await api.getOneTimeMessageToSign(signerAuthorityAddress);
        return {validationMsg, otc};
    }

    const promptUserToSignMessage = async () => {
        const {validationMsg, otc} = await getNoncedMessageToSign();
        const signature = await signerAuthority.signMessage(validationMsg);

        return {
            otc,
            publicAddr: await signerAuthority.getAddress(),
            signature};
    }

    const getDepositAddress = async (destinationAddress?: string) => {
        const {otc, publicAddr, signature} = await promptUserToSignMessage();
        const parameters: AssetTransferObject = getParameters(destinationAddress || publicAddr); // wherever you specify for the destination address on the destination chain
        parameters.otc = otc;
        parameters.publicAddr = publicAddr;
        parameters.signature = signature;

        const linkAddress = await api.getDepositAddress(parameters);
    }
    

// getParameters.ts

const getParameters = (destinationAddress: string, sourceChainName: string = "terra", destinationChainName: string = "avalanche", asset_common_key: string = "uusd") => {

    /*
    info for sourceChainInfo and destinationChainInfo fetched from the ChainList module. 
    * */
    const terraChain: ChainInfo = ChainList.map((chain: Chain) => chain.chainInfo).find((chainInfo: ChainInfo) => chainInfo.chainName.toLowerCase() === sourceChainName.toLowerCase()) as ChainInfo;
    const avalancheChain: ChainInfo = ChainList.map((chain: Chain) => chain.chainInfo).find((chainInfo: ChainInfo) => chainInfo.chainName.toLowerCase() === destinationChainName.toLowerCase()) as ChainInfo;
    const assetObj = terraChain.assets?.find((asset: AssetInfo) => asset.common_key === asset_common_key) as AssetInfo;

    let requestPayload: AssetTransferObject = {
        sourceChainInfo: terraChain,
        destinationChainInfo: avalancheChain,
        selectedSourceAsset: assetObj,
        selectedDestinationAsset: {
            ...assetObj,
            assetAddress: destinationAddress, //address on the destination chain where you want the tokens to arrive
        },
        signature: "SIGNATURE_FROM_METAMASK_SIGN",
        otc: "OTC_RECEIVED_FROM_SERVER",
        publicAddr: "SIGNER_OF_SIGNATURE",
        transactionTraceId: "YOUR_OWN_UUID" //your own UUID, helpful for tracing purposes. optional.
    }

    return requestPayload;
}