monitoring

type ChainConfig interface {
	GetRPCEndpoint() string
	GetNetworkName() string
	GetNetworkID() string
	GetChainID() string
	GetReadTimeout() time.Duration
	GetPollInterval() time.Duration
	// Useful for serializing to avro.
	ToMapping() map[string]interface{}
}

type ChainMetrics interface {
	SetNewFeedConfigsDetected(numFeeds float64)

	IncSendMessageToKafkaFailed(topic string)
	IncSendMessageToKafkaSucceeded(topic string)
	AddSendMessageToKafkaBytes(bytes float64, topic string)
}

type Envelope struct {
	// latest transmission details
	ConfigDigest    types.ConfigDigest
	Epoch           uint32
	Round           uint8
	LatestAnswer    *big.Int
	LatestTimestamp time.Time

	// latest contract config
	ContractConfig types.ContractConfig

	// extra
	BlockNumber             uint64
	Transmitter             types.Account
	LinkBalance             *big.Int
	LinkAvailableForPayment *big.Int

	// The "fee coin" is different for each chain.
	JuelsPerFeeCoin   *big.Int
	AggregatorRoundID uint32
}

type Exporter interface {
	// Export is executed on each update on a monitored feed
	Export(ctx context.Context, data interface{})
	// Cleanup is executed once a monitor for a specific feed is terminated.
	Cleanup(ctx context.Context)
}

type ExporterFactory interface {
	NewExporter(ExporterParams) (Exporter, error)
}

type ExporterFactoryMock struct {
	mock.Mock
}

type ExporterMock struct {
	mock.Mock
}

type ExporterParams struct {
	ChainConfig ChainConfig
	FeedConfig  FeedConfig
	Nodes       []NodeConfig
}

type FeedConfig interface {
	// This functions as a feed identifier.
	GetID() string
	GetName() string
	GetPath() string
	GetSymbol() string
	GetHeartbeatSec() int64
	GetContractType() string
	GetContractStatus() string
	GetContractAddress() string
	GetContractAddressBytes() []byte
	// GetMultiply() returns the multiply parameter of a feed.
	// This is a misnomer kept for historical reasons. Multiply is used as divisor
	// for the big integers read from on-chain - think balances, observations,
	// etc. - into prometheus-friendly float64s.
	GetMultiply() *big.Int
	// ToMapping() is useful when encoding kafka messages.
	ToMapping() map[string]interface{}
}

type FeedMetrics interface {
	IncFetchFromSourceFailed(sourceName string)
	IncFetchFromSourceSucceeded(sourceName string)
	ObserveFetchFromSourceDuraction(duration time.Duration, sourceName string)
}

type FeedMonitor interface {
	Run(ctx context.Context)
}

type FeedsParser func(buf io.ReadCloser) ([]FeedConfig, error)

type HTTPServer interface {
	Handle(path string, handler http.Handler)
	Run(ctx context.Context)
}

type Logger = logger.Logger

type ManagedFunc func(localCtx context.Context, data RDDData)

type Manager interface {
	Run(backgroundCtx context.Context, managed ManagedFunc)
	HTTPHandler() http.Handler
}

type Mapper func(Envelope, ChainConfig, FeedConfig) (map[string]interface{}, error)

