chain

type AsynchronousCommonSubsetRunner interface {
	RunACSConsensus(value []byte, sessionID uint64, stateIndex uint32, callback func(sessionID uint64, acs [][]byte))
	Close()
}

type Chain interface {
	ChainCore
	ChainRequests
	ChainEntry
	ChainMetrics
}

type ChainCore interface {
	ID() *iscp.ChainID
	GetCommitteeInfo() *CommitteeInfo
	StateCandidateToStateManager(state.VirtualStateAccess, ledgerstate.OutputID)
	TriggerChainTransition(*ChainTransitionEventData)
	Processors() *processors.Cache
	GlobalStateSync() coreutil.ChainStateSync
	GetStateReader() state.OptimisticStateReader
	Log() *logger.Logger

	// Most of these methods are made public for mocking in tests
	EnqueueDismissChain(reason string) // This one should really be public
	EnqueueLedgerState(chainOutput *ledgerstate.AliasOutput, timestamp time.Time)
	EnqueueOffLedgerRequestMsg(msg *messages.OffLedgerRequestMsgIn)
	EnqueueRequestAckMsg(msg *messages.RequestAckMsgIn)
	EnqueueMissingRequestIDsMsg(msg *messages.MissingRequestIDsMsgIn)
	EnqueueMissingRequestMsg(msg *messages.MissingRequestMsg)
	EnqueueTimerTick(tick int)
}

type ChainEntry interface {
	ReceiveTransaction(*ledgerstate.Transaction)
	ReceiveState(stateOutput *ledgerstate.AliasOutput, timestamp time.Time)

	Dismiss(reason string)
	IsDismissed() bool
}

type ChainMetrics interface {
	GetNodeConnectionMetrics() nodeconnmetrics.NodeConnectionMessagesMetrics
}

type ChainNodeConnection interface {
	AttachToTransactionReceived(NodeConnectionHandleTransactionFun)
	AttachToInclusionStateReceived(NodeConnectionHandleInclusionStateFun)
	AttachToOutputReceived(NodeConnectionHandleOutputFun)
	AttachToUnspentAliasOutputReceived(NodeConnectionHandleUnspentAliasOutputFun)

	PullState()
	PullTransactionInclusionState(txid ledgerstate.TransactionID)
	PullConfirmedOutput(outputID ledgerstate.OutputID)
	PostTransaction(tx *ledgerstate.Transaction)

	GetMetrics() nodeconnmetrics.NodeConnectionMessagesMetrics

	DetachFromTransactionReceived()
	DetachFromInclusionStateReceived()
	DetachFromOutputReceived()
	DetachFromUnspentAliasOutputReceived()
	Close()
}

type ChainRequests interface {
	GetRequestProcessingStatus(id iscp.RequestID) RequestProcessingStatus
	AttachToRequestProcessed(func(iscp.RequestID)) (attachID *events.Closure)
	DetachFromRequestProcessed(attachID *events.Closure)
}

type ChainTransitionEventData struct {
	VirtualState    state.VirtualStateAccess
	ChainOutput     *ledgerstate.AliasOutput
	OutputTimestamp time.Time
}

type Committee interface {
	Address() ledgerstate.Address
	Size() uint16
	Quorum() uint16
	OwnPeerIndex() uint16
	DKShare() *tcrypto.DKShare
	IsAlivePeer(peerIndex uint16) bool
	QuorumIsAlive(quorum ...uint16) bool
	PeerStatus() []*PeerStatus
	IsReady() bool
	Close()
	RunACSConsensus(value []byte, sessionID uint64, stateIndex uint32, callback func(sessionID uint64, acs [][]byte))
	GetOtherValidatorsPeerIDs() []string
	GetRandomValidators(upToN int) []string
}

type CommitteeInfo struct {
	Address       ledgerstate.Address
	Size          uint16
	Quorum        uint16
	QuorumIsAlive bool
	PeerStatus    []*PeerStatus
}

type Consensus interface {
	EnqueueStateTransitionMsg(state.VirtualStateAccess, *ledgerstate.AliasOutput, time.Time)
	EnqueueSignedResultMsg(*messages.SignedResultMsgIn)
	EnqueueSignedResultAckMsg(*messages.SignedResultAckMsgIn)
	EnqueueInclusionsStateMsg(ledgerstate.TransactionID, ledgerstate.InclusionState)
	EnqueueAsynchronousCommonSubsetMsg(msg *messages.AsynchronousCommonSubsetMsg)
	EnqueueVMResultMsg(msg *messages.VMResultMsg)
	EnqueueTimerMsg(messages.TimerTick)
	IsReady() bool
	Close()
	GetStatusSnapshot() *ConsensusInfo
	ShouldReceiveMissingRequest(req iscp.Request) bool
}

