package testutil

import (
	"context"
	"fmt"
	"github.com/synapsecns/sanguine/agents/contracts/test/attestationharness"
	"github.com/synapsecns/sanguine/agents/contracts/test/basemessageharness"
	"github.com/synapsecns/sanguine/agents/contracts/test/bondingmanagerharness"
	gasdataharness "github.com/synapsecns/sanguine/agents/contracts/test/gasdata"
	"github.com/synapsecns/sanguine/agents/contracts/test/lightmanagerharness"
	"github.com/synapsecns/sanguine/agents/contracts/test/originharness"
	"github.com/synapsecns/sanguine/agents/contracts/test/receiptharness"
	"github.com/synapsecns/sanguine/agents/contracts/test/requestharness"
	"github.com/synapsecns/sanguine/agents/contracts/test/snapshotharness"
	"github.com/synapsecns/sanguine/agents/contracts/test/stateharness"
	"github.com/synapsecns/sanguine/agents/contracts/test/tipsharness"

	"github.com/synapsecns/sanguine/agents/contracts/test/summitharness"

	"github.com/ethereum/go-ethereum/accounts/abi/bind"
	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/core/types"
	"github.com/synapsecns/sanguine/agents/contracts/test/destinationharness"
	"github.com/synapsecns/sanguine/agents/contracts/test/headerharness"
	"github.com/synapsecns/sanguine/agents/contracts/test/messageharness"
	"github.com/synapsecns/sanguine/agents/contracts/test/pingpongclient"
	"github.com/synapsecns/sanguine/agents/contracts/test/testclient"
	"github.com/synapsecns/sanguine/agents/testutil/agentstestcontract"
	"github.com/synapsecns/sanguine/ethergo/backends"
	"github.com/synapsecns/sanguine/ethergo/contracts"
	"github.com/synapsecns/sanguine/ethergo/deployer"
)

// SynapseChainID is the chain ID for the synapse chain.
const SynapseChainID = 10

// MessageHarnessDeployer deploys the message harness for testing.
type MessageHarnessDeployer struct {
	*deployer.BaseDeployer
}

// NewMessageHarnessDeployer creates a message harness deployer.
func NewMessageHarnessDeployer(registry deployer.GetOnlyContractRegistry, backend backends.SimulatedTestBackend) deployer.ContractDeployer {
	return MessageHarnessDeployer{deployer.NewSimpleDeployer(registry, backend, MessageHarnessType)}
}

// Deploy deploys the message harness deployer.
func (d MessageHarnessDeployer) Deploy(ctx context.Context) (contracts.DeployedContract, error) {
	return d.DeploySimpleContract(ctx, func(transactOps *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, interface{}, error) {
		return messageharness.DeployMessageHarness(transactOps, backend)
	}, func(address common.Address, backend bind.ContractBackend) (interface{}, error) {
		return messageharness.NewMessageHarnessRef(address, backend)
	})
}

// BaseMessageHarnessDeployer deploys the base message harness for testing.
type BaseMessageHarnessDeployer struct {
	*deployer.BaseDeployer
}

// NewBaseMessageHarnessDeployer creates a base message harness deployer.
func NewBaseMessageHarnessDeployer(regirstry deployer.GetOnlyContractRegistry, backend backends.SimulatedTestBackend) deployer.ContractDeployer {
	return BaseMessageHarnessDeployer{deployer.NewSimpleDeployer(regirstry, backend, BaseMessageHarnessType)}
}

// Deploy deploys the base message harness deployer.
func (d BaseMessageHarnessDeployer) Deploy(ctx context.Context) (contracts.DeployedContract, error) {
	return d.DeploySimpleContract(ctx, func(transactOpts *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, interface{}, error) {
		return basemessageharness.DeployBaseMessageHarness(transactOpts, backend)
	}, func(address common.Address, backend bind.ContractBackend) (interface{}, error) {
		return basemessageharness.NewBaseMessageHarnessRef(address, backend)
	})
}

