package gas

import (
	"context"
	"fmt"
	"github.com/ethereum/go-ethereum/eth/gasprice"
	"github.com/ethereum/go-ethereum/params"
	"github.com/ipfs/go-log"
	"github.com/synapsecns/sanguine/ethergo/chain/gas/backend"
	"github.com/synapsecns/sanguine/ethergo/chain/gas/londinium"
	"github.com/teivah/onecontext"
	"math/big"
)

var logger = log.Logger("synapse-gas")

// DefaultGasPriceEstimate estimates the default gas price.
// This is exposed as a variable so it can be modified by tests, but will be removed in a future version.
var DefaultGasPriceEstimate = big.NewInt(int64(params.GWei))

// PriceEstimator handles estimating gas prices for type 0 txes on evm based chains. The logic is entirely derived from eth's
// SuggestPrice() logic (see: https://git.io/JZFlE), but designed to be deterministic from a given block height
// (with older block gas price estimations garbage collected).
// This is needed because, unlike in cases  with a single signer gas prices need to be estimated deterministically.
// This is done by deriving the price at a given height (taken from the event log in cases where an event is being handles)
// and then following eth's estimation logic on the last n blocks. All clients arrive at the same price every time.
// The client is responsible for determining the height they wish to get the gas price at and coordinating this if
// the event log is cross chain.
type PriceEstimator interface {
	// EstimateGasPrice estimates a gas price deterministically at a given height
	EstimateGasPrice(ctx context.Context, height uint64, config gasprice.Config) (*big.Int, error)
}

type gasFeeEstimatorImpl struct {
	//nolint: containedctx
	ctx           context.Context
	oracleBackend londinium.OracleBackend
}

// NewGasPriceEstimator creates a gas estimator for v0 transactions.
func NewGasPriceEstimator(ctx context.Context, oracle backend.OracleBackendChain) (g PriceEstimator) {
	g = &gasFeeEstimatorImpl{ctx: ctx, oracleBackend: londinium.NewOracleBackendFromChain(oracle)}
	return g
}

// EstimateGasPrice deterministically determines the gas price at a given height.
func (g *gasFeeEstimatorImpl) EstimateGasPrice(ctx context.Context, height uint64, config gasprice.Config) (gasPrice *big.Int, err error) {
	// copy this to avoid mutating the default value
	defaultEstimate, _ := big.NewInt(0).SetString(DefaultGasPriceEstimate.String(), 10)

	if height < uint64(config.Blocks) {
		return defaultEstimate, nil
	}
	ctx, cancel := onecontext.Merge(g.ctx, ctx)
	defer cancel()

	oracleBackend := londinium.NewOracleBackendFromHeight(height, g.oracleBackend)
	gasOracle := londinium.NewOracle(oracleBackend, londinium.ToLondiniumConfig(config))
	price, err := gasOracle.SuggestPrice(ctx)
	if err != nil {
		logger.Warn(fmt.Errorf("could not estimate gas price: %w", err))
		return defaultEstimate, nil
	}

	return price, nil
}

var _ PriceEstimator = &gasFeeEstimatorImpl{}