type Metrics interface {
	SetHeadTrackerCurrentHead(blockNumber float64, networkName, chainID, networkID string)
	SetFeedContractMetadata(chainID, contractAddress, feedID, contractStatus, contractType, feedName, feedPath, networkID, networkName, symbol string)
	SetFeedContractLinkBalance(balance float64, contractAddress, feedID, chainID, contractStatus, contractType, feedName, feedPath, networkID, networkName string)
	SetLinkAvailableForPayment(amount float64, feedID, chainID, contractStatus, contractType, feedName, feedPath, networkID, networkName string)
	SetFeedContractTransactionsSucceeded(numSucceeded float64, contractAddress, feedID, chainID, contractStatus, contractType, feedName, feedPath, networkID, networkName string)
	SetFeedContractTransactionsFailed(numFailed float64, contractAddress, feedID, chainID, contractStatus, contractType, feedName, feedPath, networkID, networkName string)
	SetNodeMetadata(chainID, networkID, networkName, oracleName, sender string)
	// Deprecated: use SetOffchainAggregatorAnswers
	SetOffchainAggregatorAnswersRaw(answer float64, contractAddress, feedID, chainID, contractStatus, contractType, feedName, feedPath, networkID, networkName string)
	SetOffchainAggregatorAnswers(answer float64, contractAddress, feedID, chainID, contractStatus, contractType, feedName, feedPath, networkID, networkName string)
	IncOffchainAggregatorAnswersTotal(contractAddress, feedID, chainID, contractStatus, contractType, feedName, feedPath, networkID, networkName string)
	// Deprecated: use SetOffchainAggregatorJuelsPerFeeCoin
	SetOffchainAggregatorJuelsPerFeeCoinRaw(juelsPerFeeCoin float64, contractAddress, feedID, chainID, contractStatus, contractType, feedName, feedPath, networkID, networkName string)
	SetOffchainAggregatorJuelsPerFeeCoin(juelsPerFeeCoin float64, contractAddress, feedID, chainID, contractStatus, contractType, feedName, feedPath, networkID, networkName string)
	SetOffchainAggregatorSubmissionReceivedValues(value float64, contractAddress, feedID, sender, chainID, contractStatus, contractType, feedName, feedPath, networkID, networkName string)
	SetOffchainAggregatorJuelsPerFeeCoinReceivedValues(value float64, contractAddress, feedID, sender, chainID, contractStatus, contractType, feedName, feedPath, networkID, networkName string)
	SetOffchainAggregatorAnswerStalled(isSet bool, contractAddress, feedID, chainID, contractStatus, contractType, feedName, feedPath, networkID, networkName string)
	SetOffchainAggregatorRoundID(aggregatorRoundID float64, contractAddress, feedID, chainID, contractStatus, contractType, feedName, feedPath, networkID, networkName string)
	// Cleanup deletes all the metrics
	Cleanup(networkName, networkID, chainID, oracleName, sender, feedName, feedPath, symbol, contractType, contractStatus, contractAddress, feedID string)
	// Exposes the accumulated metrics to HTTP.
	HTTPHandler() http.Handler
}

type MetricsMock struct {
	mock.Mock
}

type Monitor struct {
	RootContext context.Context

	ChainConfig ChainConfig
	Config      config.Config

	Log            Logger
	Producer       Producer
	Metrics        Metrics
	ChainMetrics   ChainMetrics
	SchemaRegistry SchemaRegistry

	SourceFactories   []SourceFactory
	ExporterFactories []ExporterFactory

	RDDSource Source
	RDDPoller Poller

	Manager Manager

	HTTPServer HTTPServer
}

type MultiFeedMonitor interface {
	Run(ctx context.Context, data RDDData)
}

type NodeConfig interface {
	GetName() string
	GetAccount() types.Account
}

type NodesParser func(buf io.ReadCloser) ([]NodeConfig, error)

type Pipeline struct {
	Topic  string
	Mapper Mapper
	Schema Schema
}

type Poller interface {
	Updater // Poller is just another name for updater.
}

type Producer interface {
	Produce(key, value []byte, topic string) error
}

type RDDData struct {
	Feeds []FeedConfig `json:"feeds,omitempty"`
	Nodes []NodeConfig `json:"nodes,omitempty"`
}

type Schema interface {
	ID() int
	Version() int
	Subject() string
	Encode(interface{}) ([]byte, error)
	Decode([]byte) (interface{}, error)
}

type SchemaRegistry interface {
	// EnsureSchema handles three cases when pushing a schema spec to the SchemaRegistry:
	// 1. when the schema with a given subject does not exist, it will create it.
	// 2. if a schema with the given subject already exists but the spec is different, it will update it and bump the version.
	// 3. if the schema exists and the spec is the same, it will not do anything.
	EnsureSchema(subject, spec string) (Schema, error)
}

type Source interface {
	// Fetch must be thread-safe!
	// There is no guarantee on the ordering of Fetch() calls for the same source instance.
	Fetch(context.Context) (interface{}, error)
}

type SourceFactory interface {
	NewSource(chainConfig ChainConfig, feedConfig FeedConfig) (Source, error)
	// GetType should return a namespace for all the source instances produced by this factory.
	GetType() string
}

type SourceFactoryMock struct {
	mock.Mock
}

type SourceMock struct {
	mock.Mock
}

type TxResults struct {
	NumSucceeded, NumFailed uint64
}

type Updater interface {
	// Run should be executed as a goroutine otherwise it will block.
	Run(context.Context)
	// You should never close the channel returned by Updates()!
	// You should always read from the channel returned by Updates() in a
	// select statement with the same context you passed to Run()
	Updates() <-chan interface{}
}