// ReceiptHarnessDeployer deploys the request harness for testing.
type ReceiptHarnessDeployer struct {
	*deployer.BaseDeployer
}

// NewReceiptHarnessDeployer creates a request harness deployer.
func NewReceiptHarnessDeployer(registry deployer.GetOnlyContractRegistry, backend backends.SimulatedTestBackend) deployer.ContractDeployer {
	return ReceiptHarnessDeployer{deployer.NewSimpleDeployer(registry, backend, ReceiptHarnessType)}
}

// Deploy deploys the receipt harness deployer.
func (d ReceiptHarnessDeployer) Deploy(ctx context.Context) (contracts.DeployedContract, error) {
	return d.DeploySimpleContract(ctx, func(transactOpts *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, interface{}, error) {
		return receiptharness.DeployReceiptHarness(transactOpts, backend)
	}, func(address common.Address, backend bind.ContractBackend) (interface{}, error) {
		return receiptharness.NewReceiptHarnessRef(address, backend)
	})
}

// RequestHarnessDeployer deploys the request harness for testing.
type RequestHarnessDeployer struct {
	*deployer.BaseDeployer
}

// NewRequestHarnessDeployer creates a request harness deployer.
func NewRequestHarnessDeployer(registry deployer.GetOnlyContractRegistry, backend backends.SimulatedTestBackend) deployer.ContractDeployer {
	return RequestHarnessDeployer{deployer.NewSimpleDeployer(registry, backend, RequestHarnessType)}
}

// Deploy deploys the request harness deployer.
func (d RequestHarnessDeployer) Deploy(ctx context.Context) (contracts.DeployedContract, error) {
	return d.DeploySimpleContract(ctx, func(transactOpts *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, interface{}, error) {
		return requestharness.DeployRequestHarness(transactOpts, backend)
	}, func(address common.Address, backend bind.ContractBackend) (interface{}, error) {
		return requestharness.NewRequestHarnessRef(address, backend)
	})
}

// LightManagerHarnessDeployer deploys the light agent manager for testing.
type LightManagerHarnessDeployer struct {
	*deployer.BaseDeployer
}

// NewLightManagerHarnessDeployer deploys a new light agent manager harness.
func NewLightManagerHarnessDeployer(registry deployer.GetOnlyContractRegistry, backend backends.SimulatedTestBackend) deployer.ContractDeployer {
	return LightManagerHarnessDeployer{deployer.NewSimpleDeployer(registry, backend, LightManagerHarnessType)}
}

// Deploy deploys the light manager harness.
// nolint:dupl,dupword
func (o LightManagerHarnessDeployer) Deploy(ctx context.Context) (contracts.DeployedContract, error) {
	/*originHarnessContract := o.Registry().Get(ctx, OriginHarnessType)
	destinationHarnessContract := o.Registry().Get(ctx, DestinationHarnessType)
	originAddress := originHarnessContract.Address()
	destinationAddress := destinationHarnessContract.Address()*/
	return o.DeploySimpleContract(ctx, func(transactOps *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, interface{}, error) {
		address, tx, rawHandle, err := lightmanagerharness.DeployLightManagerHarness(transactOps, backend, SynapseChainID)
		if err != nil {
			return common.Address{}, nil, nil, fmt.Errorf("could not deploy %s: %w", o.ContractType().ContractName(), err)
		}
		o.Backend().WaitForConfirmation(ctx, tx)

		/*initializeOpts := o.Backend().GetTxContext(ctx, &transactOps.From)
		initializeTx, err := rawHandle.Initialize(initializeOpts.TransactOpts, originAddress, destinationAddress)
		if err != nil {
			return common.Address{}, nil, nil, fmt.Errorf("could not initialize origin (%s) on %s: %w", transactOps.From, o.ContractType().ContractName(), err)
		}
		o.Backend().WaitForConfirmation(ctx, initializeTx)*/

		return address, tx, rawHandle, err
	}, func(address common.Address, backend bind.ContractBackend) (interface{}, error) {
		return lightmanagerharness.NewLightManagerHarnessRef(address, backend)
	})
}

