caches

type AccountDataUpdate struct {
	AccountData []state.AccountData
}

type CacheFinder interface {
	CacheForUser(userID string) *UserCache
}

type DeviceDataUpdate struct {
}

type DeviceEventsUpdate struct {
}

type EventData struct {
	Event     json.RawMessage
	RoomID    string
	EventType string
	StateKey  *string
	Content   gjson.Result
	Timestamp uint64
	Sender    string
	// TransactionID is the unsigned.transaction_id field in the event as stored in the
	// syncv3_events table, or the empty string if there is no such field.
	//
	// We may see the event on poller A without a transaction_id, and then later on
	// poller B with a transaction_id. If this happens, we make a temporary note of the
	// transaction_id in the syncv3_txns table, but do not edit the persisted event.
	// This means that this field is not authoritative; we only include it here as a
	// hint to avoid unnecessary waits for V2TransactionID payloads.
	TransactionID string

	// the number of joined users in this room. Use this value and don't try to work it out as you
	// may get it wrong due to Synapse sending duplicate join events(!) This value has them de-duped
	// correctly.
	JoinCount   int
	InviteCount int

	// NID is the nid for this event; or a non-nid sentinel value. Current sentinels are
	//  - PosAlwaysProcess and PosDoNotProcess, for things outside the event timeline
	//    e.g invites; and
	//  - `0` used by UserCache.OnRegistered to inject space children events at startup.
	//    It's referenced in ConnState.OnRoomUpdateand UserCache.OnSpaceUpdate
	NID int64

	// Update consumers will usually ignore updates with a NID < what they have seen before for this room.
	// However, in some cases, we want to force the consumer to process this event even though the NID
	// may be < what they have seen before. Currently, we use this to force consumers to process invites
	// for a connected client, as the invite itself has no event NID due to the proxy not being in the room yet.
	AlwaysProcess bool

	// Flag set when this event should force the room contents to be resent e.g
	// state res, initial join, etc
	ForceInitial bool
}

type GlobalCache struct {
	// LoadJoinedRoomsOverride allows tests to mock out the behaviour of LoadJoinedRooms.
	LoadJoinedRoomsOverride func(userID string) (pos int64, joinedRooms map[string]*internal.RoomMetadata, joinTimings map[string]internal.EventMetadata, latestNIDs map[string]int64, err error)
	// contains filtered or unexported fields
}

type InviteData struct {
	InviteState          []json.RawMessage
	Heroes               []internal.Hero
	InviteEvent          *EventData
	NameEvent            string // the content of m.room.name, NOT the calculated name
	AvatarEvent          string // the content of m.room.avatar, NOT the calculated avatar
	CanonicalAlias       string
	LastMessageTimestamp uint64
	Encrypted            bool
	IsDM                 bool
	RoomType             string
	// contains filtered or unexported fields
}

type InviteUpdate struct {
	RoomUpdate
	InviteData InviteData
}

type JoinChecker interface {
	IsUserJoined(userID, roomID string) bool
}

type ReceiptUpdate struct {
	RoomUpdate
	Receipt internal.Receipt
}

type RoomAccountDataUpdate struct {
	RoomUpdate
	AccountData []state.AccountData
}

type RoomEventUpdate struct {
	RoomUpdate
	EventData *EventData
}

type RoomUpdate interface {
	Update
	RoomID() string
	GlobalRoomMetadata() *internal.RoomMetadata
	UserRoomMetadata() *UserRoomData
}

type TransactionIDFetcher interface {
	TransactionIDForEvents(userID, deviceID string, eventIDs []string) (eventIDToTxnID map[string]string)
}

type TypingUpdate struct {
	RoomUpdate
}

type UnreadCountUpdate struct {
	RoomUpdate
	HasCountDecreased bool
}

type Update interface {
	Type() string
}

type UserCache struct {
	LazyLoadTimelinesOverride func(loadPos int64, roomIDs []string, maxTimelineEvents int) map[string]state.LatestEvents
	UserID                    string
	// contains filtered or unexported fields
}

type UserCacheListener interface {
	// Called when there is an update affecting a room e.g new event, unread count update, room account data.
	// Type-cast to find out what the update is about.
	OnRoomUpdate(ctx context.Context, up RoomUpdate)
	// Called when there is an update affecting this user but not in the room e.g global account data, presence.
	// Type-cast to find out what the update is about.
	OnUpdate(ctx context.Context, up Update)
}

type UserCacheStore interface {
	LatestEventsInRooms(userID string, roomIDs []string, to int64, limit int) (map[string]*state.LatestEvents, error)
	GetClosestPrevBatch(roomID string, eventNID int64) (prevBatch string)
}

type UserRoomData struct {
	IsDM              bool
	IsInvite          bool
	HasLeft           bool
	NotificationCount int
	HighlightCount    int
	Invite            *InviteData

	// TODO: should CanonicalisedName really be in RoomConMetadata? It's only set in SetRoom AFAICS
	CanonicalisedName string // stripped leading symbols like #, all in lower case

	// ResolvedAvatarURL is the avatar that should be displayed to this user to
	// represent this room. The empty string means that this room has no avatar.
	// Avatars set in m.room.avatar take precedence; if this is missing and the room is
	// a DM with one other user joined or invited, we fall back to that user's
	// avatar (if any) as specified in their membership event in that room.
	ResolvedAvatarURL string

	// Spaces is the set of room IDs of spaces that this room is part of.
	Spaces map[string]struct{}
	// Map of tag to order float.
	// See https://spec.matrix.org/latest/client-server-api/#room-tagging
	Tags map[string]float64
	// JoinTiming tracks our latest join to the room, excluding profile changes.
	JoinTiming internal.EventMetadata
}