package base

import (
	"bytes"
	"context"
	"fmt"
	"github.com/hashicorp/go-multierror"
	"github.com/synapsecns/sanguine/core"
	"github.com/synapsecns/sanguine/ethergo/signer/wallet"
	"math/big"
	"os"
	"sync"
	"testing"
	"time"

	"github.com/Flaque/filet"
	"github.com/brianvoe/gofakeit/v6"
	"github.com/ethereum/go-ethereum"
	"github.com/ethereum/go-ethereum/accounts/abi"
	"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/types"
	"github.com/ipfs/go-log"
	"github.com/pkg/errors"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"github.com/synapsecns/sanguine/ethergo/chain"
	"github.com/synapsecns/sanguine/ethergo/chain/client"
	"github.com/synapsecns/sanguine/ethergo/contracts"
	"github.com/synapsecns/sanguine/ethergo/signer/nonce"
	"github.com/synapsecns/sanguine/ethergo/util"
	"github.com/teivah/onecontext"
	"k8s.io/apimachinery/pkg/util/wait"
)

var logger = log.Logger("backend-base-logger")

// Backend contains common functions across backends and can be used to extend a backend.
type Backend struct {
	// chain is the chain to be used by the backend
	chain.Chain
	// Manager is the nonce manager
	nonce.Manager
	// ctx is the context of the backend
	//nolint: containedctx
	ctx context.Context
	// tb contains the testing object
	t *testing.T
	// store stores the accounts
	store *InMemoryKeyStore
	// verifiedContracts is a list of verified contracts
	verifiedContracts map[common.Address]VerifiedContract
	// verificationMutex is the mutex for the verification
	verifiedMux sync.RWMutex
}

// VerifiedContract is a contract that has been verified.
type VerifiedContract struct {
	contracts.ContractType
	contracts.DeployedContract
}

// T returns the testing object.
func (b *Backend) T() *testing.T {
	return b.t
}

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

func (b *Backend) Store(key *keystore.Key) {
	b.store.Store(key)
}

func (b *Backend) GetAccount(a common.Address) *keystore.Key {
	return b.store.GetAccount(a)
}

// NewBaseBackend creates a new base backend.
//
//nolint:staticcheck
func NewBaseBackend(ctx context.Context, t *testing.T, chn chain.Chain) (*Backend, error) {
	t.Helper()

	b := &Backend{
		Chain:             chn,
		ctx:               ctx,
		t:                 t,
		Manager:           nonce.NewNonceManager(ctx, chn, chn.GetBigChainID()),
		store:             NewInMemoryKeyStore(),
		verifiedContracts: map[common.Address]VerifiedContract{},
	}

	return b, nil
}

// Client fetches an eth client fro the backend.
func (b *Backend) Client() client.EVMClient {
	return b.Chain
}

// see: https://git.io/JGsC1
// taken from geth, used to speed up tests.
const (
	VeryLightScryptN = 2
	VeryLightScryptP = 1
)

// MockAccount creates a new mock account.
// TODO: dry this up w/ mocks.
func MockAccount(t *testing.T) *keystore.Key {
	t.Helper()

	kstr := keystore.NewKeyStore(filet.TmpDir(t, ""), VeryLightScryptN, VeryLightScryptP)
	password := gofakeit.Password(true, true, true, false, false, 10)
	acct, err := kstr.NewAccount(password)
	assert.Nil(t, err)

	data, err := os.ReadFile(acct.URL.Path)
	assert.Nil(t, err)

	key, err := keystore.DecryptKey(data, password)
	assert.Nil(t, err)
	return key
}

// MockAccount creates a new mock account.
func (b *Backend) MockAccount() *keystore.Key {
	return MockAccount(b.t)
}

var logOnce sync.Once

// EnableLocalDebug enables local tx debugging. It is exported so it can be disabled
// and disabled by default to speed up the ci.
// Note: there's currently a bug causing this to fail if tenderly is disabled.
var EnableLocalDebug = os.Getenv("CI") == ""

