p2pcommon

type ActorService interface {
	// TellRequest send actor request, which does not need to get return value, and forget it.
	TellRequest(actorName string, msg interface{})
	// SendRequest send actor request, and the response is expected to go back asynchronously.
	SendRequest(actorName string, msg interface{})
	// CallRequest send actor request and wait the handling of that message to finished,
	// and get return value.
	CallRequest(actorName string, msg interface{}, timeout time.Duration) (interface{}, error)
	// CallRequestDefaultTimeout is CallRequest with default timeout
	CallRequestDefaultTimeout(actorName string, msg interface{}) (interface{}, error)

	// FutureRequest send actor request and get the Future object to get the state and return value of message
	FutureRequest(actorName string, msg interface{}, timeout time.Duration) *actor.Future
	// FutureRequestDefaultTimeout is FutureRequest with default timeout
	FutureRequestDefaultTimeout(actorName string, msg interface{}) *actor.Future

	GetChainAccessor() types.ChainAccessor
}

type AergoVersion = semver.Version

type AgentCertificateV1 struct {
	Version      uint32
	BPID         types.PeerID
	BPPubKey     *btcec.PublicKey
	CreateTime   time.Time
	ExpireTime   time.Time
	AgentID      types.PeerID
	AgentAddress []string
	Signature    *btcec.Signature
}

type AsyncHandler interface {
	HandleOrNot(msg Message, msgBody MessageBody) bool
	Handle(msg Message, msgBody MessageBody, ttl time.Duration)
}

type AttrModifier struct {
	ID   types.PeerID
	Role types.PeerRole
}

type CertificateManager interface {
	PeerEventListener

	Start()
	Stop()

	// methods for bp
	// CreateCertificate create certificate for the agent. It will return ErrInvalidRole error if local peer is not block producer
	CreateCertificate(remoteMeta PeerMeta) (*AgentCertificateV1, error)

	// methods for agents
	// GetProducers return list of peer id of which this agent is charge.
	GetProducers() []types.PeerID
	// GetCertificates returns my certificates
	GetCertificates() []*AgentCertificateV1
	// AddCertificate add to my certificate list
	AddCertificate(cert *AgentCertificateV1)

	CanHandle(bpID types.PeerID) bool
}

type ConnWorkResult struct {
	Inbound bool
	Seq     uint32
	// TargetPeer is nil if Inbound is true
	TargetPeer *WaitingPeer
	Meta       PeerMeta
	ConnInfo   RemoteInfo

	P2PVer uint32
	Result error
}

type HSHandler interface {
	// Handle peer handshake till ttl, and return msgrw for this connection, and status of remote peer.
	Handle(s io.ReadWriteCloser, ttl time.Duration) (*HandshakeResult, error)
}

type HSHandlerFactory interface {
	CreateHSHandler(outbound bool, pid types.PeerID) HSHandler
}

type HSHeadReq struct {
	Magic uint32
	// Versions are p2p versions which the connecting peer can support.
	Versions []P2PVersion
}

type HSHeadResp struct {
	// Magic will be same as the magic in HSHeadReq if wire handshake is successful, or 0 if not.
	Magic uint32
	// RespCode is different meaning by value of Magic. It is p2p version which listening peer will use, if wire handshake is successful, or errCode otherwise.
	RespCode uint32
}

type HSHeader struct {
	Magic   uint32
	Version P2PVersion
}

type HSRespCode = uint32

type HandlerAdvice interface {
	PreHandle()
	PostHandle(msg Message, msgBody MessageBody)
}

type HandshakeResult struct {
	MsgRW MsgReadWriter

	Meta          PeerMeta
	BestBlockHash types.BlockID
	BestBlockNo   types.BlockNo
	Hidden        bool
	Certificates  []*AgentCertificateV1
}

