import argparse
from terra_sdk.client.lcd import AsyncLCDClient
import asyncio
from terra_sdk.core.wasm import (
    MsgExecuteContract,
)
from terra_sdk.key.mnemonic import MnemonicKey
import base64


def add_default_args(parser):
    parser.add_argument('--rpc', required=True, help='Terra lcd address')
    parser.add_argument('--chain-id', dest="chain_id", required=True, help='Chain ID')
    parser.add_argument('--mnemonic', dest="mnemonic", required=True, help='Mnemonic of the wallet to be used')
    parser.add_argument('--contract', dest="contract", required=True, help='Address of the Wormhole contract')


parser = argparse.ArgumentParser(prog='terra_cli')

subparsers = parser.add_subparsers(help='sub-command help', dest="command")
gov_parser = subparsers.add_parser('execute_governance', help='Execute a governance VAA')
add_default_args(gov_parser)
gov_parser.add_argument('vaa', help='Hex encoded VAA')
post_parser = subparsers.add_parser('post_message', help='Publish a message over the wormhole')
add_default_args(post_parser)
post_parser.add_argument('nonce', help='Nonce of the message', type=int)
post_parser.add_argument('message', help='Hex-encoded message')

gas_prices = {
    "uluna": "0.15",
    "usdr": "0.1018",
    "uusd": "0.15",
    "ukrw": "178.05",
    "umnt": "431.6259",
    "ueur": "0.125",
    "ucny": "0.97",
    "ujpy": "16",
    "ugbp": "0.11",
    "uinr": "11",
    "ucad": "0.19",
    "uchf": "0.13",
    "uaud": "0.19",
    "usgd": "0.2",
}


async def sign_and_broadcast(sequence, deployer, terra, *msgs):
    tx = await deployer.create_and_sign_tx(
        msgs=msgs, fee_denoms=["ukrw", "uusd", "uluna"], sequence=sequence, gas_adjustment=1.4,
    )
    result = await terra.tx.broadcast(tx)
    sequence += 1
    if result.is_tx_error():
        raise RuntimeError(result.raw_log)
    return result


class ContractQuerier:
    def __init__(self, address, terra):
        self.address = address
        self.terra = terra

    def __getattr__(self, item):
        async def result_fxn(**kwargs):
            return await self.terra.wasm.contract_query(self.address, {item: kwargs})

        return result_fxn


class Contract:
    def __init__(self, address, deployer, terra, sequence):
        self.address = address
        self.deployer = deployer
        self.terra = terra
        self.sequence = sequence

    def __getattr__(self, item):
        async def result_fxn(coins=None, **kwargs):
            execute = MsgExecuteContract(
                self.deployer.key.acc_address, self.address, {item: kwargs}, coins=coins
            )
            return await sign_and_broadcast(self.sequence, self.deployer, self.terra, execute)

        return result_fxn

    @property
    def query(self):
        return ContractQuerier(self.address, self.terra)


async def main():
    args = parser.parse_args()
    async with AsyncLCDClient(
            args.rpc, args.chain_id, gas_prices=gas_prices, loop=asyncio.get_event_loop()
    ) as terra:
        deployer = terra.wallet(MnemonicKey(
            mnemonic=args.mnemonic))
        sequence = await deployer.sequence()

        wormhole = Contract(args.contract, deployer, terra, sequence)

        res = dict()
        if args.command == "execute_governance":
            res = await wormhole.submit_v_a_a(vaa=base64.b64encode(bytes.fromhex(args.vaa)).decode("utf-8"))
        elif args.command == "post_message":
            state = await wormhole.query.get_state()
            fee = state["fee"]
            res = await wormhole.post_message(nonce=args.nonce,
                                              message=base64.b64encode(bytes.fromhex(args.message)).decode("utf-8"),
                                              coins={fee["denom"]: fee["amount"]})
        print(res.logs[0].events_by_type["from_contract"])


if __name__ == "__main__":
    asyncio.get_event_loop().run_until_complete(main())