package eth

import (
	"context"
	"fmt"
	"math/big"
	"time"

	"github.com/ethereum/go-ethereum/accounts"
	"github.com/ethereum/go-ethereum/accounts/abi/bind"
	ethKeystore "github.com/ethereum/go-ethereum/accounts/keystore"
	ethCommon "github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/core/types"
	"github.com/ethereum/go-ethereum/ethclient"
	"github.com/hermeznetwork/hermez-node/common"
	HEZ "github.com/hermeznetwork/hermez-node/eth/contracts/tokenHEZ"
	"github.com/hermeznetwork/hermez-node/log"
	"github.com/hermeznetwork/tracerr"
)

// ERC20Consts are the constants defined in a particular ERC20 Token instance
type ERC20Consts struct {
	Name     string
	Symbol   string
	Decimals uint64
}

// EthereumInterface is the interface to Ethereum
type EthereumInterface interface {
	EthLastBlock() (int64, error)
	// EthHeaderByNumber(context.Context, *big.Int) (*types.Header, error)
	EthBlockByNumber(context.Context, int64) (*common.Block, error)
	EthAddress() (*ethCommon.Address, error)
	EthTransactionReceipt(context.Context, ethCommon.Hash) (*types.Receipt, error)

	EthERC20Consts(ethCommon.Address) (*ERC20Consts, error)
}

var (
	// ErrAccountNil is used when the calls can not be made because the account is nil
	ErrAccountNil = fmt.Errorf("Authorized calls can't be made when the account is nil")
	// ErrReceiptStatusFailed is used when receiving a failed transaction
	ErrReceiptStatusFailed = fmt.Errorf("receipt status is failed")
	// ErrReceiptNotReceived is used when unable to retrieve a transaction
	ErrReceiptNotReceived = fmt.Errorf("receipt not available")
	// ErrBlockHashMismatchEvent is used when there's a block hash mismatch
	// beetween different events of the same block
	ErrBlockHashMismatchEvent = fmt.Errorf("block hash mismatch in event log")
)

const (
	errStrDeploy      = "deployment of %s failed: %w"
	errStrWaitReceipt = "wait receipt of %s deploy failed: %w"

	// default values
	defaultCallGasLimit        = 300000
	defaultDeployGasLimit      = 1000000
	defaultGasPriceDiv         = 100
	defaultReceiptTimeout      = 60
	defaultIntervalReceiptLoop = 200
)

// EthereumConfig defines the configuration parameters of the EthereumClient
type EthereumConfig struct {
	CallGasLimit        uint64
	DeployGasLimit      uint64
	GasPriceDiv         uint64
	ReceiptTimeout      time.Duration
	IntervalReceiptLoop time.Duration
}

// EthereumClient is an ethereum client to call Smart Contract methods and check blockchain information.
type EthereumClient struct {
	client         *ethclient.Client
	account        *accounts.Account
	ks             *ethKeystore.KeyStore
	ReceiptTimeout time.Duration
	config         *EthereumConfig
	opts           *bind.CallOpts
}

// NewEthereumClient creates a EthereumClient instance.  The account is not mandatory (it can
// be nil).  If the account is nil, CallAuth will fail with ErrAccountNil.
func NewEthereumClient(client *ethclient.Client, account *accounts.Account, ks *ethKeystore.KeyStore, config *EthereumConfig) *EthereumClient {
	if config == nil {
		config = &EthereumConfig{
			CallGasLimit:        defaultCallGasLimit,
			DeployGasLimit:      defaultDeployGasLimit,
			GasPriceDiv:         defaultGasPriceDiv,
			ReceiptTimeout:      defaultReceiptTimeout,
			IntervalReceiptLoop: defaultIntervalReceiptLoop,
		}
	}
	return &EthereumClient{
		client:         client,
		account:        account,
		ks:             ks,
		ReceiptTimeout: config.ReceiptTimeout * time.Second,
		config:         config,
		opts:           newCallOpts(),
	}
}

// BalanceAt retieves information about the default account
func (c *EthereumClient) BalanceAt(addr ethCommon.Address) (*big.Int, error) {
	return c.client.BalanceAt(context.TODO(), addr, nil)
}