type InternalService interface {
	//NetworkTransport
	SelfMeta() PeerMeta
	SelfNodeID() types.PeerID
	LocalSettings() LocalSettings

	// accessors of other modules
	GetChainAccessor() types.ChainAccessor

	CertificateManager() CertificateManager

	RoleManager() PeerRoleManager
}

type ListManager interface {
	Start()
	Stop()

	IsBanned(addr string, pid types.PeerID) (bool, time.Time)

	// RefineList update white/blacklist
	RefineList()
	Summary() map[string]interface{}
}

type LocalSettings struct {
	AgentID       types.PeerID
	InternalZones []*net.IPNet
}

type Message interface {
	Subprotocol() SubProtocol

	// Length is length of payload
	Length() uint32

	// Timestamp is when this message was created with unixNano format
	Timestamp() int64

	// ID is 16 bytes unique identifier
	ID() MsgID

	// OriginalID is message id of request which trigger this message. it will be all zero, if message is request or notice.
	OriginalID() MsgID

	// Payload is MessageBody struct, marshaled by google protocol buffer v3. object is determined by Subprotocol
	Payload() []byte
}

type MessageBody interface {
	proto.Message
}

type MessageHandler interface {
	AddAdvice(advice HandlerAdvice)
	ParsePayload([]byte) (MessageBody, error)
	CheckAuth(msg Message, msgBody MessageBody) error
	Handle(msg Message, msgBody MessageBody)
	PreHandle()
	PostHandle(msg Message, msgBody MessageBody)
}

type MessageValue struct {
	// contains filtered or unexported fields
}

type MoFactory interface {
	NewMsgRequestOrder(expectResponse bool, protocolID SubProtocol, message MessageBody) MsgOrder
	NewMsgBlockRequestOrder(respReceiver ResponseReceiver, protocolID SubProtocol, message MessageBody) MsgOrder
	NewMsgResponseOrder(reqID MsgID, protocolID SubProtocol, message MessageBody) MsgOrder
	NewMsgBlkBroadcastOrder(noticeMsg *types.NewBlockNotice) MsgOrder
	NewMsgTxBroadcastOrder(noticeMsg *types.NewTransactionsNotice) MsgOrder
	NewMsgBPBroadcastOrder(noticeMsg *types.BlockProducedNotice) MsgOrder
	NewRaftMsgOrder(msgType raftpb.MessageType, raftMsg *raftpb.Message) MsgOrder
	NewTossMsgOrder(orgMsg Message) MsgOrder
}

type MsgID [IDLength]byte

type MsgIOListener interface {
	OnRead(protocol SubProtocol, read int)
	OnWrite(protocol SubProtocol, write int)
}

type MsgOrder interface {
	GetMsgID() MsgID
	// Timestamp is unit time value
	Timestamp() int64
	IsRequest() bool
	IsNeedSign() bool
	GetProtocolID() SubProtocol

	// SendTo send message to remote peer. it return err if write fails, or nil if write is successful or ignored.
	SendTo(p RemotePeer) error
	CancelSend(pi RemotePeer)
}

type MsgReadWriter interface {
	ReadMsg() (Message, error)
	WriteMsg(msg Message) error
	Close() error

	AddIOListener(l MsgIOListener)
}

type MsgSigner interface {
	// signMsg calculate signature and fill related fields in msg(peerID, pubkey, signature or etc)
	SignMsg(msg *types.P2PMessage) error
	// verifyMsg check signature is valid
	VerifyMsg(msg *types.P2PMessage, senderID types.PeerID) error
}

type NTContainer interface {
	GetNetworkTransport() NetworkTransport

	// GenesisChainID return inititial chainID of current chain.
	GenesisChainID() *types.ChainID
	SelfMeta() PeerMeta
}