// Dependencies gets a list of dependencies used to deploy the light agent manager contract.
func (o LightManagerHarnessDeployer) Dependencies() []contracts.ContractType {
	return []contracts.ContractType{}
}

// BondingManagerHarnessDeployer deploys the bonding manager for testing.
type BondingManagerHarnessDeployer struct {
	*deployer.BaseDeployer
}

// NewBondingManagerHarnessDeployer deploys a new bonding agent manager harness.
func NewBondingManagerHarnessDeployer(registry deployer.GetOnlyContractRegistry, backend backends.SimulatedTestBackend) deployer.ContractDeployer {
	return BondingManagerHarnessDeployer{deployer.NewSimpleDeployer(registry, backend, BondingManagerHarnessType)}
}

// Deploy deploys the light manager harness.
// nolint:dupl,dupword
func (o BondingManagerHarnessDeployer) Deploy(ctx context.Context) (contracts.DeployedContract, error) {
	/*originHarnessContract := o.Registry().Get(ctx, OriginHarnessType)
	destinationHarnessContract := o.Registry().Get(ctx, DestinationHarnessType)
	originAddress := originHarnessContract.Address()
	destinationAddress := destinationHarnessContract.Address()*/
	return o.DeploySimpleContract(ctx, func(transactOps *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, interface{}, error) {
		address, tx, rawHandle, err := bondingmanagerharness.DeployBondingManagerHarness(transactOps, backend, SynapseChainID)
		if err != nil {
			return common.Address{}, nil, nil, fmt.Errorf("could not deploy %s: %w", o.ContractType().ContractName(), err)
		}
		o.Backend().WaitForConfirmation(ctx, tx)

		/*initializeOpts := o.Backend().GetTxContext(ctx, &transactOps.From)
		initializeTx, err := rawHandle.Initialize(initializeOpts.TransactOpts, originAddress, destinationAddress)
		if err != nil {
			return common.Address{}, nil, nil, fmt.Errorf("could not initialize origin (%s) on %s: %w", transactOps.From, o.ContractType().ContractName(), err)
		}
		o.Backend().WaitForConfirmation(ctx, initializeTx)*/

		return address, tx, rawHandle, err
	}, func(address common.Address, backend bind.ContractBackend) (interface{}, error) {
		return bondingmanagerharness.NewBondingManagerHarnessRef(address, backend)
	})
}

// Dependencies gets a list of dependencies used to deploy the bonding manager contract.
func (o BondingManagerHarnessDeployer) Dependencies() []contracts.ContractType {
	return []contracts.ContractType{}
}

// OriginHarnessDeployer deploys the origin harness for testing.
type OriginHarnessDeployer struct {
	*deployer.BaseDeployer
}

// NewOriginHarnessDeployer deploys a new origin harness.
func NewOriginHarnessDeployer(registry deployer.GetOnlyContractRegistry, backend backends.SimulatedTestBackend) deployer.ContractDeployer {
	return OriginHarnessDeployer{deployer.NewSimpleDeployer(registry, backend, OriginHarnessType)}
}