// Account returns the underlying ethereum account
func (c *EthereumClient) Account() *accounts.Account {
	return c.account
}

// EthAddress returns the ethereum address of the account loaded into the EthereumClient
func (c *EthereumClient) EthAddress() (*ethCommon.Address, error) {
	if c.account == nil {
		return nil, tracerr.Wrap(ErrAccountNil)
	}
	return &c.account.Address, nil
}

// CallAuth performs a Smart Contract method call that requires authorization.
// This call requires a valid account with Ether that can be spend during the
// call.
func (c *EthereumClient) CallAuth(gasLimit uint64,
	fn func(*ethclient.Client, *bind.TransactOpts) (*types.Transaction, error)) (*types.Transaction, error) {
	if c.account == nil {
		return nil, tracerr.Wrap(ErrAccountNil)
	}

	gasPrice, err := c.client.SuggestGasPrice(context.Background())
	if err != nil {
		return nil, tracerr.Wrap(err)
	}
	inc := new(big.Int).Set(gasPrice)
	inc.Div(inc, new(big.Int).SetUint64(c.config.GasPriceDiv))
	gasPrice.Add(gasPrice, inc)
	log.Debugw("Transaction metadata", "gasPrice", gasPrice)

	auth, err := bind.NewKeyStoreTransactor(c.ks, *c.account)
	if err != nil {
		return nil, tracerr.Wrap(err)
	}
	auth.Value = big.NewInt(0) // in wei
	if gasLimit == 0 {
		auth.GasLimit = c.config.CallGasLimit // in units
	} else {
		auth.GasLimit = gasLimit // in units
	}
	auth.GasPrice = gasPrice

	tx, err := fn(c.client, auth)
	if tx != nil {
		log.Debugw("Transaction", "tx", tx.Hash().Hex(), "nonce", tx.Nonce())
	}
	return tx, tracerr.Wrap(err)
}

// ContractData contains the contract data
type ContractData struct {
	Address ethCommon.Address
	Tx      *types.Transaction
	Receipt *types.Receipt
}

// Deploy a smart contract.  `name` is used to log deployment information.  fn
// is a wrapper to the deploy function generated by abigen.  In case of error,
// the returned `ContractData` may have some parameters filled depending on the
// kind of error that occurred.
func (c *EthereumClient) Deploy(name string,
	fn func(c *ethclient.Client, auth *bind.TransactOpts) (ethCommon.Address, *types.Transaction, interface{}, error)) (ContractData, error) {
	var contractData ContractData
	log.Infow("Deploying", "contract", name)
	tx, err := c.CallAuth(
		c.config.DeployGasLimit,
		func(client *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
			addr, tx, _, err := fn(client, auth)
			if err != nil {
				return nil, tracerr.Wrap(err)
			}
			contractData.Address = addr
			return tx, nil
		},
	)
	if err != nil {
		return contractData, tracerr.Wrap(fmt.Errorf(errStrDeploy, name, err))
	}
	log.Infow("Waiting receipt", "tx", tx.Hash().Hex(), "contract", name)
	contractData.Tx = tx
	receipt, err := c.WaitReceipt(tx)
	if err != nil {
		return contractData, tracerr.Wrap(fmt.Errorf(errStrWaitReceipt, name, err))
	}
	contractData.Receipt = receipt
	return contractData, nil
}

// Call performs a read only Smart Contract method call.
func (c *EthereumClient) Call(fn func(*ethclient.Client) error) error {
	return fn(c.client)
}

// WaitReceipt will block until a transaction is confirmed.  Internally it
// polls the state every 200 milliseconds.
func (c *EthereumClient) WaitReceipt(tx *types.Transaction) (*types.Receipt, error) {
	return c.waitReceipt(context.TODO(), tx, c.ReceiptTimeout)
}

// GetReceipt will check if a transaction is confirmed and return
// immediately, waiting at most 1 second and returning error if the transaction
// is still pending.
func (c *EthereumClient) GetReceipt(tx *types.Transaction) (*types.Receipt, error) {
	ctx, cancel := context.WithTimeout(context.TODO(), 1*time.Second)
	defer cancel()
	return c.waitReceipt(ctx, tx, 0)
}