// VerifyContract calls the contract verification hook (e.g. tenderly).
func (b *Backend) VerifyContract(contractType contracts.ContractType, contract contracts.DeployedContract) (resError error) {
	// TODO actually verify the contract against abi locally: https://pkg.go.dev/github.com/iden3/tx-forwarder/eth/contracts/verifier
	// until then we go ahead and run a code at to ensure the correct address was used, this helps avoid extremely hard to debug prob
	go func() {
		code, err := b.Client().CodeAt(b.ctx, contract.Address(), nil)
		if !errors.Is(err, context.Canceled) {
			require.Nil(b.T(), err)
			require.NotEmpty(b.T(), code, "contract of type %s (metadata %s) not found", contractType.ContractName(), contract.String())
		}
	}()
	var wg sync.WaitGroup

	// skip items on the blacklist.
	if IsVerificationBlacklisted(contractType) {
		return nil
	}

	wg.Wait()

	b.verifiedMux.Lock()
	defer b.verifiedMux.Unlock()

	b.verifiedContracts[contract.Address()] = VerifiedContract{
		ContractType:     contractType,
		DeployedContract: contract,
	}

	return errors.Wrap(resError, "error verifying contract")
}

var (
	errorSig     = []byte{0x08, 0xc3, 0x79, 0xa0} // Keccak256("Error(string)")[:4]
	abiString, _ = abi.NewType("string", "", nil)
)

// WaitForConfirmation waits for transaction confirmation.
// nolint: cyclop
func (b *Backend) WaitForConfirmation(parentCtx context.Context, transaction *types.Transaction) {
	ctx, cancel := onecontext.Merge(b.ctx, parentCtx)
	defer cancel()

	//nolint: contextcheck
	WaitForConfirmation(ctx, b.Client(), transaction, time.Millisecond*500)

	// check or an error, if there is one log it
	go func() {
		txReceipt, err := b.TransactionReceipt(b.ctx, transaction.Hash())
		if err != nil {
			logger.Warnf("could not get tx receipt: %v on tx %s", err, transaction.Hash())
			return
		}

		callMessage, err := util.TxToCall(transaction)
		if err != nil {
			logger.Warnf("could not convert tx to call: %w", err)
			return
		}

		res, err := b.CallContract(b.ctx, *callMessage, big.NewInt(0).Sub(txReceipt.BlockNumber, big.NewInt(1)))
		if err != nil {
			errMessage := fmt.Sprintf("could not call contract: %v on tx: %s", err, transaction.Hash())
			if b.RPCAddress() != "" {
				errMessage += fmt.Sprintf("\nFor more info run (before the process stops): cast run --rpc-url %s %s --trace-printer ", b.RPCAddress(), transaction.Hash())

				if core.GetEnvBool("TRACELY_ENABLED", false) {
					errMessage += b.addCastLabels(transaction, callMessage.From)
				}
			}
			logger.Error(errMessage)
			return
		}

		if bytes.Equal(res, errorSig) {
			vs, err := abi.Arguments{{Type: abiString}}.UnpackValues(res[4:])
			if err != nil {
				logger.Errorf("could not unpack revert: %w", err)
				return
			}

			//nolint: forcetypeassert
			errMessage := fmt.Sprintf("tx %s reverted: %v", transaction.Hash(), vs[0].(string))
			if b.RPCAddress() != "" {
				errMessage += fmt.Sprintf("\nFor more info run (before the process stops): cast run --rpc-url %s %s --trace-printer", b.RPCAddress(), transaction.Hash())
			}
			logger.Error(errMessage)
		}
	}()
}

// Context gets the context from the backend.
func (b *Backend) Context() context.Context {
	return b.ctx
}

// ImpersonateAccount impersonates an account.
func (b *Backend) ImpersonateAccount(_ context.Context, _ common.Address, _ func(opts *bind.TransactOpts) *types.Transaction) error {
	return errors.New("account impersonation is not implemented on this backend")
}