// Deploy deploys the origin harness.
// nolint:dupl
func (o OriginHarnessDeployer) Deploy(ctx context.Context) (contracts.DeployedContract, error) {
	var agentAddress common.Address
	var inboxAddress common.Address
	if o.Backend().GetChainID() == 10 {
		bondingManagerHarnessContract := o.Registry().Get(ctx, BondingManagerHarnessType)
		agentAddress = bondingManagerHarnessContract.Address()

		inboxContract := o.Registry().Get(ctx, InboxType)
		inboxAddress = inboxContract.Address()
	} else {
		lightManagerHarnessContract := o.Registry().Get(ctx, LightManagerHarnessType)
		agentAddress = lightManagerHarnessContract.Address()

		lightInboxContract := o.Registry().Get(ctx, LightInboxType)
		inboxAddress = lightInboxContract.Address()
	}
	gasOracleContract := o.Registry().Get(ctx, GasOracleType)
	gasOracleAddress := gasOracleContract.Address()
	return o.DeploySimpleContract(ctx, func(transactOps *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, interface{}, error) {
		address, tx, rawHandle, err := originharness.DeployOriginHarness(transactOps, backend, SynapseChainID, agentAddress, inboxAddress, gasOracleAddress)
		if err != nil {
			return common.Address{}, nil, nil, fmt.Errorf("could not deploy %s: %w", o.ContractType().ContractName(), err)
		}
		o.Backend().WaitForConfirmation(ctx, tx)

		initializeOpts := o.Backend().GetTxContext(ctx, &transactOps.From)
		initializeTx, err := rawHandle.Initialize(initializeOpts.TransactOpts)
		if err != nil {
			return common.Address{}, nil, nil, fmt.Errorf("could not initialize origin (%s) on %s: %w", transactOps.From, o.ContractType().ContractName(), err)
		}
		o.Backend().WaitForConfirmation(ctx, initializeTx)

		return address, tx, rawHandle, err
	}, func(address common.Address, backend bind.ContractBackend) (interface{}, error) {
		return originharness.NewOriginHarnessRef(address, backend)
	})
}

// Dependencies gets a list of dependencies used to deploy the origin contract.
func (o OriginHarnessDeployer) Dependencies() []contracts.ContractType {
	return []contracts.ContractType{}
}

// GasDataHarnessDeployer deploys the gasData harness.
type GasDataHarnessDeployer struct {
	*deployer.BaseDeployer
}

// NewGasDataHarnessDeployer creates a new deployer for the gasData harness.
func NewGasDataHarnessDeployer(registry deployer.GetOnlyContractRegistry, backend backends.SimulatedTestBackend) deployer.ContractDeployer {
	return GasDataHarnessDeployer{deployer.NewSimpleDeployer(registry, backend, GasDataHarnessType)}
}

// Deploy deploys the gasData harness.
func (a GasDataHarnessDeployer) Deploy(ctx context.Context) (contracts.DeployedContract, error) {
	return a.DeploySimpleContract(ctx, func(transactOps *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, interface{}, error) {
		return gasdataharness.DeployGasDataHarness(transactOps, backend)
	}, func(address common.Address, backend bind.ContractBackend) (interface{}, error) {
		return gasdataharness.NewGasDataHarnessRef(address, backend)
	})
}

// StateHarnessDeployer deploys the state harness.
type StateHarnessDeployer struct {
	*deployer.BaseDeployer
}

// NewStateHarnessDeployer creates a new deployer for the state harness.
func NewStateHarnessDeployer(registry deployer.GetOnlyContractRegistry, backend backends.SimulatedTestBackend) deployer.ContractDeployer {
	return StateHarnessDeployer{deployer.NewSimpleDeployer(registry, backend, StateHarnessType)}
}

// Deploy deploys the state harness.
func (a StateHarnessDeployer) Deploy(ctx context.Context) (contracts.DeployedContract, error) {
	return a.DeploySimpleContract(ctx, func(transactOps *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, interface{}, error) {
		return stateharness.DeployStateHarness(transactOps, backend)
	}, func(address common.Address, backend bind.ContractBackend) (interface{}, error) {
		return stateharness.NewStateHarnessRef(address, backend)
	})
}

// SnapshotHarnessDeployer deploys the snapshot harness.
type SnapshotHarnessDeployer struct {
	*deployer.BaseDeployer
}

