control

type ClientAuthenticateRequest struct {
	Proto        model.ClientControlNextProto
	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 ClientID `json:"id"`
}

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

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

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

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

type ClientRelays interface {
	Client(ctx context.Context, endpoint model.Endpoint, role model.Role, cert *x509.Certificate, auth ClientAuthentication,
		notify func(map[RelayID]relayCacheValue) error) error
	Directs(ctx context.Context, endpoint model.Endpoint, role model.Role, cert *x509.Certificate, auth ClientAuthentication,
		notify func(map[RelayID]*pbclient.DirectRelay) 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.RelayControlNextProto
	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 RelayID `json:"id"`
}

type RelayConnValue struct {
	Authentication RelayAuthentication `json:"authentication"`
	Hostports      []model.HostPort    `json:"hostports"`
	Metadata       string              `json:"metadata"`
}

type RelayDirectValue struct {
	Authentication        RelayAuthentication `json:"authentication"`
	Hostports             []model.HostPort    `json:"hostports"`
	Metadata              string              `json:"metadata"`
	Certificate           *x509.Certificate   `json:"certificate"`
	AuthenticationSealKey *[32]byte           `json:"authentication-seal-key"`
}

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

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

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

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

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

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

type Status struct {
	BuildVersion string `json:"build-version"`

	ClientIngresses []StatusIngress           `json:"client-ingresses"`
	Clients         map[string]StatusClient   `json:"clients"`
	Endpoints       map[string]StatusEndpoint `json:"endpoints"`

	RelayServerID  string                 `json:"relay-server-id"`
	RelayIngresses []StatusIngress        `json:"relay-ingresses"`
	Relays         map[string]StatusRelay `json:"relays"`
}

type StatusClient struct {
	ID       ClientID `json:"id"`
	Address  string   `json:"address"`
	Metadata string   `json:"metadata"`
}

type StatusEndpoint struct {
	Endpoint     model.Endpoint `json:"endpoint"`
	Destinations []ClientID     `json:"destinations"`
	Sources      []ClientID     `json:"sources"`
}

type StatusIngress struct {
	Address      string   `json:"address"`
	Restrictions restr.IP `json:"restrictions"`
}

type StatusRelay struct {
	ID        RelayID  `json:"id"`
	Hostports []string `json:"hostport"`
	Metadata  string   `json:"metadata"`
}

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 RelayID) (logc.KV[RelayEndpointKey, RelayEndpointValue], error)
	RelayServers() (logc.KV[RelayServerKey, RelayServerValue], error)
	RelayServerOffsets() (logc.KV[RelayConnKey, int64], error)
	RelayDirects() (logc.KV[RelayConnKey, RelayDirectValue], error)
}