disco

type Disco interface {
	AddPeer(pubKey wgkey.DiscoPublicKey) DiscoPeer
	SetPeers(peers map[wgkey.DiscoPublicKey][]netip.AddrPort)
	GetAllStatuses() (res map[wgkey.DiscoPublicKey]DiscoPeerStatusReadOnly)
	Send(pkt *EncryptedDiscoPacket)
	SetStatusCallback(fn func(pubKey wgkey.DiscoPublicKey, status DiscoPeerStatusReadOnly))
	Close() error
}

type DiscoPacket struct {
	Header            DiscoPacketHeader
	SrcPublicDiscoKey [32]byte
	EndpointID        uint32
	ID                uint32

	Endpoint  netip.AddrPort
	SharedKey wgkey.DiscoSharedKey
}

type DiscoPacketHeader byte

type DiscoPeer interface {
	EnqueueReceivedPacket(pkt EncryptedDiscoPacket)
	SetEndpoints(endpoints []netip.AddrPort)
	Status() DiscoPeerStatus
	Close() error
}

type DiscoPeerEndpoint interface {
	Endpoint() netip.AddrPort
	Status() DiscoPeerEndpointStatus
	SetPriority(priority ticker.Priority)
	EnqueueReceivedPacket(pkt DiscoPacket)
	ReceivePing()
	Close() error
}

type DiscoPeerEndpointStatus interface {
	Get() DiscoPeerEndpointStatusReadOnly
	NotifyStatus(fn func(status DiscoPeerEndpointStatusReadOnly))
}

type DiscoPeerEndpointStatusReadOnly struct {
	State ticker.State
	RTT   time.Duration
}

type DiscoPeerStatus interface {
	Get() DiscoPeerStatusReadOnly
	NotifyStatus(fn func(status DiscoPeerStatusReadOnly))
}

type DiscoPeerStatusReadOnly struct {
	ActiveEndpoint netip.AddrPort
	ActiveRTT      time.Duration
}

type EncryptedDiscoPacket struct {
	Header            DiscoPacketHeader
	SrcPublicDiscoKey wgkey.DiscoPublicKey
	EncryptedPayload  []byte

	Endpoint netip.AddrPort
}

type NewDiscoPeerEndpointFunc func(
	endpointID uint32,
	endpoint netip.AddrPort,
	peerPubKey wgkey.DiscoPublicKey,
	sharedKey wgkey.DiscoSharedKey,
	sender Sender,
	logger *zap.Logger,
) DiscoPeerEndpoint

type NewDiscoPeerFunc func(
	d Sender,
	privateKey wgkey.DiscoPrivateKey,
	pubKey wgkey.DiscoPublicKey,
	onClose func(),
	logger *zap.Logger,
	newEndpoint NewDiscoPeerEndpointFunc,
) DiscoPeer

type Sender interface {
	Send(pkt *EncryptedDiscoPacket)
}