// NewSnapshotHarnessDeployer creates a new deployer for the snapshot harness.
func NewSnapshotHarnessDeployer(registry deployer.GetOnlyContractRegistry, backend backends.SimulatedTestBackend) deployer.ContractDeployer {
	return SnapshotHarnessDeployer{deployer.NewSimpleDeployer(registry, backend, SnapshotHarnessType)}
}

// Deploy deploys the snapshot harness.
func (a SnapshotHarnessDeployer) Deploy(ctx context.Context) (contracts.DeployedContract, error) {
	return a.DeploySimpleContract(ctx, func(transactOps *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, interface{}, error) {
		return snapshotharness.DeploySnapshotHarness(transactOps, backend)
	}, func(address common.Address, backend bind.ContractBackend) (interface{}, error) {
		return snapshotharness.NewSnapshotHarnessRef(address, backend)
	})
}

// AttestationHarnessDeployer deploys the attestation harness for testing.
type AttestationHarnessDeployer struct {
	*deployer.BaseDeployer
}

// NewAttestationHarnessDeployer creates a new deployer for the attestation harness.
func NewAttestationHarnessDeployer(registry deployer.GetOnlyContractRegistry, backend backends.SimulatedTestBackend) deployer.ContractDeployer {
	return AttestationHarnessDeployer{deployer.NewSimpleDeployer(registry, backend, AttestationHarnessType)}
}

// Deploy deploys the attestation harness.
func (a AttestationHarnessDeployer) Deploy(ctx context.Context) (contracts.DeployedContract, error) {
	return a.DeploySimpleContract(ctx, func(transactOps *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, interface{}, error) {
		return attestationharness.DeployAttestationHarness(transactOps, backend)
	}, func(address common.Address, backend bind.ContractBackend) (interface{}, error) {
		return attestationharness.NewAttestationHarnessRef(address, backend)
	})
}

// TipsHarnessDeployer deploys the tip harness for tester.
type TipsHarnessDeployer struct {
	*deployer.BaseDeployer
}

// NewTipsHarnessDeployer creates a new deployer for the attestation harness.
func NewTipsHarnessDeployer(registry deployer.GetOnlyContractRegistry, backend backends.SimulatedTestBackend) deployer.ContractDeployer {
	return TipsHarnessDeployer{deployer.NewSimpleDeployer(registry, backend, TipsHarnessType)}
}

// Deploy deploys the attestation harness.
func (a TipsHarnessDeployer) Deploy(ctx context.Context) (contracts.DeployedContract, error) {
	return a.DeploySimpleContract(ctx, func(transactOps *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, interface{}, error) {
		return tipsharness.DeployTipsHarness(transactOps, backend)
	}, func(address common.Address, backend bind.ContractBackend) (interface{}, error) {
		return tipsharness.NewTipsHarnessRef(address, backend)
	})
}

// DestinationHarnessDeployer deploys the destination harness.
type DestinationHarnessDeployer struct {
	*deployer.BaseDeployer
}

// NewDestinationHarnessDeployer creates a new deployer for the destination harness.
func NewDestinationHarnessDeployer(registry deployer.GetOnlyContractRegistry, backend backends.SimulatedTestBackend) deployer.ContractDeployer {
	return DestinationHarnessDeployer{deployer.NewSimpleDeployer(registry, backend, DestinationHarnessType)}
}