type NetworkTransport interface {
	core.Host
	Start() error
	Stop() error

	SelfMeta() PeerMeta

	GetAddressesOfPeer(peerID types.PeerID) []string

	// AddStreamHandler wrapper function which call host.SetStreamHandler after transport is initialized, this method is for preventing nil error.
	AddStreamHandler(pid core.ProtocolID, handler network.StreamHandler)

	GetOrCreateStream(meta PeerMeta, protocolIDs ...core.ProtocolID) (core.Stream, error)
	GetOrCreateStreamWithTTL(meta PeerMeta, ttl time.Duration, protocolIDs ...core.ProtocolID) (core.Stream, error)

	FindPeer(peerID types.PeerID) bool
	ClosePeerConnection(peerID types.PeerID) bool
}

type P2PVersion uint32

type PeerAccessor interface {
	// SelfMeta returns peerid, ipaddress and port of server itself
	SelfMeta() PeerMeta

	GetPeerBlockInfos() []types.PeerBlockInfo
	GetPeer(ID types.PeerID) (RemotePeer, bool)
}

type PeerEventListener interface {
	OnPeerConnect(pid types.PeerID)
	OnPeerDisconnect(peer RemotePeer)
}

type PeerFactory interface {
	CreateRemotePeer(remoteInfo RemoteInfo, seq uint32, rw MsgReadWriter) RemotePeer
}

type PeerFinder interface {
	PeerEventListener

	// Check if it need to discover more peers and send query request to polaris or other peers if needed.
	CheckAndFill()
}

type PeerManager interface {
	AddPeerEventListener(l PeerEventListener)

	Start() error
	Stop() error

	//NetworkTransport
	SelfMeta() PeerMeta
	SelfNodeID() types.PeerID

	// AddNewPeer connect to peer. It will reset reconnect schedule and try to connect immediately if this peer is in reconnect cooltime.
	AddNewPeer(meta PeerMeta)
	// Remove peer from peer list. Peer dispose relative resources and stop itself, and then call PeerManager.RemovePeer
	RemovePeer(peer RemotePeer)
	UpdatePeerRole(changes []AttrModifier)

	NotifyPeerAddressReceived([]PeerMeta)

	// GetPeer return registered(handshaked) remote peer object. It is thread safe
	GetPeer(ID types.PeerID) (RemotePeer, bool)
	// GetPeers return all registered(handshaked) remote peers. It is thread safe
	GetPeers() []RemotePeer
	GetPeerAddresses(noHidden bool, showSelf bool) []*message.PeerInfo

	GetPeerBlockInfos() []types.PeerBlockInfo

	AddDesignatedPeer(meta PeerMeta)
	RemoveDesignatedPeer(peerID types.PeerID)
	ListDesignatedPeers() []PeerMeta
}

type PeerMeta struct {
	ID types.PeerID
	// AcceptedRole is the role that the remote peer claims: the local peer may not admit it, and only admits it when there is a proper proof, such as vote result in chain or AgentCertificate.
	Role types.PeerRole
	// ProducerIDs is a list of block producer IDs produced by this peer if the peer is BP, and if it is Agent, it is a list of block producer IDs that this peer acts as.
	ProducerIDs []types.PeerID
	// Address is advertised address to which other peer can connect.
	Addresses []types.Multiaddr
	// Version is build version of binary
	Version string
	Hidden  bool // Hidden means that meta info of this peer will not be sent to other peers when getting peer list

}

type PeerRoleManager interface {
	UpdateBP(toAdd []types.PeerID, toRemove []types.PeerID)

	// SelfRole returns role of this peer itself
	SelfRole() types.PeerRole
	// GetRole returns role of remote peer
	GetRole(pid types.PeerID) types.PeerRole
	// FilterBPNoticeReceiver selects target peers with the appropriate role and sends them a BlockProducedNotice
	FilterBPNoticeReceiver(block *types.Block, pm PeerManager, targetZone PeerZone) []RemotePeer

	// FilterNewBlockNoticeReceiver selects target peers with the appropriate role and sends them a NewBlockNotice
	FilterNewBlockNoticeReceiver(block *types.Block, pm PeerManager) []RemotePeer
}

type PeerZone bool

type RemoteConn struct {
	IP       net.IP
	Port     uint32
	Outbound bool
}

