repository

type BulkRepository[T dbObject] interface {
	Inserter[T]
	Counter[T]
	Dictionary[T]
	Getter[T]
	Chunker[T]
}

type ChannelRepository interface {
	BulkRepository[DBChannel]
}

type ChannelUserRepository interface {
	BulkRepository[DBChannelUser]
	GetByChannelID(ctx context.Context, db sqlx.QueryerContext, channelID string) (iter.Seq2[DBChannelUser, error], error)
}

type ChunkCount map[chunk.ChunkType]int64

type ChunkRepository interface {
	// Insert should insert dbchunk into the repository and return its ID.
	Insert(ctx context.Context, conn sqlx.ExtContext, dbchunk *DBChunk) (int64, error)
	Count(ctx context.Context, conn sqlx.ExtContext, sessionID int64, chunkTypeID ...chunk.ChunkType) (ChunkCount, error)
	All(ctx context.Context, conn sqlx.ExtContext, sessionID int64, chunkTypeID ...chunk.ChunkType) (iter.Seq2[DBChunk, error], error)
}

type Chunker[T dbObject] interface {
	OneForChunk(ctx context.Context, conn sqlx.QueryerContext, chunkID int64) (T, error)
	AllForChunk(ctx context.Context, conn sqlx.QueryerContext, chunkID int64) (iter.Seq2[T, error], error)
}

type Counter[T dbObject] interface {
	// CountType should return the number of entities in the database of a
	// given chunk types.
	CountType(ctx context.Context, conn sqlx.QueryerContext, chunkTypeID ...chunk.ChunkType) (int64, error)
	// Count should return the number of entities in the database.
	Count(ctx context.Context, conn sqlx.QueryerContext) (int64, error)
}

type DBChannel struct {
	ID      string  `db:"ID"`
	ChunkID int64   `db:"CHUNK_ID"`
	Name    *string `db:"NAME"`
	Index   int     `db:"IDX"`
	Data    []byte  `db:"DATA"`
}

type DBChannelUser struct {
	ChannelID string `db:"CHANNEL_ID"`
	UserID    string `db:"USER_ID"`
	ChunkID   int64  `db:"CHUNK_ID"`
	Index     int    `db:"IDX"`
}

type DBChunk struct {
	// ID is the unique identifier of the chunk within the session.
	ID          int64           `db:"ID,omitempty"`
	SessionID   int64           `db:"SESSION_ID,omitempty"`
	UnixTS      int64           `db:"UNIX_TS,omitempty"`
	CreatedAt   time.Time       `db:"CREATED_AT,omitempty"`
	TypeID      chunk.ChunkType `db:"TYPE_ID,omitempty"`
	NumRecords  int32           `db:"NUM_REC"`
	ChannelID   *string         `db:"CHANNEL_ID,omitempty"`
	SearchQuery *string         `db:"SEARCH_QUERY,omitempty"`
	Final       bool            `db:"FINAL"`
	ThreadOnly  *bool           `db:"THREAD_ONLY,omitempty"`
}

type DBFile struct {
	ID        string  `db:"ID"`
	ChunkID   int64   `db:"CHUNK_ID"`
	ChannelID string  `db:"CHANNEL_ID"`
	MessageID *int64  `db:"MESSAGE_ID"`
	ThreadID  *int64  `db:"THREAD_ID,omitempty"`
	Index     int     `db:"IDX"`
	Mode      string  `db:"MODE"`
	Filename  *string `db:"FILENAME"`
	URL       *string `db:"URL"`
	Data      []byte  `db:"DATA"`
}

type DBMessage struct {
	ID          int64   `db:"ID,omitempty"`
	ChunkID     int64   `db:"CHUNK_ID,omitempty"`
	ChannelID   string  `db:"CHANNEL_ID"`
	TS          string  `db:"TS"`
	ParentID    *int64  `db:"PARENT_ID,omitempty"`
	ThreadTS    *string `db:"THREAD_TS,omitempty"`
	LatestReply *string `db:"LATEST_REPLY,omitempty"`
	IsParent    bool    `db:"IS_PARENT"`
	Index       int     `db:"IDX"`
	NumFiles    int     `db:"NUM_FILES"`
	Text        string  `db:"TXT"`
	Data        []byte  `db:"DATA"`
}

type DBSearchFile struct {
	ID      int64  `db:"ID,omitempty"`
	ChunkID int64  `db:"CHUNK_ID"`
	FileID  string `db:"FILE_ID"`
	Index   int    `db:"IDX"`
	Data    []byte `db:"DATA"`
}

type DBSearchMessage struct {
	ID          int64   `db:"ID"`
	ChunkID     int64   `db:"CHUNK_ID"`
	ChannelID   string  `db:"CHANNEL_ID"`
	ChannelName *string `db:"CHANNEL_NAME,omitempty"`
	TS          string  `db:"TS"`
	Text        *string `db:"TXT,omitempty"`
	IDX         int     `db:"IDX"`
	Data        []byte  `db:"DATA"`
}

type DBUser struct {
	ID       string `db:"ID"`
	ChunkID  int64  `db:"CHUNK_ID,omitempty"`
	Username string `db:"USERNAME,omitempty"`
	Index    int    `db:"IDX"`
	Data     []byte `db:"DATA"`
}

type DBWorkspace struct {
	ID           int64   `db:"ID,omitempty"`
	ChunkID      int64   `db:"CHUNK_ID"`
	Team         string  `db:"TEAM"`
	User         *string `db:"USERNAME"`
	TeamID       string  `db:"TEAM_ID"`
	UserID       string  `db:"USER_ID"`
	EnterpriseID *string `db:"ENTERPRISE_ID"`
	URL          string  `db:"URL"`
	Data         []byte  `db:"DATA"`
}

