package handlers

import (
	"fmt"
	"math/big"

	sdk "github.com/cosmos/cosmos-sdk/types"
	"github.com/cosmos/cosmos-sdk/x/auth"

	"github.com/cosmos/ethermint/types"
	ethcmn "github.com/ethereum/go-ethereum/common"

	ethtypes "github.com/ethereum/go-ethereum/core/types"
)

const (
	// TODO: Ported from the SDK and may have a different context/value for
	// Ethermint.
	verifySigCost = 100
)

// internalAnteHandler reflects a function signature an internal ante handler
// must implementing. Internal ante handlers will be dependant upon the
// transaction type.
type internalAnteHandler func(
	sdkCtx sdk.Context, tx sdk.Tx, am auth.AccountMapper,
) (newCtx sdk.Context, res sdk.Result, abort bool)

// AnteHandler handles Ethereum transactions and passes SDK transactions to the
// embeddedAnteHandler if it's an Ethermint transaction. The ante handler gets
// invoked after the BaseApp performs the runTx. At this point, the transaction
// should be properly decoded via the TxDecoder and should be of a proper type,
// Transaction or EmbeddedTx.
func AnteHandler(am auth.AccountMapper) sdk.AnteHandler {
	return func(sdkCtx sdk.Context, tx sdk.Tx) (newCtx sdk.Context, res sdk.Result, abort bool) {
		var (
			gasLimit int64
			handler  internalAnteHandler
		)

		switch tx := tx.(type) {
		case types.Transaction:
			gasLimit = int64(tx.Data.GasLimit)
			handler = handleEthTx
		case types.EmbeddedTx:
			gasLimit = tx.Fee.Gas
			handler = handleEmbeddedTx
		default:
			return sdkCtx, sdk.ErrInternal(fmt.Sprintf("invalid transaction: %T", tx)).Result(), true
		}

		newCtx = sdkCtx.WithGasMeter(sdk.NewGasMeter(gasLimit))

		// AnteHandlers must have their own defer/recover in order for the
		// BaseApp to know how much gas was used! This is because the GasMeter
		// is created in the AnteHandler, but if it panics the context won't be
		// set properly in runTx's recover.
		defer func() {
			if r := recover(); r != nil {
				switch rType := r.(type) {
				case sdk.ErrorOutOfGas:
					log := fmt.Sprintf("out of gas in location: %v", rType.Descriptor)
					res = sdk.ErrOutOfGas(log).Result()
					res.GasWanted = gasLimit
					res.GasUsed = newCtx.GasMeter().GasConsumed()
					abort = true
				default:
					panic(r)
				}
			}
		}()

		return handler(newCtx, tx, am)
	}
}

// handleEthTx implements an ante handler for an Ethereum transaction. It
// validates the signature and if valid returns an OK result.
//
// TODO: Do we need to do any further validation or account manipulation
// (e.g. increment nonce)?
func handleEthTx(sdkCtx sdk.Context, tx sdk.Tx, am auth.AccountMapper) (sdk.Context, sdk.Result, bool) {
	ethTx, ok := tx.(types.Transaction)
	if !ok {
		return sdkCtx, sdk.ErrInternal(fmt.Sprintf("invalid transaction: %T", tx)).Result(), true
	}

	// the SDK chainID is a string representation of integer
	chainID, ok := new(big.Int).SetString(sdkCtx.ChainID(), 10)
	if !ok {
		// TODO: ErrInternal may not be correct error to throw here?
		return sdkCtx, sdk.ErrInternal(fmt.Sprintf("invalid chainID: %s", sdkCtx.ChainID())).Result(), true
	}

	// validate signature
	gethTx := ethTx.ConvertTx(chainID)
	signer := ethtypes.NewEIP155Signer(chainID)

	_, err := signer.Sender(&gethTx)
	if err != nil {
		return sdkCtx, sdk.ErrUnauthorized("signature verification failed").Result(), true
	}

	return sdkCtx, sdk.Result{GasWanted: int64(ethTx.Data.GasLimit)}, false
}

// handleEmbeddedTx implements an ante handler for an SDK transaction. It
// validates the signature and if valid returns an OK result.
func handleEmbeddedTx(sdkCtx sdk.Context, tx sdk.Tx, am auth.AccountMapper) (sdk.Context, sdk.Result, bool) {
	etx, ok := tx.(types.EmbeddedTx)
	if !ok {
		return sdkCtx, sdk.ErrInternal(fmt.Sprintf("invalid transaction: %T", tx)).Result(), true
	}

	if err := validateEmbeddedTxBasic(etx); err != nil {
		return sdkCtx, err.Result(), true
	}

	signerAddrs := etx.GetRequiredSigners()
	signerAccs := make([]auth.Account, len(signerAddrs))

	// validate signatures
	for i, sig := range etx.Signatures {
		signer := ethcmn.BytesToAddress(signerAddrs[i].Bytes())

		signerAcc, err := validateSignature(sdkCtx, etx, signer, sig, am)
		if err.Code() != sdk.CodeOK {
			return sdkCtx, err.Result(), false
		}

		// TODO: Fees!

		am.SetAccount(sdkCtx, signerAcc)
		signerAccs[i] = signerAcc
	}

	newCtx := auth.WithSigners(sdkCtx, signerAccs)

	return newCtx, sdk.Result{GasWanted: etx.Fee.Gas}, false
}

// validateEmbeddedTxBasic validates an EmbeddedTx based on things that don't
// depend on the context.
func validateEmbeddedTxBasic(etx types.EmbeddedTx) (err sdk.Error) {
	sigs := etx.Signatures
	if len(sigs) == 0 {
		return sdk.ErrUnauthorized("transaction missing signatures")
	}

	signerAddrs := etx.GetRequiredSigners()
	if len(sigs) != len(signerAddrs) {
		return sdk.ErrUnauthorized("invalid number of transaction signers")
	}

	return nil
}

func validateSignature(
	sdkCtx sdk.Context, etx types.EmbeddedTx, signer ethcmn.Address,
	sig []byte, am auth.AccountMapper,
) (acc auth.Account, sdkErr sdk.Error) {

	chainID := sdkCtx.ChainID()

	acc = am.GetAccount(sdkCtx, signer.Bytes())
	if acc == nil {
		return nil, sdk.ErrUnknownAddress(fmt.Sprintf("no account with address %s found", signer))
	}

	signEtx := types.EmbeddedTxSign{
		ChainID:       chainID,
		AccountNumber: acc.GetAccountNumber(),
		Sequence:      acc.GetSequence(),
		Messages:      etx.Messages,
		Fee:           etx.Fee,
	}

	err := acc.SetSequence(signEtx.Sequence + 1)
	if err != nil {
		return nil, sdk.ErrInternal(err.Error())
	}

	signBytes, err := signEtx.Bytes()
	if err != nil {
		return nil, sdk.ErrInternal(err.Error())
	}

	// consume gas for signature verification
	sdkCtx.GasMeter().ConsumeGas(verifySigCost, "ante verify")

	if err := types.ValidateSigner(signBytes, sig, signer); err != nil {
		return nil, sdk.ErrUnauthorized(err.Error())
	}

	return
}