type ConsensusInfo struct {
	StateIndex uint32
	Mempool    MempoolInfo
	TimerTick  int
}

type Mempool interface {
	ReceiveRequests(reqs ...iscp.Request)
	ReceiveRequest(req iscp.Request) bool
	RemoveRequests(reqs ...iscp.RequestID)
	ReadyNow(nowis ...time.Time) []iscp.Request
	ReadyFromIDs(nowis time.Time, reqIDs ...iscp.RequestID) ([]iscp.Request, []int, bool)
	HasRequest(id iscp.RequestID) bool
	GetRequest(id iscp.RequestID) iscp.Request
	Info() MempoolInfo
	WaitRequestInPool(reqid iscp.RequestID, timeout ...time.Duration) bool // for testing
	WaitInBufferEmpty(timeout ...time.Duration) bool                       // for testing
	Close()
}

type MempoolInfo struct {
	TotalPool      int
	ReadyCounter   int
	InBufCounter   int
	OutBufCounter  int
	InPoolCounter  int
	OutPoolCounter int
}

type NodeConnection interface {
	Subscribe(addr ledgerstate.Address)
	Unsubscribe(addr ledgerstate.Address)

	AttachToTransactionReceived(*ledgerstate.AliasAddress, NodeConnectionHandleTransactionFun)
	AttachToInclusionStateReceived(*ledgerstate.AliasAddress, NodeConnectionHandleInclusionStateFun)
	AttachToOutputReceived(*ledgerstate.AliasAddress, NodeConnectionHandleOutputFun)
	AttachToUnspentAliasOutputReceived(*ledgerstate.AliasAddress, NodeConnectionHandleUnspentAliasOutputFun)

	PullState(addr *ledgerstate.AliasAddress)
	PullTransactionInclusionState(addr ledgerstate.Address, txid ledgerstate.TransactionID)
	PullConfirmedOutput(addr ledgerstate.Address, outputID ledgerstate.OutputID)
	PostTransaction(tx *ledgerstate.Transaction)

	GetMetrics() nodeconnmetrics.NodeConnectionMetrics

	DetachFromTransactionReceived(*ledgerstate.AliasAddress)
	DetachFromInclusionStateReceived(*ledgerstate.AliasAddress)
	DetachFromOutputReceived(*ledgerstate.AliasAddress)
	DetachFromUnspentAliasOutputReceived(*ledgerstate.AliasAddress)
	Close()
}

type NodeConnectionHandleInclusionStateFun func(ledgerstate.TransactionID, ledgerstate.InclusionState)

type NodeConnectionHandleOutputFun func(ledgerstate.Output)

type NodeConnectionHandleTransactionFun func(*ledgerstate.Transaction)

type NodeConnectionHandleUnspentAliasOutputFun func(*ledgerstate.AliasOutput, time.Time)

type PeerStatus struct {
	Index     int
	PeeringID string
	IsSelf    bool
	Connected bool
}

type ReadyListRecord struct {
	Request iscp.Request
	Seen    map[uint16]bool
}

type RequestProcessingStatus int

type StateManager interface {
	Ready() *ready.Ready
	EnqueueGetBlockMsg(msg *messages.GetBlockMsgIn)
	EnqueueBlockMsg(msg *messages.BlockMsgIn)
	EnqueueStateMsg(msg *messages.StateMsg)
	EnqueueOutputMsg(msg ledgerstate.Output)
	EnqueueStateCandidateMsg(state.VirtualStateAccess, ledgerstate.OutputID)
	EnqueueTimerMsg(msg messages.TimerTick)
	GetStatusSnapshot() *SyncInfo
	Close()
}

type SyncInfo struct {
	Synced                bool
	SyncedBlockIndex      uint32
	SyncedStateHash       hashing.HashValue
	SyncedStateTimestamp  time.Time
	StateOutputBlockIndex uint32
	StateOutputID         ledgerstate.OutputID
	StateOutputHash       hashing.HashValue
	StateOutputTimestamp  time.Time
}