type Dictionary[T dbObject] interface {
	// AllOfType should return all entities of a given chunk types.
	AllOfType(ctx context.Context, conn sqlx.QueryerContext, chunkTypeID ...chunk.ChunkType) (iter.Seq2[T, error], error)
	// All should return all entities.
	All(ctx context.Context, conn sqlx.QueryerContext) (iter.Seq2[T, error], error)
}

type FileRepository interface {
	BulkRepository[DBFile]
}

type Getter[T dbObject] interface {
	// Get should return the entity with the given id.
	Get(ctx context.Context, conn sqlx.ExtContext, id any) (T, error)
	// GetType should return the entity with the given id.
	GetType(ctx context.Context, conn sqlx.ExtContext, id any, ct ...chunk.ChunkType) (T, error)
}

type Inserter[T dbObject] interface {
	// Insert should insert the entity into the database.
	Insert(ctx context.Context, conn sqlx.ExtContext, t ...*T) error
	// InsertAll should insert all entities from the iterator into the
	// database.
	InsertAll(ctx context.Context, pconn PrepareExtContext, tt iter.Seq2[*T, error]) (int, error)
}

type LatestMessage struct {
	ChannelID string `db:"CHANNEL_ID"`
	TS        string `db:"TS"`
	ID        int64  `db:"ID"`
}

type LatestThread struct {
	LatestMessage
	ThreadTS string `db:"THREAD_TS"`
	ParentID int64  `db:"PARENT_ID"`
}

type MessageRepository interface {
	Inserter[DBMessage]
	Chunker[DBMessage]
	Getter[DBMessage]
	// Count returns the number of messages in a channel.
	Count(ctx context.Context, conn sqlx.QueryerContext, channelID string) (int64, error)
	// AllForID returns all messages in a channel.
	AllForID(ctx context.Context, conn sqlx.QueryerContext, channelID string) (iter.Seq2[DBMessage, error], error)
	// CountThread returns the number of messages in a thread.
	CountThread(ctx context.Context, conn sqlx.QueryerContext, channelID, threadID string) (int64, error)
	// AllForThread returns all messages in a thread, including parent message.
	AllForThread(ctx context.Context, conn sqlx.QueryerContext, channelID, threadID string) (iter.Seq2[DBMessage, error], error)
	// Sorted returns all thread and channel messages in ascending or descending
	// time order.
	Sorted(ctx context.Context, conn sqlx.QueryerContext, channelID string, order Order) (iter.Seq2[DBMessage, error], error)
	// CountUnfinished returns the number of unfinished threads in a channel.
	CountUnfinished(ctx context.Context, conn sqlx.QueryerContext, sessionID int64, channelID string) (int64, error)
	// CountThreadOnlyParts should return the number of parts in a complete
	// thread-only thread. If an unfinished or non-existent thread is
	// requested, it should return the sql.ErrNoRows error.
	CountThreadOnlyParts(ctx context.Context, conn sqlx.QueryerContext, sessionID int64, channelID, threadID string) (int64, error)
	// LatestMessages returns the latest message in each channel.
	LatestMessages(ctx context.Context, conn sqlx.QueryerContext) (iter.Seq2[LatestMessage, error], error)
	// LatestThreads returns the latest thread message in each channel.
	LatestThreads(ctx context.Context, conn sqlx.QueryerContext) (iter.Seq2[LatestThread, error], error)
}

type Order bool

type PrepareExtContext interface {
	sqlx.PreparerContext
	sqlx.ExtContext
}

type SearchFileRepository interface {
	BulkRepository[DBSearchFile]
}

type SearchMessageRepository interface {
	BulkRepository[DBSearchMessage]
}

type Session struct {
	ID             int64      `db:"ID,omitempty"`
	CreatedAt      time.Time  `db:"CREATED_AT,omitempty"`
	UpdatedAt      time.Time  `db:"UPDATED_AT,omitempty"`
	ParentID       *int64     `db:"PAR_SESSION_ID,omitempty"`
	FromTS         *time.Time `db:"FROM_TS,omitempty"`
	ToTS           *time.Time `db:"TO_TS,omitempty"`
	Finished       bool       `db:"FINISHED"`
	FilesEnabled   bool       `db:"FILES_ENABLED"`
	AvatarsEnabled bool       `db:"AVATARS_ENABLED"`
	Mode           string     `db:"MODE"`
	Args           string     `db:"ARGS,omitempty"`
}

type SessionRepository interface {
	// Insert should insert a new session into the database. If the session has
	// a parent session, it should verify that the parent session exists. It
	// should return the ID of the newly inserted session.
	Insert(ctx context.Context, conn sqlx.ExtContext, s *Session) (int64, error)
	// Finalise should mark a [Session] as finished. It should return the number
	// of rows affected.
	Finalise(ctx context.Context, conn sqlx.ExtContext, id int64) (int64, error)
	// Get should retrieve a session from the database by its ID.
	Get(ctx context.Context, conn sqlx.ExtContext, id int64) (*Session, error)
	// Update should update a session in the database. It should return the
	// number of rows affected.
	Update(ctx context.Context, conn sqlx.ExtContext, s *Session) (int64, error)
	// Last should return the last session in the database. If finished is not nil,
	// it should return the last session that is finished or not finished,
	// depending on the value of finished.
	Last(ctx context.Context, conn sqlx.ExtContext, finished *bool) (*Session, error)
	// All should return all sessions in the database.
	All(ctx context.Context, conn sqlx.ExtContext) ([]Session, error)
}

type UserRepository interface {
	BulkRepository[DBUser]
}

type WorkspaceRepository interface {
	Inserter[DBWorkspace]
	Chunker[DBWorkspace]
	GetWorkspace(ctx context.Context, conn sqlx.QueryerContext) (DBWorkspace, error)
}