// Package chain defines the interface for interacting with a blockchain.
package chain

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

	"github.com/ethereum/go-ethereum/accounts/abi/bind"
	"github.com/ethereum/go-ethereum/core/types"
	"github.com/synapsecns/sanguine/core"
	"github.com/synapsecns/sanguine/ethergo/client"
	"github.com/synapsecns/sanguine/ethergo/listener"
	"github.com/synapsecns/sanguine/ethergo/submitter"
	"github.com/synapsecns/sanguine/services/rfq/contracts/fastbridge"
	"github.com/synapsecns/sanguine/services/rfq/relayer/relconfig"
	"github.com/synapsecns/sanguine/services/rfq/relayer/reldb"
	"github.com/synapsecns/sanguine/services/rfq/util"
)

// Chain is a chain helper for relayer.
// lowercase fields are private, uppercase are public.
// the plan is to move this out of relayer which is when this distinction will matter.
type Chain struct {
	ChainID       uint32
	Bridge        *fastbridge.FastBridgeRef
	Client        client.EVM
	Confirmations uint64
	listener      listener.ContractListener
	submitter     submitter.TransactionSubmitter
}

// NewChain creates a new chain.
func NewChain(ctx context.Context, cfg relconfig.Config, chainClient client.EVM, chainListener listener.ContractListener, ts submitter.TransactionSubmitter) (*Chain, error) {
	chainID, err := chainClient.ChainID(ctx)
	if err != nil {
		return nil, fmt.Errorf("could not get chain id: %w", err)
	}
	addr, err := cfg.GetRFQAddress(int(chainID.Int64()))
	if err != nil {
		return nil, fmt.Errorf("could not get rfq address: %w", err)
	}
	bridge, err := fastbridge.NewFastBridgeRef(addr, chainClient)
	if err != nil {
		return nil, fmt.Errorf("could not create bridge contract: %w", err)
	}
	confirmations, err := cfg.GetConfirmations(int(chainID.Int64()))
	if err != nil {
		return nil, fmt.Errorf("could not get confirmations: %w", err)
	}
	return &Chain{
		ChainID:       uint32(chainID.Int64()),
		Bridge:        bridge,
		Client:        chainClient,
		Confirmations: confirmations,
		listener:      chainListener,
		submitter:     ts,
	}, nil
}

// SubmitTransaction submits a transaction to the chain.
func (c Chain) SubmitTransaction(ctx context.Context, call submitter.ContractCallType) (nonce uint64, _ error) {
	//nolint: wrapcheck
	return c.submitter.SubmitTransaction(ctx, big.NewInt(int64(c.ChainID)), call)
}

// LatestBlock returns the latest block.
func (c Chain) LatestBlock() uint64 {
	return c.listener.LatestBlock()
}

// SubmitRelay submits a relay transaction to the destination chain after evaluating gas amount.
func (c Chain) SubmitRelay(ctx context.Context, request reldb.QuoteRequest) (uint64, *big.Int, error) {
	gasAmount := big.NewInt(0)
	var err error

	// Check to see if ETH should be sent to destination
	if util.IsGasToken(request.Transaction.DestToken) {
		gasAmount = request.Transaction.DestAmount
	} else if request.Transaction.SendChainGas {
		gasAmount, err = c.Bridge.ChainGasAmount(&bind.CallOpts{Context: ctx})
		if err != nil {
			return 0, nil, fmt.Errorf("could not get chain gas amount: %w", err)
		}
	}

	nonce, err := c.SubmitTransaction(ctx, func(transactor *bind.TransactOpts) (tx *types.Transaction, err error) {
		transactor.Value = core.CopyBigInt(gasAmount)

		tx, err = c.Bridge.Relay(transactor, request.RawRequest)
		if err != nil {
			return nil, fmt.Errorf("could not relay: %w", err)
		}

		return tx, nil
	})
	if err != nil {
		return 0, nil, fmt.Errorf("could not submit transaction: %w", err)
	}

	return nonce, gasAmount, nil
}