m8sh/database/leveldb/chat.go

package leveldb

import (
	"bytes"
	"encoding/gob"
	"fmt"
	"time"

	"github.com/syndtr/goleveldb/leveldb"
	"github.com/syndtr/goleveldb/leveldb/util"
	"m8sh.su/x/m8sh/database"
)

type chat struct {
	db *leveldb.DB
}

func (c *chat) Put(user string, msg database.Message) error {
	ts := formatTime(msg.Date)
	contact := msg.To
	if msg.To == user {
		contact = msg.From
	}

	metaKey := key(user, prefixChatMeta, contact, ts)
	attachKey := key(user, prefixChatAttach, contact, ts)
	dialogKey := key(user, prefixChatDialog, contact)

	var metaBuf bytes.Buffer
	if err := gob.NewEncoder(&metaBuf).Encode(msg); err != nil {
		return fmt.Errorf("encode message for %q: %w", user, err)
	}

	batch := new(leveldb.Batch)
	defer batch.Reset()

	batch.Put(metaKey, metaBuf.Bytes())
	if len(msg.Attachments) > 0 {
		var attachBuf bytes.Buffer
		if err := gob.NewEncoder(&attachBuf).Encode(msg.Attachments); err != nil {
			return fmt.Errorf("encode attachments for %q: %w", user, err)
		}
		batch.Put(attachKey, attachBuf.Bytes())
	}

	dialogue := database.Dialogue{
		Contact:     contact,
		LastDate:    msg.Date,
		LastContent: msg.Content,
		UnreadCount: 1,
	}

	existing, err := c.db.Get(dialogKey, nil)
	if err == nil {
		var prev database.Dialogue
		if gob.NewDecoder(bytes.NewReader(existing)).Decode(&prev) == nil {
			dialogue.UnreadCount = prev.UnreadCount + 1
		}
	}

	var dialogBuf bytes.Buffer
	if err := gob.NewEncoder(&dialogBuf).Encode(dialogue); err != nil {
		return fmt.Errorf("encode dialogue for %q: %w", user, err)
	}
	batch.Put(dialogKey, dialogBuf.Bytes())

	if err := c.db.Write(batch, woSync); err != nil {
		return fmt.Errorf("store message for %q: %w", user, err)
	}

	return nil
}

func (c *chat) Dialogues(user string, limit int, after time.Time) ([]database.Dialogue, error) {
	prefix := key(user, prefixChatDialog)

	iter := c.db.NewIterator(util.BytesPrefix(prefix), nil)
	defer iter.Release()

	var dialogues []database.Dialogue
	for iter.Next() {
		var dialogue database.Dialogue
		if err := gob.NewDecoder(bytes.NewReader(iter.Value())).Decode(&dialogue); err != nil {
			return nil, fmt.Errorf("decode dialogue for %q: %w", user, err)
		}

		if !after.IsZero() && !dialogue.LastDate.After(after) {
			continue
		}

		dialogues = append(dialogues, dialogue)
		if len(dialogues) >= limit {
			break
		}
	}

	return dialogues, nil
}

func (c *chat) Messages(user, contact string, limit int, after time.Time) ([]database.Message, error) {
	prefix := key(user, prefixChatMeta, contact)

	iter := c.db.NewIterator(util.BytesPrefix(prefix), nil)
	defer iter.Release()

	var messages []database.Message
	for iter.Next() {
		var msg database.Message
		if err := gob.NewDecoder(bytes.NewReader(iter.Value())).Decode(&msg); err != nil {
			return nil, fmt.Errorf("decode message for %q: %w", user, err)
		}

		if !after.IsZero() && !msg.Date.After(after) {
			continue
		}

		messages = append(messages, msg)
		if len(messages) >= limit {
			break
		}
	}

	return messages, nil
}

func (c *chat) MarkSeen(user, contact string, date time.Time) error {
	ts := formatTime(date)
	metaKey := key(user, prefixChatMeta, contact, ts)

	data, err := c.db.Get(metaKey, nil)
	if err != nil {
		if err == leveldb.ErrNotFound {
			return database.ErrNotFound
		}
		return fmt.Errorf("read message for %q: %w", user, err)
	}

	var msg database.Message
	if err = gob.NewDecoder(bytes.NewReader(data)).Decode(&msg); err != nil {
		return fmt.Errorf("decode message for %q: %w", user, err)
	}

	if msg.Seen {
		return nil
	}
	msg.Seen = true

	var buf bytes.Buffer
	if err = gob.NewEncoder(&buf).Encode(msg); err != nil {
		return fmt.Errorf("encode message for %q: %w", user, err)
	}

	if err = c.db.Put(metaKey, buf.Bytes(), woSync); err != nil {
		return fmt.Errorf("mark seen for %q: %w", user, err)
	}

	return nil
}

func (c *chat) Delete(user, contact string, date time.Time) error {
	ts := formatTime(date)
	metaKey := key(user, prefixChatMeta, contact, ts)
	attachKey := key(user, prefixChatAttach, contact, ts)
	dialogKey := key(user, prefixChatDialog, contact)

	_, err := c.db.Get(metaKey, nil)
	if err != nil {
		if err == leveldb.ErrNotFound {
			return database.ErrNotFound
		}
		return fmt.Errorf("check message for %q: %w", user, err)
	}

	batch := new(leveldb.Batch)
	defer batch.Reset()

	batch.Delete(metaKey)
	batch.Delete(attachKey)

	prefix := key(user, prefixChatMeta, contact)
	iter := c.db.NewIterator(util.BytesPrefix(prefix), nil)

	var latest database.Message
	for iter.Next() {
		var msg database.Message
		if gob.NewDecoder(bytes.NewReader(iter.Value())).Decode(&msg) == nil {
			if msg.Date.Equal(date) {
				continue
			}
			if msg.Date.After(latest.Date) {
				latest = msg
			}
		}
	}
	iter.Release()

	if latest.Date.IsZero() {
		batch.Delete(dialogKey)
	} else {
		var prev database.Dialogue
		existing, err := c.db.Get(dialogKey, nil)
		if err == nil {
			gob.NewDecoder(bytes.NewReader(existing)).Decode(&prev)
		}
		prev.LastDate = latest.Date
		prev.LastContent = latest.Content

		var dialogBuf bytes.Buffer
		if err := gob.NewEncoder(&dialogBuf).Encode(prev); err != nil {
			return fmt.Errorf("encode dialogue for %q: %w", user, err)
		}
		batch.Put(dialogKey, dialogBuf.Bytes())
	}

	if err = c.db.Write(batch, woSync); err != nil {
		return fmt.Errorf("delete message for %q: %w", user, err)
	}

	return nil
}