// Deploy deploys the destination harness.
// nolint:dupl,dupword
func (d DestinationHarnessDeployer) Deploy(ctx context.Context) (contracts.DeployedContract, error) {
	var agentManagerAddress common.Address
	var inboxAddress common.Address
	if d.Backend().GetChainID() == 10 {
		bondingManagerHarnessContract := d.Registry().Get(ctx, BondingManagerHarnessType)
		agentManagerAddress = bondingManagerHarnessContract.Address()

		inboxContract := d.Registry().Get(ctx, InboxType)
		inboxAddress = inboxContract.Address()
	} else {
		lightManagerHarnessContract := d.Registry().Get(ctx, LightManagerHarnessType)
		agentManagerAddress = lightManagerHarnessContract.Address()

		lightInboxContract := d.Registry().Get(ctx, LightInboxType)
		inboxAddress = lightInboxContract.Address()
	}
	return d.DeploySimpleContract(ctx, func(transactOps *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, interface{}, error) {
		address, tx, rawHandle, err := destinationharness.DeployDestinationHarness(transactOps, backend, SynapseChainID, agentManagerAddress, inboxAddress)
		if err != nil {
			return common.Address{}, nil, nil, fmt.Errorf("could not deploy %s: %w", d.ContractType().ContractName(), err)
		}
		d.Backend().WaitForConfirmation(ctx, tx)

		/*initializeOpts := d.Backend().GetTxContext(ctx, &transactOps.From)
		initializeTx, err := rawHandle.Initialize(initializeOpts.TransactOpts)
		if err != nil {
			return common.Address{}, nil, nil, fmt.Errorf("could not initialize destination (%s) on %s: %w", transactOps.From, d.ContractType().ContractName(), err)
		}
		d.Backend().WaitForConfirmation(ctx, initializeTx)*/

		return address, tx, rawHandle, err
	}, func(address common.Address, backend bind.ContractBackend) (interface{}, error) {
		return destinationharness.NewDestinationHarnessRef(address, backend)
	})
}

// SummitHarnessDeployer deploys the summit harness.
type SummitHarnessDeployer struct {
	*deployer.BaseDeployer
}

// NewSummitHarnessDeployer creates a new deployer for the summit harness.
func NewSummitHarnessDeployer(registry deployer.GetOnlyContractRegistry, backend backends.SimulatedTestBackend) deployer.ContractDeployer {
	return SummitHarnessDeployer{deployer.NewSimpleDeployer(registry, backend, SummitHarnessType)}
}

// Deploy deploys the summit harness.
// nolint:dupl
func (d SummitHarnessDeployer) Deploy(ctx context.Context) (contracts.DeployedContract, error) {
	bondingManagerHarnessContract := d.Registry().Get(ctx, BondingManagerHarnessType)
	bondingManagerAddress := bondingManagerHarnessContract.Address()
	inboxContract := d.Registry().Get(ctx, InboxType)
	inboxAddress := inboxContract.Address()
	return d.DeploySimpleContract(ctx, func(transactOps *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, interface{}, error) {
		address, tx, rawHandle, err := summitharness.DeploySummitHarness(transactOps, backend, bondingManagerAddress, inboxAddress)
		if err != nil {
			return common.Address{}, nil, nil, fmt.Errorf("could not deploy %s: %w", d.ContractType().ContractName(), err)
		}
		d.Backend().WaitForConfirmation(ctx, tx)

		initializeOpts := d.Backend().GetTxContext(ctx, &transactOps.From)
		initializeTx, err := rawHandle.Initialize(initializeOpts.TransactOpts)
		if err != nil {
			return common.Address{}, nil, nil, fmt.Errorf("could not initialize summit harness (%s) on %s: %w", transactOps.From, d.ContractType().ContractName(), err)
		}
		d.Backend().WaitForConfirmation(ctx, initializeTx)

		return address, tx, rawHandle, err
	}, func(address common.Address, backend bind.ContractBackend) (interface{}, error) {
		return summitharness.NewSummitHarnessRef(address, backend)
	})
}

// HeaderHarnessDeployer deploys the header harness.
type HeaderHarnessDeployer struct {
	*deployer.BaseDeployer
}

// NewHeaderHarnessDeployer gets the header harness.
func NewHeaderHarnessDeployer(registry deployer.GetOnlyContractRegistry, backend backends.SimulatedTestBackend) deployer.ContractDeployer {
	return HeaderHarnessDeployer{deployer.NewSimpleDeployer(registry, backend, HeaderHarnessType)}
}

