// Package evm TODO description
package evm

import (
	"context"
	"fmt"
	"github.com/ethereum/go-ethereum/common"
	"github.com/synapsecns/sanguine/agents/config"
	"github.com/synapsecns/sanguine/agents/domains"
	"github.com/synapsecns/sanguine/ethergo/chain"
)

type evmClient struct {
	// name is the name of the evm client
	name string
	// config is the config of the evm client
	config config.DomainConfig
	// client uses the old synapse client for now
	//nolint: staticcheck
	client chain.Chain
	// origin contains the origin contract
	origin domains.OriginContract
	// summit contains the summit contract
	summit domains.SummitContract
	// destination contains the destination contract
	destination domains.DestinationContract
	// lightManager contains the lightManager contract
	lightManager domains.LightManagerContract
	// bondingManager contains the bondingManager contract
	bondingManager domains.BondingManagerContract
	// lightInbox contains the lightInbox contract
	lightInbox domains.LightInboxContract
	// inbox contains the inbox contract
	inbox domains.InboxContract
}

var _ domains.DomainClient = &evmClient{}

// NewEVM creates a new evm client.
//
//nolint:nestif
func NewEVM(ctx context.Context, name string, domain config.DomainConfig, chainRPCURL string) (domains.DomainClient, error) {
	underlyingClient, err := chain.NewFromURL(ctx, chainRPCURL)
	if err != nil {
		return nil, fmt.Errorf("could not get evm: %w", err)
	}

	boundOrigin, err := NewOriginContract(ctx, underlyingClient, common.HexToAddress(domain.OriginAddress))
	if err != nil {
		return nil, fmt.Errorf("could not bind origin contract: %w", err)
	}

	boundDestination, err := NewDestinationContract(ctx, underlyingClient, common.HexToAddress(domain.DestinationAddress))
	if err != nil {
		return nil, fmt.Errorf("could not bind destination contract: %w", err)
	}

	var boundSummit domains.SummitContract
	var boundBondingManager domains.BondingManagerContract
	var boundInbox domains.InboxContract
	var boundLightManager domains.LightManagerContract
	var boundLightInbox domains.LightInboxContract
	if domain.SummitAddress == "" {
		boundLightManager, err = NewLightManagerContract(ctx, underlyingClient, common.HexToAddress(domain.LightManagerAddress))
		if err != nil {
			return nil, fmt.Errorf("could not bind light manager contract: %w", err)
		}
		boundLightInbox, err = NewLightInboxContract(ctx, underlyingClient, common.HexToAddress(domain.LightInboxAddress))
		if err != nil {
			return nil, fmt.Errorf("could not bind light inbox contract: %w", err)
		}
	} else {
		boundSummit, err = NewSummitContract(ctx, underlyingClient, common.HexToAddress(domain.SummitAddress))
		if err != nil {
			return nil, fmt.Errorf("could not bind summit contract: %w", err)
		}

		boundBondingManager, err = NewBondingManagerContract(ctx, underlyingClient, common.HexToAddress(domain.BondingManagerAddress))
		if err != nil {
			return nil, fmt.Errorf("could not bind bonding manager contract: %w", err)
		}
		boundInbox, err = NewInboxContract(ctx, underlyingClient, common.HexToAddress(domain.InboxAddress))
		if err != nil {
			return nil, fmt.Errorf("could not bind inbox contract: %w", err)
		}
	}

	return evmClient{
		name:           name,
		config:         domain,
		client:         underlyingClient,
		summit:         boundSummit,
		origin:         boundOrigin,
		destination:    boundDestination,
		lightManager:   boundLightManager,
		lightInbox:     boundLightInbox,
		bondingManager: boundBondingManager,
		inbox:          boundInbox,
	}, nil
}

// Name gets the name of the evm client.
func (e evmClient) Name() string {
	return e.name
}

// Config gets the config the evm client was initiated with.
func (e evmClient) Config() config.DomainConfig {
	return e.config
}

// BlockNumber gets the latest block number.
func (e evmClient) BlockNumber(ctx context.Context) (uint32, error) {
	blockNumber, err := e.client.BlockNumber(ctx)
	if err != nil {
		return 0, fmt.Errorf("could not get block number: %w", err)
	}

	return uint32(blockNumber), nil
}

// Origin returns the bound origin contract.
func (e evmClient) Origin() domains.OriginContract {
	return e.origin
}

// Summit gets the summit.
func (e evmClient) Summit() domains.SummitContract {
	return e.summit
}

// Destination gets the destination.
func (e evmClient) Destination() domains.DestinationContract {
	return e.destination
}

// LightManager gets the light manager.
func (e evmClient) LightManager() domains.LightManagerContract {
	return e.lightManager
}

// BondingManager gets the bonding manager.
func (e evmClient) BondingManager() domains.BondingManagerContract {
	return e.bondingManager
}

// LightInbox gets the light inbox.
func (e evmClient) LightInbox() domains.LightInboxContract {
	return e.lightInbox
}

// Inbox gets the inbox.
func (e evmClient) Inbox() domains.InboxContract {
	return e.inbox
}