type RemoteInfo struct {
	Meta       PeerMeta
	Connection RemoteConn

	Designated bool // Designated means this peer is designated in config file and connect to in startup phase
	Hidden     bool // Hidden means that meta info of this peer will not be sent to other peers when getting peer list

	// AcceptedRole is role as which the local peer treat the remote peer
	AcceptedRole types.PeerRole
	Certificates []*AgentCertificateV1
	Zone         PeerZone
}

type RemotePeer interface {
	ID() types.PeerID
	RemoteInfo() RemoteInfo
	Meta() PeerMeta
	ManageNumber() uint32
	Name() string
	Version() string
	AcceptedRole() types.PeerRole
	ChangeRole(role types.PeerRole)

	AddMessageHandler(subProtocol SubProtocol, handler MessageHandler)

	State() types.PeerState
	// LastStatus returns last observed status of remote peer. this value will be changed by notice, or ping
	LastStatus() *types.LastBlockStatus

	RunPeer()
	Stop()

	SendMessage(msg MsgOrder)
	SendAndWaitMessage(msg MsgOrder, ttl time.Duration) error

	PushTxsNotice(txHashes []types.TxID)

	ConsumeRequest(msgID MsgID)
	GetReceiver(id MsgID) ResponseReceiver

	// updateBlkCache add hash to block cache and return true if this hash already exists.
	UpdateBlkCache(blkHash types.BlockID, blkNumber types.BlockNo) bool
	// updateTxCache add hashes to transaction cache and return newly added hashes.
	UpdateTxCache(hashes []types.TxID) []types.TxID
	// updateLastNotice change estimate of the last status of remote peer
	UpdateLastNotice(blkHash types.BlockID, blkNumber types.BlockNo)

	// TODO
	MF() MoFactory

	// AddCertificate add to my certificate list
	AddCertificate(cert *AgentCertificateV1)
}

type ReportType int

type ResponseReceiver func(Message, MessageBody) bool

type SubProtocol uint32

type SyncManager interface {
	// handle notice from bp
	HandleBlockProducedNotice(peer RemotePeer, block *types.Block)
	// handle notice from other node
	HandleNewBlockNotice(peer RemotePeer, data *types.NewBlockNotice)
	HandleGetBlockResponse(peer RemotePeer, msg Message, resp *types.GetBlockResponse)
	HandleNewTxNotice(peer RemotePeer, hashes []types.TxID, data *types.NewTransactionsNotice)
}

type TxNoticeTracer interface {
	RegisterTxNotice(txIDs []types.TxID, cnt int, alreadySent []types.PeerID)
	ReportSend(txIDs []types.TxID, peerID types.PeerID)
	ReportNotSend(txIDs []types.TxID, cnt int)
}

type VersionedHandshaker interface {
	DoForOutbound(ctx context.Context) (*HandshakeResult, error)
	DoForInbound(ctx context.Context) (*HandshakeResult, error)
	GetMsgRW() MsgReadWriter
}

type VersionedManager interface {
	FindBestP2PVersion(versions []P2PVersion) P2PVersion
	GetVersionedHandshaker(version P2PVersion, peerID types.PeerID, rwc io.ReadWriteCloser) (VersionedHandshaker, error)

	GetBestChainID() *types.ChainID
	GetChainID(no types.BlockNo) *types.ChainID
}

type WaitingPeer struct {
	Meta       PeerMeta
	Designated bool
	TrialCnt   int
	NextTrial  time.Time

	LastResult error
}

type WaitingPeerManager interface {
	PeerEventListener
	// OnDiscoveredPeers is called when response of discover query came from polaris or other peer.
	// It returns the count of previously unknown peers.
	OnDiscoveredPeers(metas []PeerMeta) int
	// OnWorkDone
	OnWorkDone(result ConnWorkResult)

	CheckAndConnect()

	InstantConnect(meta PeerMeta)

	OnInboundConn(s network.Stream)
}