// Deploy deploys the header harness.
func (h HeaderHarnessDeployer) Deploy(ctx context.Context) (contracts.DeployedContract, error) {
	return h.DeploySimpleContract(ctx, func(transactOps *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, interface{}, error) {
		return headerharness.DeployHeaderHarness(transactOps, backend)
	}, func(address common.Address, backend bind.ContractBackend) (interface{}, error) {
		return headerharness.NewHeaderHarnessRef(address, backend)
	})
}

// AgentsTestContractDeployer deploys the agents test contract.
type AgentsTestContractDeployer struct {
	*deployer.BaseDeployer
}

// NewAgentsTestContractDeployer gets the agents test contract.
func NewAgentsTestContractDeployer(registry deployer.GetOnlyContractRegistry, backend backends.SimulatedTestBackend) deployer.ContractDeployer {
	return AgentsTestContractDeployer{deployer.NewSimpleDeployer(registry, backend, AgentsTestContractType)}
}

// Deploy deploys the agents test contract.
func (h AgentsTestContractDeployer) Deploy(ctx context.Context) (contracts.DeployedContract, error) {
	return h.DeploySimpleContract(ctx, func(transactOps *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, interface{}, error) {
		return agentstestcontract.DeployAgentsTestContract(transactOps, backend)
	}, func(address common.Address, backend bind.ContractBackend) (interface{}, error) {
		return agentstestcontract.NewAgentsTestContractRef(address, backend)
	})
}

// TestClientDeployer deploys the test client.
type TestClientDeployer struct {
	*deployer.BaseDeployer
}

// NewTestClientDeployer gets the test client.
func NewTestClientDeployer(registry deployer.GetOnlyContractRegistry, backend backends.SimulatedTestBackend) deployer.ContractDeployer {
	return TestClientDeployer{deployer.NewSimpleDeployer(registry, backend, TestClientType)}
}

// Deploy deploys the test client.
func (h TestClientDeployer) Deploy(ctx context.Context) (contracts.DeployedContract, error) {
	originHarnessContract := h.Registry().Get(ctx, OriginHarnessType)
	destinationHarnessContract := h.Registry().Get(ctx, DestinationHarnessType)
	originAddress := originHarnessContract.Address()
	destinationAddress := destinationHarnessContract.Address()
	return h.DeploySimpleContract(ctx, func(transactOps *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, interface{}, error) {
		return testclient.DeployTestClient(transactOps, backend, originAddress, destinationAddress)
	}, func(address common.Address, backend bind.ContractBackend) (interface{}, error) {
		return testclient.NewTestClientRef(address, backend)
	})
}

// PingPongClientDeployer deploys the ping pong test client.
type PingPongClientDeployer struct {
	*deployer.BaseDeployer
}

// NewPingPongClientDeployer gets the ping pong test client.
func NewPingPongClientDeployer(registry deployer.GetOnlyContractRegistry, backend backends.SimulatedTestBackend) deployer.ContractDeployer {
	return PingPongClientDeployer{deployer.NewSimpleDeployer(registry, backend, PingPongClientType)}
}

// Deploy deploys the ping pong test client.
func (h PingPongClientDeployer) Deploy(ctx context.Context) (contracts.DeployedContract, error) {
	originHarnessContract := h.Registry().Get(ctx, OriginHarnessType)
	destinationHarnessContract := h.Registry().Get(ctx, DestinationHarnessType)
	originAddress := originHarnessContract.Address()
	destinationAddress := destinationHarnessContract.Address()
	return h.DeploySimpleContract(ctx, func(transactOps *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, interface{}, error) {
		return pingpongclient.DeployPingPongClient(transactOps, backend, originAddress, destinationAddress)
	}, func(address common.Address, backend bind.ContractBackend) (interface{}, error) {
		return pingpongclient.NewPingPongClientRef(address, backend)
	})
}