package keeper

import (
	"encoding/hex"
	"fmt"
	"math/big"

	errorsmod "cosmossdk.io/errors"
	sdk "github.com/cosmos/cosmos-sdk/types"
	"github.com/ethereum/go-ethereum/core/vm"
	"github.com/ethereum/go-ethereum/crypto"
	evmtypes "github.com/evmos/ethermint/x/evm/types"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"

	"github.com/kava-labs/kava/x/evmutil/types"
)

const (
	erc20BalanceOfMethod   = "balanceOf"
	erc20BurnMethod        = "burn"
	erc20MintMethod        = "mint"
	erc20TotalSupplyMethod = "totalSupply"
)

// DeployTestMintableERC20Contract deploys an ERC20 contract on the EVM as the
// module account and returns the address of the contract. This contract has
// minting permissions for the module account.
// Derived from tharsis/evmos
// https://github.com/tharsis/evmos/blob/ee54f496551df937915ff6f74a94732a35abc505/x/erc20/keeper/evm.go
func (k Keeper) DeployTestMintableERC20Contract(
	ctx sdk.Context,
	name string,
	symbol string,
	decimals uint8,
) (types.InternalEVMAddress, error) {
	ctorArgs, err := types.ERC20MintableBurnableContract.ABI.Pack(
		"", // Empty string for contract constructor
		name,
		symbol,
		decimals,
	)
	if err != nil {
		return types.InternalEVMAddress{}, errorsmod.Wrapf(err, "token %v is invalid", name)
	}

	data := make([]byte, len(types.ERC20MintableBurnableContract.Bin)+len(ctorArgs))
	copy(
		data[:len(types.ERC20MintableBurnableContract.Bin)],
		types.ERC20MintableBurnableContract.Bin,
	)
	copy(
		data[len(types.ERC20MintableBurnableContract.Bin):],
		ctorArgs,
	)

	nonce, err := k.accountKeeper.GetSequence(ctx, types.ModuleEVMAddress.Bytes())
	if err != nil {
		return types.InternalEVMAddress{}, err
	}

	contractAddr := crypto.CreateAddress(types.ModuleEVMAddress, nonce)
	_, err = k.CallEVMWithData(ctx, types.ModuleEVMAddress, nil, data)
	if err != nil {
		return types.InternalEVMAddress{}, fmt.Errorf("failed to deploy ERC20 for %s: %w", name, err)
	}

	return types.NewInternalEVMAddress(contractAddr), nil
}

// DeployKavaWrappedCosmosCoinERC20Contract validates token details and then deploys an ERC20
// contract with the token metadata.
// This method does NOT check if a token for the provided SdkDenom has already been deployed.
func (k Keeper) DeployKavaWrappedCosmosCoinERC20Contract(
	ctx sdk.Context,
	token types.AllowedCosmosCoinERC20Token,
) (types.InternalEVMAddress, error) {
	if err := token.Validate(); err != nil {
		return types.InternalEVMAddress{}, errorsmod.Wrapf(err, "failed to deploy erc20 for sdk denom %s", token.CosmosDenom)
	}

	packedAbi, err := types.ERC20KavaWrappedCosmosCoinContract.ABI.Pack(
		"", // Empty string for contract constructor
		token.Name,
		token.Symbol,
		uint8(token.Decimals), // cast to uint8 is safe because of Validate()
	)
	if err != nil {
		return types.InternalEVMAddress{}, errorsmod.Wrapf(err, "failed to pack token with details %+v", token)
	}

	data := make([]byte, len(types.ERC20KavaWrappedCosmosCoinContract.Bin)+len(packedAbi))
	copy(
		data[:len(types.ERC20KavaWrappedCosmosCoinContract.Bin)],
		types.ERC20KavaWrappedCosmosCoinContract.Bin,
	)
	copy(
		data[len(types.ERC20KavaWrappedCosmosCoinContract.Bin):],
		packedAbi,
	)

	nonce, err := k.accountKeeper.GetSequence(ctx, types.ModuleEVMAddress.Bytes())
	if err != nil {
		return types.InternalEVMAddress{}, err
	}

	contractAddr := crypto.CreateAddress(types.ModuleEVMAddress, nonce)
	_, err = k.CallEVMWithData(ctx, types.ModuleEVMAddress, nil, data)
	if err != nil {
		return types.InternalEVMAddress{}, fmt.Errorf("failed to deploy ERC20 %s (nonce=%d, data=%s): %s", token.Name, nonce, hex.EncodeToString(data), err)
	}

	return types.NewInternalEVMAddress(contractAddr), nil
}

