Files
mtusi2026lab2/internal/store/memory.go
T
2026-10-02 11:45:26 +03:00

237 lines
5.1 KiB
Go

package store
import (
"errors"
"slices"
"sort"
"sync"
"time"
"github.com/google/uuid"
"mtusi2026-messenger/internal/model"
)
var (
ErrNotFound = errors.New("not found")
ErrConflict = errors.New("conflict")
ErrDuplicateMember = errors.New("duplicate member id")
ErrUnknownMember = errors.New("unknown member id")
ErrInvalidCursor = errors.New("invalid cursor")
)
type Memory struct {
mu sync.RWMutex
users map[uuid.UUID]model.User
usersByUsername map[string]uuid.UUID
chats map[uuid.UUID]model.Chat
messages map[uuid.UUID]model.Message
chatMessages map[uuid.UUID][]uuid.UUID
}
func New() *Memory {
return &Memory{
users: make(map[uuid.UUID]model.User),
usersByUsername: make(map[string]uuid.UUID),
chats: make(map[uuid.UUID]model.Chat),
messages: make(map[uuid.UUID]model.Message),
chatMessages: make(map[uuid.UUID][]uuid.UUID),
}
}
func (m *Memory) CreateUser(username, displayName string) (model.User, error) {
m.mu.Lock()
defer m.mu.Unlock()
if _, exists := m.usersByUsername[username]; exists {
return model.User{}, ErrConflict
}
user := model.User{
ID: uuid.New(),
Username: username,
DisplayName: displayName,
CreatedAt: time.Now().UTC(),
}
m.users[user.ID] = user
m.usersByUsername[user.Username] = user.ID
return user, nil
}
func (m *Memory) GetUser(id uuid.UUID) (model.User, error) {
m.mu.RLock()
defer m.mu.RUnlock()
user, exists := m.users[id]
if !exists {
return model.User{}, ErrNotFound
}
return user, nil
}
func (m *Memory) CreateChat(title string, memberIDs []uuid.UUID) (model.Chat, error) {
m.mu.Lock()
defer m.mu.Unlock()
seen := make(map[uuid.UUID]struct{}, len(memberIDs))
for _, id := range memberIDs {
if _, dup := seen[id]; dup {
return model.Chat{}, ErrDuplicateMember
}
seen[id] = struct{}{}
if _, exists := m.users[id]; !exists {
return model.Chat{}, ErrUnknownMember
}
}
chat := model.Chat{
ID: uuid.New(),
Title: title,
MemberIDs: append([]uuid.UUID(nil), memberIDs...),
CreatedAt: time.Now().UTC(),
}
m.chats[chat.ID] = chat
return chat, nil
}
func (m *Memory) GetChat(id uuid.UUID, userID uuid.UUID) (model.Chat, error) {
m.mu.RLock()
defer m.mu.RUnlock()
chat, exists := m.chats[id]
if !exists || !slices.Contains(chat.MemberIDs, userID) {
return model.Chat{}, ErrNotFound
}
chat.MemberIDs = append([]uuid.UUID(nil), chat.MemberIDs...)
return chat, nil
}
func (m *Memory) ListChats(
userID uuid.UUID,
afterCreatedAt *time.Time,
afterID *uuid.UUID,
limit int,
) ([]model.Chat, bool, error) {
m.mu.RLock()
defer m.mu.RUnlock()
chats := make([]model.Chat, 0)
for _, c := range m.chats {
if slices.Contains(c.MemberIDs, userID) {
c.MemberIDs = append([]uuid.UUID(nil), c.MemberIDs...)
chats = append(chats, c)
}
}
sort.Slice(chats, func(i, j int) bool {
if !chats[i].CreatedAt.Equal(chats[j].CreatedAt) {
return chats[i].CreatedAt.Before(chats[j].CreatedAt)
}
return chats[i].ID.String() < chats[j].ID.String()
})
start := 0
if afterCreatedAt != nil && afterID != nil {
start = sort.Search(len(chats), func(i int) bool {
chat := chats[i]
return chat.CreatedAt.After(*afterCreatedAt) ||
(chat.CreatedAt.Equal(*afterCreatedAt) &&
chat.ID.String() > afterID.String())
})
}
end := start + limit
hasMore := end < len(chats)
if end > len(chats) {
end = len(chats)
}
return chats[start:end], hasMore, nil
}
func (m *Memory) CreateMessage(
chatID uuid.UUID,
senderID uuid.UUID,
text string,
) (model.Message, error) {
m.mu.Lock()
defer m.mu.Unlock()
chat, exists := m.chats[chatID]
if !exists || !slices.Contains(chat.MemberIDs, senderID) {
return model.Message{}, ErrNotFound
}
message := model.Message{
ID: uuid.New(),
ChatID: chatID,
SenderID: senderID,
Text: text,
CreatedAt: time.Now().UTC(),
}
m.messages[message.ID] = message
m.chatMessages[chatID] = append(m.chatMessages[chatID], message.ID)
return message, nil
}
func (m *Memory) ListMessages(
chatID uuid.UUID,
userID uuid.UUID,
afterCreatedAt *time.Time,
afterID *uuid.UUID,
limit int,
) ([]model.Message, bool, error) {
m.mu.RLock()
defer m.mu.RUnlock()
chat, exists := m.chats[chatID]
if !exists || !slices.Contains(chat.MemberIDs, userID) {
return nil, false, ErrNotFound
}
ids := m.chatMessages[chatID]
messages := make([]model.Message, 0, len(ids))
for _, id := range ids {
messages = append(messages, m.messages[id])
}
sort.Slice(messages, func(i, j int) bool {
if !messages[i].CreatedAt.Equal(messages[j].CreatedAt) {
return messages[i].CreatedAt.Before(messages[j].CreatedAt)
}
return messages[i].ID.String() < messages[j].ID.String()
})
start := 0
if afterCreatedAt != nil && afterID != nil {
start = sort.Search(len(messages), func(i int) bool {
msg := messages[i]
return msg.CreatedAt.After(*afterCreatedAt) ||
(msg.CreatedAt.Equal(*afterCreatedAt) &&
msg.ID.String() > afterID.String())
})
}
end := start + limit
hasMore := end < len(messages)
if end > len(messages) {
end = len(messages)
}
return messages[start:end], hasMore, nil
}