extensions

type AccountDataRequest struct {
	Core
}

type AccountDataResponse struct {
	Global []json.RawMessage            `json:"global,omitempty"`
	Rooms  map[string][]json.RawMessage `json:"rooms,omitempty"`
	// contains filtered or unexported fields
}

type Context struct {
	*Handler
	// RoomIDToTimeline is a map from room IDs to slices of event IDs. The keys are the
	// rooms which
	// - have seen new events since the last sync request, and
	// - the client is subscribed to (via a list or a room subscription).
	// The values are the event IDs at the end of the room "timeline", ordered from
	// oldest to newest, as determined by the core sliding sync protocol.
	// TODO: can the timelines be "gappy" like a v2 sync timeline?
	RoomIDToTimeline map[string][]string
	// IsInitial is true if this sync is requesting a snapshot of current client state
	// (pos = 0, "initial sync") and false otherwise (pos > 0, "incremental sync").
	IsInitial bool
	UserID    string
	DeviceID  string
	// Map from room IDs to list names. Keys are the room IDs of all rooms currently
	// visible in at least one sliding window. Values are the names of the lists that
	// enclose those sliding windows. Values should be nonnil and nonempty, and may
	// contain multiple list names.
	RoomIDsToLists map[string][]string
	// AllLists is the slice of list names provided to the Sliding Window API.
	AllLists []string
	// AllSubscribedRooms is the slice of room IDs provided to the Room Subscription API.
	AllSubscribedRooms []string
}

type Core struct {
	// All fields are optional, with nil meaning "not specified".
	Enabled *bool    `json:"enabled"`
	Lists   []string `json:"lists"`
	Rooms   []string `json:"rooms"`
}

type E2EEDeviceList struct {
	Changed []string `json:"changed"`
	Left    []string `json:"left"`
}

type E2EEFetcher interface {
	DeviceData(context context.Context, userID, deviceID string, isInitial bool) *internal.DeviceData
}

type E2EERequest struct {
	Core
}

type E2EEResponse struct {
	OTKCounts        map[string]int  `json:"device_one_time_keys_count,omitempty"`
	DeviceLists      *E2EEDeviceList `json:"device_lists,omitempty"`
	FallbackKeyTypes *[]string       `json:"device_unused_fallback_key_types,omitempty"`
}

type GenericRequest interface {
	// Name provides a name to identify the kind of request. At present, it's only
	// used to name opentracing spans; this isn't end-user visible.
	Name() string
	// Returns the value of the `enabled` JSON key. nil for "not specified".
	IsEnabled() *bool
	// Returns the value of the `lists` JSON key. nil for "not specified".
	OnlyLists() []string
	// Returns the value of the `rooms` JSON key. nil for "not specified".
	OnlyRooms() []string
	// InterpretAsInitial interprets this as an initial request rather than a delta, and
	// overwrites fields accordingly. This can be useful when fields have default
	// values, but is a little ugly. Use sparingly.
	InterpretAsInitial()
	// Overwrite fields in the request by side-effecting on this struct.
	ApplyDelta(next GenericRequest)
	// ProcessInitial provides a means for extensions to return data to clients immediately.
	// If an implementation wants to do so, put the response into *Response (and ensure
	// that GenericResponse.HasData returns true).
	//
	// This is called for every request before going into a live stream loop. By "every
	// request" we mean both initial and incremental syncs; this function gets call
	// multiple times over the lifetime of a connection. (Read Context.IsInitial to see
	// if we are serving an initial or incremental sync.)
	ProcessInitial(ctx context.Context, res *Response, extCtx Context)
	// Process a live event, /aggregating/ the response in *Response. This function can be called
	// multiple times per sync loop as the conn buffer is consumed.
	AppendLive(ctx context.Context, res *Response, extCtx Context, up caches.Update)
}

type GenericResponse interface {
	// HasData determines if there is enough data in the response for it to be
	// meaningful or useful for the client. If so, we eagerly return this response
	// (even if we are aware of other updates). The parameter isInitial is true if and
	// only if this response is to an initial sync request; this allows the
	// implementation to send out a "fuller" update to an initial sync than it would
	// for an incremental sync.
	HasData(isInitial bool) bool
}

type Handler struct {
	Store       *state.Storage
	E2EEFetcher E2EEFetcher
	GlobalCache *caches.GlobalCache
}

type HandlerInterface interface {
	Handle(ctx context.Context, req Request, extCtx Context) (res Response)
	HandleLiveUpdate(ctx context.Context, update caches.Update, req Request, res *Response, extCtx Context)
}

type ReceiptsRequest struct {
	Core
}

type ReceiptsResponse struct {
	// room_id -> m.receipt ephemeral event
	Rooms map[string]json.RawMessage `json:"rooms,omitempty"`
}

type Request struct {
	ToDevice    *ToDeviceRequest    `json:"to_device"`
	E2EE        *E2EERequest        `json:"e2ee"`
	AccountData *AccountDataRequest `json:"account_data"`
	Typing      *TypingRequest      `json:"typing"`
	Receipts    *ReceiptsRequest    `json:"receipts"`
}

type Response struct {
	ToDevice    *ToDeviceResponse    `json:"to_device,omitempty"`
	E2EE        *E2EEResponse        `json:"e2ee,omitempty"`
	AccountData *AccountDataResponse `json:"account_data,omitempty"`
	Typing      *TypingResponse      `json:"typing,omitempty"`
	Receipts    *ReceiptsResponse    `json:"receipts,omitempty"`
}

type ToDeviceRequest struct {
	Core
	Limit int    `json:"limit"` // max number of to-device messages per response
	Since string `json:"since"` // since token
}

type ToDeviceResponse struct {
	NextBatch string            `json:"next_batch"`
	Events    []json.RawMessage `json:"events,omitempty"`
}

type TypingRequest struct {
	Core
}

type TypingResponse struct {
	Rooms map[string]json.RawMessage `json:"rooms,omitempty"`
}