service

type AllChatUsersStore interface {

	// AllChatUsers returns all online users which are currently using chat.
	AllChatUsers(ctx context.Context) ([]OnlineChatUser, error)
}

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

type BridgeBuilder struct {
	Handler BridgeEventHandler
	Logger  *logrus.Logger
	Storage BridgeStorage
}

type BridgeEvent struct {
	// Name is event type.
	Name BridgeEventType `json:"type"`

	// ID is unique event identifier.
	ID string `json:"id"`

	// CreatedAt is date of event creation expressed
	// as unix epoch.
	CreatedAt int64 `json:"createdAt"`

	// Headers holds event metadata such as. For
	// example: one's could use headers to store
	// event data content type.
	Headers BridgeHeaders `json:"headers"`

	// Data sent or stored with event.
	Data []byte `json:"data"`
}

type BridgeEventHandler interface {
	// EventHook can implement any generic operation which uses
	// data from BridgeEvent type.
	EventHook(context.Context, BridgeEvent)
}

type BridgeEventHandlerFunc func(context.Context, BridgeEvent)

type BridgeEventProducer[T any] struct {
	EventBridge *Bridge
	Type        BridgeEventType
	Log         *logrus.Logger
	Clock
}

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

type BridgeEventType string

type BridgeHeaders map[string]string

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

type BridgeStorage interface {
	// StoreEvent stores given bridge event in event storage.
	StoreEvent(context.Context, BridgeEvent) error
}

type ChatUser struct {
	ID       string `json:"id"`
	Nickname string `json:"nickname"`
}

type Clock interface {

	// Now returns current time.
	Now() time.Time
}

type ClockFunc func() time.Time

type ConfigVariables struct {
	// Address is combination of IP addres and port
	// which is used for listening to TCP/IP connections.
	Address string

	// Tokenizer is name of tokenizer type backend that should be
	// used by application.
	Tokenizer string

	// SessionSecret is secret password which is used to encrypt
	// and decrypt session state data if tokenizer age was chose.
	SessionSecret string

	// Database holds connection string for szmaterlok event storage.
	Database string

	// LastMessagesBufferSize describes maximal number stored in last
	// messages buffer that is sent to the users, when they're joining chat.
	LastMessagesBufferSize int

	// MaximumMessageSize is maximal number of runes for single message.
	MaximumMessageSize int
}

type EventAnnouncer struct {
	MessageNotifier

	UserJoinProducer *BridgeEventProducer[EventUserJoin]
	UserLeftProducer *BridgeEventProducer[EventUserLeft]

	Clock
	IDGenerator
}

type EventSentMessage struct {
	ID      string    `json:"id"`
	From    ChatUser  `json:"from"`
	Content string    `json:"content"`
	SentAt  time.Time `json:"sentAt"`
}

type EventUserJoin struct {
	ID       string    `json:"id"`
	User     ChatUser  `json:"user"`
	JoinedAt time.Time `json:"joinedAt"`
}

type EventUserLeft struct {
	ID     string    `json:"id"`
	User   ChatUser  `json:"user"`
	LeftAt time.Time `json:"leftAt"`
}

type HandlerLoginDependencies struct {
	StateFactory *SessionStateFactory
	Logger       *logrus.Logger
	SessionStore *SessionCookieStore
}

type HandlerSendMessageDependencies struct {
	MaxMessageSize int
	Sender         *BridgeEventProducer[EventSentMessage]
	IDGenerator
	Clock
}

type HandlerStreamDependencies struct {
	MessageNotifier
	IDGenerator
	Clock
}

type IDGenerator interface {

	// GenerateID return unique ID.
	GenerateID() string
}

type IDGeneratorFunc func() string

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

type LoggerLogFormatter struct {
	*logrus.Logger
}

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

type MessageNotifier interface {
	// Subscribe given ID for SSE events. Returns unsubscribe func.
	Subscribe(ctx context.Context, args MessageSubscribeRequest) func()
}

type MessageNotifierWithBuffer struct {
	Notifier MessageNotifier
	Buffer   *LastMessagesBuffer
	Logger   *logrus.Logger
}

type MessageSubscribeRequest struct {
	// ID is chat (channel, user or any other chat entity) ID.
	ID string

	// RequestID is unique request ID. One client, with the same ID,
	// can have multiple request IDs.
	RequestID string

	// Channel for sending SSE events.
	Channel chan<- sse.Event
}

type OnlineChatUser struct {
	ID       string `json:"id"`
	Nickname string `json:"nickname"`
}

type RouterDependencies struct {
	Logger       *logrus.Logger
	SessionStore *SessionCookieStore
	Bridge       *Bridge

	MaximumMessageSize int

	AllChatUsersStore
	MessageNotifier
	IDGenerator
	Clock
}

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

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

type SessionCookieSetRequest struct {
	Writer    http.ResponseWriter
	Request   *http.Request
	Tokenizer *SessionTokenizer
	State     SessionState
	Clock
}

type SessionCookieStore struct {
	// ExpirationTime of http cookie. It can differ from session
	// state expiration date, but session state's one is more
	// important. Valid cookie with expired session state will be
	// invalid.
	ExpirationTime time.Duration

	// Tokenizer handles encoding and decoding of session state.
	Tokenizer SessionTokenizer

	// Clock returns current time.
	Clock
}

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

type SessionState struct {
	Nickname  string    `json:"nck"`
	ID        string    `json:"id"`
	CreatedAt time.Time `json:"cat"`
	ExpireAt  time.Time `json:"eat"`
}

type SessionStateFactory struct {
	ExpirationTime time.Duration
	IDGenerator
	Clock
}

type SessionTokenizer interface {
	// TokenEncode returns tokenized string which represents session state and
	// can be decoded with the same interface implementation.
	TokenEncode(state SessionState) (string, error)

	// TokenDecode decodes given string token into valid session state.
	TokenDecode(token string) (*SessionState, error)
}

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

type SessionTokenizerCacheBuilder struct {
	Wrapped SessionTokenizer
	Timeout time.Duration
	Logger  *logrus.Logger
}

type SessionTokenizerFactory struct {
	Timeout time.Duration
	Logger  *logrus.Logger
}

type StateArchive interface {
	// Events sends all events from state archive through given channels
	// grouped by their creation date.
	Events(context.Context, chan<- BridgeEvent) error
}

type StateBuilder struct {
	// Archive stores past events.
	Archive StateArchive

	// Handler rebuilds state by applying hook to events
	// from archive.
	Handler BridgeEventHandler
}

type StateChatUser struct {
	ID       string
	Nickname string
}

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