package chain

import (
	"context"
	"fmt"
	"github.com/ethereum/go-ethereum/params"
	"github.com/pkg/errors"
	"github.com/synapsecns/sanguine/ethergo/chain/chainwatcher"
	"github.com/synapsecns/sanguine/ethergo/chain/client"
	"github.com/synapsecns/sanguine/ethergo/chain/gas"
	"github.com/synapsecns/sanguine/ethergo/chain/watcher"
	"math/big"
	"sync"
)

var _ Chain = &baseChain{}

// baseChain is an extensible struct that implements chain. This is used for interacting with an underlying
// evm rpc.
type baseChain struct {
	// ctx: this is used on all non-client methods
	//nolint: containedctx
	ctx context.Context
	// EVMClient is the rpc client used to access the chain
	client.MeteredEVMClient
	// cfg is the configuration for the chain
	cfg *client.Config
	// structMux is the mutex
	structMux sync.RWMutex
	// chainConfig is the chain config
	chainConfig *params.ChainConfig
	// height watcher keeps track of the current chain tip height
	heightWatcher chainwatcher.BlockHeightWatcher
	// contractWatcher watches for events on the contract
	contractWatcher chainwatcher.ContractWatcher
	// chainID is the cached chain id
	chainID uint
	// cancel is used to close the session
	cancel context.CancelFunc
	// rpcAddress used by the chain
	rpcAddress string
	// estimator stores the gas estimator
	// Deprecated: use setter
	estimator gas.PriceEstimator
	// setter is used to set gas on a tx
	setter gas.Setter
}

func (b *baseChain) GasSetter() gas.Setter {
	return b.setter
}

// Name is the name of the chain.
// Deprecated: do not use.
func (b *baseChain) Name() string {
	return ""
}

// Config gets the config for the chain.
func (b *baseChain) Config() *client.Config {
	return b.cfg
}

// RPCAddress gets the rpc address the chain is currently connected to.
func (b *baseChain) RPCAddress() string {
	return b.rpcAddress
}

// ChainConfig gets the chain config if it's available.
func (b *baseChain) ChainConfig() *params.ChainConfig {
	b.structMux.RLock()
	defer b.structMux.RUnlock()

	return b.chainConfig
}

// Estimator gets the gas estimator.
func (b *baseChain) Estimator() gas.PriceEstimator {
	return b.estimator
}

// GetHeightWatcher gets a block height watcher.
func (b *baseChain) GetHeightWatcher() chainwatcher.BlockHeightWatcher {
	return b.heightWatcher
}

// SetChainConfig sets the chain config manually. This is used mostly for testing.
func (b *baseChain) SetChainConfig(config *params.ChainConfig) {
	b.structMux.Lock()
	defer b.structMux.Unlock()
	b.chainConfig = config
}

// NewFromMeteredClient creaates a new client from a metered evm client.
func NewFromMeteredClient(ctx context.Context, config *client.Config, meteredClient client.MeteredEVMClient) (chain Chain, err error) {
	b := baseChain{}
	b.ctx, b.cancel = context.WithCancel(ctx)
	b.cfg = config

	if len(config.RPCUrl) > 0 {
		b.rpcAddress = config.RPCUrl[0]
	}

	logger.Debugf("creating eth client %s", config.RPCUrl)

	// TODO, correctly set chain id here, only affects metrics
	b.MeteredEVMClient = meteredClient
	b.chainID = uint(config.ChainID)
	b.chainConfig = client.ConfigFromID(b.GetBigChainID())
	// initialize monitor/estimator

	b.heightWatcher = watcher.NewBlockHeightWatcher(ctx, uint64(b.chainID), b.MeteredEVMClient)
	b.contractWatcher = watcher.NewContractWatcher(ctx, &b, b.heightWatcher, b.cfg.RequiredConfirmations)
	b.estimator = gas.NewGasPriceEstimator(ctx, &b)
	b.setter = gas.NewGasSetter(ctx, &b)

	return &b, nil
}

// NewFromURL creates a new client from a url.
//
//nolint:ireturn
func NewFromURL(ctx context.Context, url string) (Chain, error) {
	tmpClient, err := client.NewClient(ctx, url)
	if err != nil {
		return nil, fmt.Errorf("could not create new client at %s: %w", url, err)
	}

	chainID, err := tmpClient.ChainID(ctx)
	if err != nil {
		return nil, fmt.Errorf("could not get chain id: %w", err)
	}

	meteredClient := client.NewMeteredClient(tmpClient, chainID, url, nil)
	return NewFromMeteredClient(ctx, &client.Config{
		RPCUrl:  []string{url},
		ChainID: int(chainID.Int64()),
	}, meteredClient)
}

// NewFromClient gets a chain from client.
func NewFromClient(ctx context.Context, config *client.Config, evmClient client.EVMClient) (chain Chain, err error) {
	rpcURL := ""
	if len(config.RPCUrl) > 0 {
		rpcURL = config.RPCUrl[0]
	}
	meteredClient := client.NewMeteredClient(evmClient, big.NewInt(0), rpcURL, config.LimiterConfig)
	return NewFromMeteredClient(ctx, config, meteredClient)
}

// New creates a new rpc client for querying an evm-based rpc server and attempts to connect to the chain.
func New(ctx context.Context, config *client.Config) (evmClient Chain, err error) {
	if len(config.RPCUrl) == 0 {
		return nil, errors.New("could not get ws url")
	}

	// RPCUrl gets the rpc url from the client
	baseClient, err := client.NewClientFromChainID(ctx, config.RPCUrl[0], big.NewInt(int64(config.ChainID)))
	if err != nil {
		return nil, fmt.Errorf("could not create pool client: %w", err)
	}

	return NewFromClient(ctx, config, baseClient)
}

// ChainName gets the chain name from the config.
func (b *baseChain) ChainName() string {
	return b.Name()
}

// GetChainID gets the cached chain id.
func (b *baseChain) GetChainID() uint {
	return b.chainID
}

// GetBigChainID gets the chain id as a big int.
func (b *baseChain) GetBigChainID() *big.Int {
	return big.NewInt(int64(b.chainID))
}

// ListenOnContract registers an event listener on a contract address
// the events emitted by the a contractAddress after confirmations (defined in the config).
func (b *baseChain) ListenOnContract(ctx context.Context, contractAddress string, eventLog chan interface{}) error {
	err := b.contractWatcher.ListenOnContract(ctx, contractAddress, eventLog)
	if err != nil {
		return fmt.Errorf("could not listen on contract: %w", err)
	}

	return nil
}