control

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

type ClientAuthentication []byte

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

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

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

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

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

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

type Config struct {
	Cert tls.Certificate

	ClientsAddr  *net.UDPAddr
	ClientsAuth  ClientAuthenticator
	ClientsRestr restr.IP

	RelaysAddr  *net.UDPAddr
	RelaysAuth  RelayAuthenticator
	RelaysRestr restr.IP

	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 RelayAuthenticateRequest struct {
	Proto        model.RelayToControlProto
	Token        string
	Addr         net.Addr
	BuildVersion string
}

type RelayAuthentication []byte

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

type RelayClientKey struct {
	Forward model.Forward `json:"forward"`
	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"`
}

type RelayForwardKey struct {
	Forward model.Forward `json:"forward"`
}

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

type RelayServerKey struct {
	Forward model.Forward `json:"forward"`
	RelayID ksuid.KSUID   `json:"relay_id"`
}

type RelayServerValue struct {
	Hostport model.HostPort    `json:"hostport"`
	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"`
	Forward model.Forward `json:"forward"`
}

type StatusRelay struct {
	ID       ksuid.KSUID `json:"id"`
	Hostport 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)
	RelayForwards(id ksuid.KSUID) (logc.KV[RelayForwardKey, RelayForwardValue], error)
	RelayServers() (logc.KV[RelayServerKey, RelayServerValue], error)
	RelayServerOffsets() (logc.KV[RelayConnKey, int64], error)
}