rpc

type AbstractRpcClient interface {
	SendRpcMessage(msg []byte)
	RecvRpcMessage() ([]byte, bool) // blocking
}

type BrokerSubscription struct {
	AllSubs   []string            // routeids subscribed to "all" events
	ScopeSubs map[string][]string // routeids subscribed to specific scopes
	StarSubs  map[string][]string // routeids subscribed to star scope (scopes with "*" or "**" in them)
}

type BrokerType struct {
	Lock       *sync.Mutex
	Client     Client
	SubMap     map[string]*BrokerSubscription
	PersistMap map[persistKey]*persistEventWrap
}

type Client interface {
	SendEvent(routeId string, event EventType)
}

type CommandHandlerFnType = func(*RpcResponseHandler) bool

type EventListener struct {
	Lock      *sync.Mutex
	Listeners map[string][]singleListener
}

type EventType = rpctypes.EventType

type ExpMap[T any] struct {
	// contains filtered or unexported fields
}

type RpcClient struct {
	Lock               *sync.Mutex
	InputCh            chan []byte
	OutputCh           chan []byte
	CtxDoneCh          chan string // for context cancellation, value is ResId
	AuthToken          string
	RpcMap             map[string]*rpcData
	ServerImpl         RpcServerImpl
	EventListener      *EventListener
	ResponseHandlerMap map[string]*RpcResponseHandler // reqId => handler
	Debug              bool
	DebugName          string
	ServerDone         bool
}

type RpcMessage struct {
	Command   string `json:"command,omitempty"`
	ReqId     string `json:"reqid,omitempty"`
	ResId     string `json:"resid,omitempty"`
	Timeout   int64  `json:"timeout,omitempty"`
	Route     string `json:"route,omitempty"`     // to route/forward requests to alternate servers
	AuthToken string `json:"authtoken,omitempty"` // needed for routing unauthenticated requests (RpcMultiProxy)
	Source    string `json:"source,omitempty"`    // source route id
	Cont      bool   `json:"cont,omitempty"`      // flag if additional requests/responses are forthcoming
	Cancel    bool   `json:"cancel,omitempty"`    // used to cancel a streaming request or response (sent from the side that is not streaming)
	Error     string `json:"error,omitempty"`
	DataType  string `json:"datatype,omitempty"`
	Data      any    `json:"data,omitempty"`
}

type RpcMethodDecl struct {
	Command                 string
	CommandType             string
	MethodName              string
	CommandDataType         reflect.Type
	DefaultResponseDataType reflect.Type
}

type RpcOpts struct {
	Timeout        int64  `json:"timeout,omitempty"`
	NoResponse     bool   `json:"noresponse,omitempty"`
	Route          string `json:"route,omitempty"`
	StreamCancelFn func() `json:"-"` // this is an *output* parameter, set by the handler
}

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

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

type RpcServerImpl interface {
	RpcServerImpl()
}

type SubscriptionRequest = rpctypes.SubscriptionRequest

type WshRouter struct {
	Lock             *sync.Mutex
	RouteMap         map[string]AbstractRpcClient // routeid => client
	UpstreamClient   AbstractRpcClient            // upstream client (if we are not the terminal router)
	AnnouncedRoutes  map[string]string            // routeid => local routeid
	RpcMap           map[string]*routeInfo        // rpcid => routeinfo
	SimpleRequestMap map[string]chan *RpcMessage  // simple reqid => response channel
	InputCh          chan msgAndRoute
}

type WshRpcProxy struct {
	Lock         *sync.Mutex
	ToRemoteCh   chan []byte
	FromRemoteCh chan []byte
}