// ConfirmationClient waits for confirmation.
//
//go:generate go run github.com/vektra/mockery/v2 --name ConfirmationClient --output ./mocks --case=underscore
type ConfirmationClient interface {
	ethereum.TransactionReader
	ethereum.TransactionSender
	ethereum.ChainStateReader
}

// WaitForConfirmation is a helper that can be called by various inheriting funcs.
// it blocks until the transaction is confirmed.
// nolint: cyclop
func WaitForConfirmation(ctx context.Context, client ConfirmationClient, transaction *types.Transaction, timeout time.Duration) {
	// if tx is nil , we should panic here so we can see the call context
	_ = transaction.Hash()

	const debugTimeout = time.Second * 5

	start := time.Now()
	logIfShould := func(locker *sync.Once, template string, args ...interface{}) {
		if time.Since(start) > debugTimeout {
			locker.Do(func() {
				logger.Debugf(template, args...)
			})
		}
	}

	txConfirmedCtx, cancel := context.WithCancel(ctx)
	var logWaitOnce, logFetchErrOnce, logErrOnce sync.Once
	wait.UntilWithContext(txConfirmedCtx, func(ctx context.Context) {
		tx, isPending, err := client.TransactionByHash(txConfirmedCtx, transaction.Hash())
		logIfShould(&logWaitOnce, "waiting for tx %s", transaction.Hash())

		// it's possible that this transaction is impersonated. If thats the case, eth_getTransactionByHash will return an error
		// since the signature is not valid. In this case, we need to use the transaction hash to get the receipt instead, as this will
		// return the sender from the rpc rather than tryng to derive it ourselves.
		if err != nil && !errors.Is(err, ethereum.NotFound) {
			receipt, receiptErr := client.TransactionReceipt(ctx, transaction.Hash())
			if err != nil {
				err = multierror.Append(err, receiptErr)
			}

			if receipt != nil {
				if receipt.Status == types.ReceiptStatusFailed {
					rawJSON, _ := transaction.MarshalJSON()
					logger.Errorf("transaction %s with body %s reverted", transaction, string(rawJSON))
				}
				cancel()
				return
			}
		}

		// there's still an error, even with the receipt. We'll log the fetch error
		if err != nil {
			logIfShould(&logFetchErrOnce, "could not fetch transaction: %v", err)
		}

		if !isPending && tx != nil {
			receipt, err := client.TransactionReceipt(ctx, tx.Hash())
			if err != nil {
				if receipt.Status == types.ReceiptStatusFailed {
					rawJSON, _ := transaction.MarshalJSON()
					logger.Errorf("transaction %s with body %s reverted", transaction, string(rawJSON))
				}
			}

			cancel()
		} else if !isPending || time.Since(start) > debugTimeout {
			err := client.SendTransaction(ctx, transaction)
			if err != nil {
				ogErr := err
				call, err := util.TxToCall(transaction)
				if err != nil {
					logger.Errorf("could not convert tx to call: %v", err)
					return
				}

				realNonce, err := client.NonceAt(ctx, call.From, nil)
				if err != nil {
					logger.Errorf("could not get nonce: %v", err)
					return
				}

				logIfShould(&logErrOnce, "could not send transaction (from %s, account nonce %d, tx nonce: %d, tx hash: %s): %v", call.From, realNonce, transaction.Nonce(), transaction.Hash(), ogErr)
			}
		}
	}, timeout)
}

//nolint:staticcheck
var _ chain.Chain = &Backend{}

// WalletToKey converts a wallet into a storable key
// TODO: test me
func WalletToKey(tb testing.TB, wall wallet.Wallet) *keystore.Key {
	tb.Helper()

	kstr := keystore.NewKeyStore(filet.TmpDir(tb, ""), VeryLightScryptN, VeryLightScryptP)
	password := gofakeit.Password(true, true, true, false, false, 10)

	acct, err := kstr.ImportECDSA(wall.PrivateKey(), password)
	require.Nil(tb, err)

	data, err := os.ReadFile(acct.URL.Path)
	require.Nil(tb, err)

	key, err := keystore.DecryptKey(data, password)
	require.Nil(tb, err)
	return key
}