package simulated

import (
	"context"
	"errors"
	"math/big"
	"testing"
	"time"

	"github.com/ethereum/go-ethereum/accounts/abi/bind"
	"github.com/ethereum/go-ethereum/accounts/keystore"
	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/core"
	"github.com/ethereum/go-ethereum/core/types"
	"github.com/ethereum/go-ethereum/eth/gasprice"
	"github.com/ethereum/go-ethereum/params"
	"github.com/ipfs/go-log"
	"github.com/lmittmann/w3/w3types"
	"github.com/stretchr/testify/assert"
	commonBackend "github.com/synapsecns/sanguine/ethergo/backends"
	"github.com/synapsecns/sanguine/ethergo/backends/base"
	"github.com/synapsecns/sanguine/ethergo/backends/simulated/multibackend"
	"github.com/synapsecns/sanguine/ethergo/chain"
	"github.com/synapsecns/sanguine/ethergo/chain/client"
	"github.com/synapsecns/sanguine/ethergo/signer/nonce"
	"github.com/teivah/onecontext"
)

var logger = log.Logger("simulated-logger")

// Backend is the simulated backend.
type Backend struct {
	t *testing.T
	// base backend is the base backend
	*base.Backend
	// backend handles commits
	simulatedBackend *multibackend.SimulatedBackend
	// faucetAddr is the address funde at genesis
	faucetAddr *keystore.Key
	// gasLimit is the block gas limit
	gasLimit uint64
	// chainConfig is the chainConfig for this chain
	chainConfig *params.ChainConfig
}

func (s *Backend) BatchWithContext(_ context.Context, _ ...w3types.Caller) error {
	return errors.New("rpc calls not supported on simulated backend")
}

// Signer gets the signer for the backend.
func (s *Backend) Signer() types.Signer {
	latestBlock, err := s.BlockByNumber(s.Context(), nil)
	assert.Nil(s.T(), err)

	return types.MakeSigner(s.chainConfig, latestBlock.Number(), latestBlock.Time())
}

// T gets the testing object for the backend.
func (s *Backend) T() *testing.T {
	s.t.Helper()
	return s.t
}

// SetT sets the testing object on the backend.
func (s *Backend) SetT(t *testing.T) {
	t.Helper()
	s.t = t
}

// BackendName is the name of the simulated backend.
const BackendName = "SimulatedBackend"

// BackendName gets the name of SimulatedBackend.
func (s *Backend) BackendName() string {
	return BackendName
}

// Commit commits pending txes to the backend. Does not thing if no txes are pending.
func (s *Backend) Commit() {
	s.simulatedBackend.Commit()
}

// EmptyBlock mines an empty block.
func (s *Backend) EmptyBlock(blockTime time.Time) {
	s.simulatedBackend.EmptyBlock(blockTime)
}

// AdjustTime adjusts the time of the most recent block.
func (s *Backend) AdjustTime(adjustment time.Duration) error {
	//nolint: wrapcheck
	return s.simulatedBackend.AdjustTime(adjustment)
}

// getFaucetTxContext gets a signed transaction from the faucet address.
func (s *Backend) getFaucetTxContext(ctx context.Context) *bind.TransactOpts {
	auth, err := bind.NewKeyedTransactorWithChainID(s.faucetAddr.PrivateKey, s.Chain.GetBigChainID())
	assert.Nil(s.T(), err)

	//nolint: ineffassign
	gasPrice, err := s.SuggestGasPrice(ctx)
	assert.Nil(s.T(), err)

	// standard eth value tx price
	auth.GasLimit = 21000
	auth.GasPrice = gasPrice

	return auth
}

// faucetSignTx will sign a tx with the faucet addr.
func (s *Backend) faucetSignTx(tx *types.Transaction) *types.Transaction {
	tx, err := s.SignTx(tx, s.Signer(), s.faucetAddr.PrivateKey)
	assert.Nil(s.T(), err)
	return tx
}

// ChainConfig gets the chain config for the simulated backend.
func (s *Backend) ChainConfig() *params.ChainConfig {
	return s.chainConfig
}

// GetFundedAccount returns an account with the requested balance. (Note: if genesis acount has an insufficient
// balance, blocks may be mined here).
func (s *Backend) GetFundedAccount(ctx context.Context, requestBalance *big.Int) *keystore.Key {
	key := s.MockAccount()

	s.Store(key)

	s.FundAccount(ctx, key.Address, *requestBalance)

	return key
}