// GetOrDeployCosmosCoinERC20Contract checks the module store for a deployed contract for the given
// token info and returns it if preset. Otherwise, it deploys and registers the contract.
func (k *Keeper) GetOrDeployCosmosCoinERC20Contract(
	ctx sdk.Context,
	tokenInfo types.AllowedCosmosCoinERC20Token,
) (types.InternalEVMAddress, error) {
	contractAddress, found := k.GetDeployedCosmosCoinContract(ctx, tokenInfo.CosmosDenom)
	if found {
		// contract has already been deployed
		return contractAddress, nil
	}

	// deploy a new contract
	contractAddress, err := k.DeployKavaWrappedCosmosCoinERC20Contract(ctx, tokenInfo)
	if err != nil {
		return contractAddress, err
	}

	// register the contract to the module store
	err = k.SetDeployedCosmosCoinContract(ctx, tokenInfo.CosmosDenom, contractAddress)

	// TODO: emit event that contract was deployed

	return contractAddress, err
}

// MintERC20 mints the given amount of an ERC20 token to an address. This is
// unchecked and should only be called after permission and enabled ERC20 checks.
func (k Keeper) MintERC20(
	ctx sdk.Context,
	contractAddr types.InternalEVMAddress,
	receiver types.InternalEVMAddress,
	amount *big.Int,
) error {
	_, err := k.CallEVM(
		ctx,
		types.ERC20MintableBurnableContract.ABI,
		types.ModuleEVMAddress,
		contractAddr,
		erc20MintMethod,
		// Mint ERC20 args
		receiver.Address,
		amount,
	)

	return err
}

// BurnERC20 burns the token amount from the initiator's balance.
func (k Keeper) BurnERC20(
	ctx sdk.Context,
	contractAddr types.InternalEVMAddress,
	initiator types.InternalEVMAddress,
	amount *big.Int,
) error {
	_, err := k.CallEVM(
		ctx,
		types.ERC20KavaWrappedCosmosCoinContract.ABI,
		types.ModuleEVMAddress,
		contractAddr,
		erc20BurnMethod,
		// Burn ERC20 args
		initiator.Address,
		amount,
	)

	return err
}

// QueryERC20BalanceOf makes a contract call to the balanceOf method of the ERC20 contract to get
// the ERC20 balance of the given account.
func (k Keeper) QueryERC20BalanceOf(
	ctx sdk.Context,
	contractAddr types.InternalEVMAddress,
	account types.InternalEVMAddress,
) (*big.Int, error) {
	res, err := k.CallEVM(
		ctx,
		types.ERC20MintableBurnableContract.ABI,
		types.ModuleEVMAddress,
		contractAddr,
		erc20BalanceOfMethod,
		// balanceOf ERC20 args
		account.Address,
	)
	if err != nil {
		return nil, err
	}

	return unpackERC20ResToBigInt(res, erc20BalanceOfMethod)
}

// QueryERC20TotalSupply makes a contract call to the totalSupply method of the ERC20 contract to
// get the total supply of the token.
func (k Keeper) QueryERC20TotalSupply(
	ctx sdk.Context,
	contractAddr types.InternalEVMAddress,
) (*big.Int, error) {
	res, err := k.CallEVM(
		ctx,
		types.ERC20KavaWrappedCosmosCoinContract.ABI,
		types.ModuleEVMAddress,
		contractAddr,
		erc20TotalSupplyMethod,
		// totalSupply takes no args
	)
	if err != nil {
		return nil, err
	}

	return unpackERC20ResToBigInt(res, erc20TotalSupplyMethod)
}

func unpackERC20ResToBigInt(res *evmtypes.MsgEthereumTxResponse, methodName string) (*big.Int, error) {
	if res.Failed() {
		if res.VmError == vm.ErrExecutionReverted.Error() {
			// Unpacks revert
			return nil, evmtypes.NewExecErrorWithReason(res.Ret)
		}

		return nil, status.Error(codes.Internal, res.VmError)
	}

	if len(res.Ret) == 0 {
		return nil, fmt.Errorf("failed to unpack method %s: expected response to be big.Int but found nil", methodName)
	}

	anyOutput, err := types.ERC20MintableBurnableContract.ABI.Unpack(methodName, res.Ret)
	if err != nil {
		return nil, fmt.Errorf(
			"failed to unpack method %v response: %w",
			methodName,
			err,
		)
	}

	if len(anyOutput) != 1 {
		return nil, fmt.Errorf(
			"invalid ERC20 %v call return outputs %v, expected %v",
			methodName,
			len(anyOutput),
			1,
		)
	}

	bal, ok := anyOutput[0].(*big.Int)
	if !ok {
		return nil, fmt.Errorf(
			"invalid ERC20 return type %T, expected %T",
			anyOutput[0],
			&big.Int{},
		)
	}

	return bal, nil
}