// EthTransactionReceipt returns the transaction receipt of the given txHash
func (c *EthereumClient) EthTransactionReceipt(ctx context.Context, txHash ethCommon.Hash) (*types.Receipt, error) {
	return c.client.TransactionReceipt(ctx, txHash)
}

func (c *EthereumClient) waitReceipt(ctx context.Context, tx *types.Transaction, timeout time.Duration) (*types.Receipt, error) {
	var err error
	var receipt *types.Receipt

	txHash := tx.Hash()
	log.Debugw("Waiting for receipt", "tx", txHash.Hex())

	start := time.Now()
	for {
		receipt, err = c.client.TransactionReceipt(ctx, txHash)
		if receipt != nil || time.Since(start) >= timeout {
			break
		}
		time.Sleep(c.config.IntervalReceiptLoop * time.Millisecond)
	}

	if receipt != nil && receipt.Status == types.ReceiptStatusFailed {
		log.Errorw("Failed transaction", "tx", txHash.Hex())
		return receipt, tracerr.Wrap(ErrReceiptStatusFailed)
	}

	if receipt == nil {
		log.Debugw("Pendingtransaction / Wait receipt timeout", "tx", txHash.Hex(), "lasterr", err)
		return receipt, tracerr.Wrap(ErrReceiptNotReceived)
	}
	log.Debugw("Successful transaction", "tx", txHash.Hex())

	return receipt, tracerr.Wrap(err)
}

// EthLastBlock returns the last block number in the blockchain
func (c *EthereumClient) EthLastBlock() (int64, error) {
	ctx, cancel := context.WithTimeout(context.TODO(), 1*time.Second)
	defer cancel()
	header, err := c.client.HeaderByNumber(ctx, nil)
	if err != nil {
		return 0, tracerr.Wrap(err)
	}
	return header.Number.Int64(), nil
}

// EthHeaderByNumber internally calls ethclient.Client HeaderByNumber
// func (c *EthereumClient) EthHeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error) {
// 	return c.client.HeaderByNumber(ctx, number)
// }

// EthBlockByNumber internally calls ethclient.Client BlockByNumber and returns
// *common.Block.  If number == -1, the latests known block is returned.
func (c *EthereumClient) EthBlockByNumber(ctx context.Context, number int64) (*common.Block, error) {
	blockNum := big.NewInt(number)
	if number == -1 {
		blockNum = nil
	}
	block, err := c.client.BlockByNumber(ctx, blockNum)
	if err != nil {
		return nil, tracerr.Wrap(err)
	}
	b := &common.Block{
		Num:        block.Number().Int64(),
		Timestamp:  time.Unix(int64(block.Time()), 0),
		ParentHash: block.ParentHash(),
		Hash:       block.Hash(),
	}
	return b, nil
}

// EthERC20Consts returns the constants defined for a particular ERC20 Token instance.
func (c *EthereumClient) EthERC20Consts(tokenAddress ethCommon.Address) (*ERC20Consts, error) {
	// We use the HEZ token smart contract interfacehere because it's an
	// ERC20, which allows us to access the standard ERC20 constants.
	instance, err := HEZ.NewHEZ(tokenAddress, c.client)
	if err != nil {
		return nil, tracerr.Wrap(err)
	}
	name, err := instance.Name(c.opts)
	if err != nil {
		return nil, tracerr.Wrap(err)
	}

	symbol, err := instance.Symbol(c.opts)
	if err != nil {
		return nil, tracerr.Wrap(err)
	}

	decimals, err := instance.Decimals(c.opts)
	if err != nil {
		return nil, tracerr.Wrap(err)
	}
	return &ERC20Consts{
		Name:     name,
		Symbol:   symbol,
		Decimals: uint64(decimals),
	}, nil
}

// Client returns the internal ethclient.Client
func (c *EthereumClient) Client() *ethclient.Client {
	return c.client
}

// newCallOpts returns a CallOpts to be used in ethereum calls with a non-zero
// From address.  This is a workaround for a bug in ethereumjs-vm that shows up
// in ganache: https://github.com/hermeznetwork/hermez-node/issues/317
func newCallOpts() *bind.CallOpts {
	return &bind.CallOpts{
		From: ethCommon.HexToAddress("0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f"),
	}
}