control

type ClientAuthenticateRequest struct {
	Proto        model.ClientNextProto
	Token        string
	Addr         net.Addr
	BuildVersion string
}

type ClientAuthentication []byte

type ClientAuthenticator interface {
	Authenticate(req ClientAuthenticateRequest) (ClientAuthentication, error)
	Validate(auth ClientAuthentication, endpoint model.Endpoint, role model.Role) (model.Endpoint, error)
}

type ClientConnKey struct {
	ID ksuid.KSUID `json:"id"`
}

type ClientConnValue struct {
	Authentication ClientAuthentication `json:"authentication"`
	Addr           string               `json:"addr"`
}

type ClientPeerKey struct {
	Endpoint model.Endpoint `json:"endpoint"`
	Role     model.Role     `json:"role"`
	ID       ksuid.KSUID    `json:"id"` // TODO consider using the server cert key
}

type ClientPeerValue struct {
	Peer *pbclient.Peer `json:"peer"`
}

type ClientRelays interface {
	Client(ctx context.Context, endpoint model.Endpoint, role model.Role, cert *x509.Certificate, auth ClientAuthentication,
		notify func(map[ksuid.KSUID]relayCacheValue) error) error
}

type Config struct {
	ClientsIngress []Ingress
	ClientsAuth    ClientAuthenticator

	RelaysIngress []Ingress
	RelaysAuth    RelayAuthenticator

	Stores Stores

	Logger *slog.Logger
}

type ConfigKey string

type ConfigValue struct {
	Int64  int64  `json:"int64,omitempty"`
	String string `json:"string,omitempty"`
	Bytes  []byte `json:"bytes,omitempty"`
}

type Ingress struct {
	Addr  *net.UDPAddr
	TLS   *tls.Config
	Restr restr.IP
}

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

type RelayAuthenticateRequest struct {
	Proto        model.RelayNextProto
	Token        string
	Addr         net.Addr
	BuildVersion string
}

type RelayAuthentication []byte

type RelayAuthenticator interface {
	Authenticate(req RelayAuthenticateRequest) (RelayAuthentication, error)
	Allow(reAuth RelayAuthentication, clAuth ClientAuthentication, endpoint model.Endpoint) (bool, error)
}

type RelayClientKey struct {
	Endpoint model.Endpoint `json:"endpoint"`
	Role     model.Role     `json:"role"`
	Key      model.Key      `json:"key"`
}

type RelayClientValue struct {
	Cert           *x509.Certificate    `json:"cert"`
	Authentication ClientAuthentication `json:"authentication"`
}

type RelayConnKey struct {
	ID ksuid.KSUID `json:"id"`
}

type RelayConnValue struct {
	Authentication RelayAuthentication `json:"authentication"`
	Hostport       model.HostPort      `json:"hostport"`
	Hostports      []model.HostPort    `json:"hostports"`
}

type RelayEndpointKey struct {
	Endpoint model.Endpoint `json:"endpoint"`
}

type RelayEndpointValue struct {
	Cert *x509.Certificate `json:"cert"`
}

type RelayServerKey struct {
	Endpoint model.Endpoint `json:"endpoint"`
	RelayID  ksuid.KSUID    `json:"relay_id"`
}

type RelayServerValue struct {
	Hostport  model.HostPort    `json:"hostport"`
	Hostports []model.HostPort  `json:"hostports"`
	Cert      *x509.Certificate `json:"cert"`
}

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

type Status struct {
	ServerID string         `json:"server_id"`
	Clients  []StatusClient `json:"clients"`
	Peers    []StatusPeer   `json:"peers"`
	Relays   []StatusRelay  `json:"relays"`
}

type StatusClient struct {
	ID   ksuid.KSUID `json:"id"`
	Addr string      `json:"addr"`
}

type StatusPeer struct {
	ID       ksuid.KSUID    `json:"id"`
	Role     model.Role     `json:"role"`
	Endpoint model.Endpoint `json:"endpoint"`
}

type StatusRelay struct {
	ID        ksuid.KSUID `json:"id"`
	Hostports []string    `json:"hostport"`
}

type Stores interface {
	Config() (logc.KV[ConfigKey, ConfigValue], error)

	ClientConns() (logc.KV[ClientConnKey, ClientConnValue], error)
	ClientPeers() (logc.KV[ClientPeerKey, ClientPeerValue], error)

	RelayConns() (logc.KV[RelayConnKey, RelayConnValue], error)
	RelayClients() (logc.KV[RelayClientKey, RelayClientValue], error)
	RelayEndpoints(id ksuid.KSUID) (logc.KV[RelayEndpointKey, RelayEndpointValue], error)
	RelayServers() (logc.KV[RelayServerKey, RelayServerValue], error)
	RelayServerOffsets() (logc.KV[RelayConnKey, int64], error)
}