pubsub

type Config struct {
	MaxPayloadSize       int
	MaxPatternsPerStream int
	MaxPatternsPerSpace  int
	PublishRps           float64
	PublishBurst         int
	WriteQueueSize       int
	DispatchQueueSize    int
	DedupSize            int
	// MaxTimestampSkew bounds how stale (or future) a received message's timestamp
	// may be before it is dropped, raising the replay bar even after dedup eviction.
	MaxTimestampSkew time.Duration
	// ResyncInterval is how often a client re-pushes its interest to space peers,
	// keeping server-side interest alive across reconnects.
	ResyncInterval time.Duration
	// PeerTTL keeps a pubsub stream's peer from being reaped by idle pool GC.
	PeerTTL time.Duration
	// DialQueueWorkers/DialQueueSize size the pool's outbound dial pool.
	DialQueueWorkers int
	DialQueueSize    int
}

type Crypto interface {
	// Encrypt returns the key id used and the ciphertext.
	Encrypt(spaceId string, payload []byte) (keyId string, encrypted []byte, err error)
	// Decrypt resolves keyId to a historical read key and decrypts.
	Decrypt(spaceId, keyId string, encrypted []byte) ([]byte, error)
}

type Deps struct {
	Membership MembershipChecker
	Crypto     Crypto
	Peers      PeerProvider // client side; may be nil on nodes
	Relay      Relay        // node side; nil on clients
	OnStatus   StatusHandler
	// Metric, if set, registers the private pool's prometheus metrics so a node
	// relaying at scale is observable. Optional.
	Metric metric.Metric
	Config Config
}

type Handler func(spaceId, topic string, identity crypto.PubKey, payload []byte)

type MembershipChecker interface {
	CheckMember(ctx context.Context, spaceId string, identity crypto.PubKey) error
}

type PeerProvider interface {
	SpacePeers(ctx context.Context, spaceId string) ([]peer.Peer, error)
}

type Relay interface {
	// IsResponsible reports whether this node is responsible for the space.
	IsResponsible(spaceId string) bool
	// IsResponsibleNode reports whether peerId is a responsible node for the space
	// (used to authorize inbound relayed publishes).
	IsResponsibleNode(spaceId, peerId string) bool
	// OtherResponsiblePeers returns the other responsible nodes, excluding self.
	OtherResponsiblePeers(ctx context.Context, spaceId string) ([]peer.Peer, error)
}

type Service interface {
	app.ComponentRunnable
	// Publish encrypts, signs and fire-and-forgets payload to the topic within the space.
	Publish(ctx context.Context, spaceId, topic string, payload []byte) error
	// Subscribe registers a local handler for a pattern and pushes the interest to
	// the space's peers. The returned func unregisters and unsubscribes.
	Subscribe(spaceId, pattern string, h Handler) (unsubscribe func(), err error)
	// SyncInterest (re)sends all local interest for the space to its current peers;
	// call after (re)connecting to a space's peers.
	SyncInterest(ctx context.Context, spaceId string) error
	// CloseSpace drops all local and serving-side interest for the space and
	// withdraws the local interest from its peers. Hosts call it on space
	// unload/close so a global service doesn't retain closed-space state.
	CloseSpace(spaceId string)
	// EvictMember drops all serving-side interest of an identity in a space,
	// enforcing DESIGN §6.4 (active drop on ACL removal). Nodes wire it to their
	// ACL-update hook. No-op on clients (they hold no serving interest).
	EvictMember(spaceId string, identity crypto.PubKey)
	// RevalidateMembers evicts every subscriber of the space whose account no
	// longer passes isMember. Nodes call it on an ACL change to cut off all
	// removed members in one pass. No-op on clients.
	RevalidateMembers(spaceId string, isMember func(account string) bool)
	// HandleStream serves an inbound PubSubStream; blocks for the stream lifetime.
	HandleStream(stream drpc.Stream) error
}

type StatusHandler func(peerId string, status *pubsubproto.Status)