// FundAccount fundsa  new account.
func (s *Backend) FundAccount(ctx context.Context, address common.Address, amount big.Int) {
	rawTx := s.getFaucetTxContext(ctx)

	tx := s.faucetSignTx(types.NewTx(&types.LegacyTx{
		To:       &address,
		Value:    &amount,
		Gas:      rawTx.GasLimit,
		GasPrice: rawTx.GasPrice,
	}))

	assert.Nil(s.T(), s.SendTransaction(ctx, tx))
	s.Commit()

	// wait for tx confirmation
	s.WaitForConfirmation(ctx, tx)
}

// SendTransaction sends a transaction and commits it mining a new block
// in cases where you would not like to commit automatically, you can run
// s.Client().SendTransaction().
func (s *Backend) SendTransaction(ctx context.Context, tx *types.Transaction) error {
	err := s.Client().SendTransaction(ctx, tx)
	s.Commit()
	//nolint: wrapcheck
	return err
}

// GetTxContext gets a signed transaction from full backend.
func (s *Backend) GetTxContext(ctx context.Context, address *common.Address) (res commonBackend.AuthType) {
	ctx, cancel := onecontext.Merge(ctx, s.Context())
	defer cancel()

	var acct *keystore.Key
	// TODO handle storing accounts to conform to get tx context
	if address != nil {
		acct = s.GetAccount(*address)
		if acct == nil {
			s.T().Errorf("could not get account %s", address.String())
			return res
		}
	} else {
		acct = s.GetFundedAccount(ctx, big.NewInt(0).Mul(big.NewInt(params.Ether), big.NewInt(10)))
		s.Store(acct)
	}

	auth, err := s.NewKeyedTransactorFromKey(acct.PrivateKey)
	assert.Nil(s.T(), err)

	gasBlock, err := s.BlockByNumber(ctx, nil)
	assert.Nil(s.T(), err)

	//nolint: ineffassign
	err = s.Chain.GasSetter().SetGasFee(ctx, auth, gasBlock.NumberU64(), gasprice.DefaultMaxPrice)
	assert.Nil(s.T(), err)

	return commonBackend.AuthType{
		TransactOpts: auth,
		PrivateKey:   acct.PrivateKey,
	}
}

// BlockGasLimit is the gas limit used for the block.
const BlockGasLimit = uint64(91712388)

// NewSimulatedBackend gets a simulated backend from geth for testing and creates an account
// with balance. ChainID is 1337.
func NewSimulatedBackend(ctx context.Context, t *testing.T) *Backend {
	t.Helper()
	return NewSimulatedBackendWithChainID(ctx, t, params.AllEthashProtocolChanges.ChainID)
}

// NewSimulatedBackendWithChainID gets a simulated backend from geth for testing and creates an account
// with balance.
func NewSimulatedBackendWithChainID(ctx context.Context, t *testing.T, chainID *big.Int) *Backend {
	t.Helper()
	return NewSimulatedBackendWithConfig(ctx, t, multibackend.NewConfigWithChainID(chainID))
}

// NewSimulatedBackendWithConfig gets a simulated backend from geth for testing and creates an account
// with balance.
func NewSimulatedBackendWithConfig(ctx context.Context, t *testing.T, config *params.ChainConfig) *Backend {
	t.Helper()
	// 100 million ether
	balance := big.NewInt(0).Mul(big.NewInt(params.Ether), big.NewInt(100000000))
	key := base.MockAccount(t)

	genesisAlloc := map[common.Address]core.GenesisAccount{
		key.Address: {
			Balance: balance,
		},
	}

	simulatedBackend := multibackend.NewSimulatedBackendWithConfig(genesisAlloc, BlockGasLimit, config)
	baseClient := Client{simulatedBackend}

	chn, err := chain.NewFromClient(ctx, &client.Config{
		RPCUrl:  []string{""},
		ChainID: int(config.ChainID.Uint64()),
	}, baseClient)
	chn.SetChainConfig(config)
	assert.Nil(t, err)

	baseBackend, err := base.NewBaseBackend(ctx, t, chn)
	assert.Nil(t, err)

	backend := Backend{
		Backend:          baseBackend,
		simulatedBackend: simulatedBackend,
		chainConfig:      config,
	}
	backend.SetT(t)
	backend.Manager = nonce.NewNonceManager(ctx, &backend, backend.GetBigChainID())
	backend.faucetAddr = key
	backend.gasLimit = BlockGasLimit

	return &backend
}

var _ commonBackend.SimulatedTestBackend = &Backend{}