onasty @ babda7d822d93649597a4892e0dada0724e215b7

package notesrv

import (

	"context"

	"errors"

	"log/slog"

	"time"

	"github.com/gofrs/uuid/v5"

	"github.com/olexsmir/onasty/internal/dtos"

	"github.com/olexsmir/onasty/internal/hasher"

	"github.com/olexsmir/onasty/internal/models"

	"github.com/olexsmir/onasty/internal/store/psql/noterepo"

	"github.com/olexsmir/onasty/internal/store/rdb/notecache"

)

var ErrNotePasswordNotProvided = errors.New("note: password was not provided")

type NoteServicer interface {

	// Create creates note

	// if slug is empty it will be generated, otherwise used as is

	// if userID is empty it means user isn't authorized so it will be used

	Create(ctx context.Context, note dtos.CreateNote, userID uuid.UUID) (dtos.NoteSlug, error)

	// GetBySlugAndRemoveIfNeeded returns note by slug, and removes if if needed.

	// If notes is not found returns [models.ErrNoteNotFound].

	GetBySlugAndRemoveIfNeeded(

		ctx context.Context,

		input GetNoteBySlugInput,

	) (dtos.GetNote, error)

	// GetAllByAuthorID returns all notes by author id.

	GetAllByAuthorID(

		ctx context.Context,

		authorID uuid.UUID,

	) ([]dtos.NoteDetailed, error)

	// UpdateExpirationTimeSettings updates expiresAt and burnBeforeExpiration.

	// If notes is not found returns [models.ErrNoteNotFound].

	UpdateExpirationTimeSettings(

		ctx context.Context,

		patchData dtos.PatchNote,

		slug dtos.NoteSlug,

		userID uuid.UUID,

	) error

	// UpdatePassword sets or updates notes password.

	// If notes is not found returns [models.ErrNoteNotFound].

	UpdatePassword(ctx context.Context, slug dtos.NoteSlug, passwd string, userID uuid.UUID) error

	// DeleteBySlug deletes note by slug

	DeleteBySlug(ctx context.Context, slug dtos.NoteSlug, userID uuid.UUID) error

}

var _ NoteServicer = (*NoteSrv)(nil)

type NoteSrv struct {

	noterepo noterepo.NoteStorer

	hasher   hasher.Hasher

	cache    notecache.NoteCacher

}

func New(noterepo noterepo.NoteStorer, hasher hasher.Hasher, cache notecache.NoteCacher) *NoteSrv {

	return &NoteSrv{

		noterepo: noterepo,

		hasher:   hasher,

		cache:    cache,

	}

}

func (n *NoteSrv) Create(

	ctx context.Context,

	inp dtos.CreateNote,

	userID uuid.UUID,

) (dtos.NoteSlug, error) {

	slog.DebugContext(ctx, "creating", "inp", inp)

	if inp.Slug == "" {

		inp.Slug = uuid.Must(uuid.NewV4()).String()

	}

	if inp.Password != "" {

		hashedPassword, err := n.hasher.Hash(inp.Password)

		if err != nil {

			return "", err

		}

		inp.Password = hashedPassword

	}

	//nolint:exhaustruct // ID - cannot be predicted, and ReadAt will be set on read

	note := models.Note{

		Content:              inp.Content,

		Slug:                 inp.Slug,

		Password:             inp.Password,

		BurnBeforeExpiration: inp.BurnBeforeExpiration,

		CreatedAt:            inp.CreatedAt,

		ExpiresAt:            inp.ExpiresAt,

	}

	if err := note.Validate(); err != nil {

		return "", err

	}

	if err := n.noterepo.Create(ctx, note); err != nil {

		return "", err

	}

	if !userID.IsNil() {

		if err := n.noterepo.SetAuthorIDBySlug(ctx, inp.Slug, userID); err != nil {

			return "", err

		}

	}

	return inp.Slug, nil

}

func (n *NoteSrv) GetBySlugAndRemoveIfNeeded(

	ctx context.Context,

	inp GetNoteBySlugInput,

) (dtos.GetNote, error) {

	note, err := n.getNote(ctx, inp)

	if err != nil {

		return dtos.GetNote{}, err

	}

	if note.IsExpired() {

		return dtos.GetNote{}, models.ErrNoteExpired

	}

	respNote := dtos.GetNote{

		Content:   note.Content,

		ReadAt:    note.ReadAt,

		CreatedAt: note.CreatedAt,

		ExpiresAt: note.ExpiresAt,

	}

	// since not every note should be burn before expiration

	// we return early if it's not

	if note.ShouldBeBurnt() {

		return respNote, nil

	}

	return respNote, n.noterepo.RemoveBySlug(ctx, inp.Slug, time.Now())

}

func (n *NoteSrv) GetAllByAuthorID(

	ctx context.Context,

	authorID uuid.UUID,

) ([]dtos.NoteDetailed, error) {

	notes, err := n.noterepo.GetAllByAuthorID(ctx, authorID)

	if err != nil {

		return nil, err

	}

	var resNotes []dtos.NoteDetailed

	for _, note := range notes {

		resNotes = append(resNotes, dtos.NoteDetailed{

			Content:              note.Content,

			Slug:                 note.Slug,

			BurnBeforeExpiration: note.BurnBeforeExpiration,

			HasPassword:          note.Password != "",

			CreatedAt:            note.CreatedAt,

			ExpiresAt:            note.ExpiresAt,

			ReadAt:               note.ReadAt,

		})

	}

	return resNotes, nil

}

func (n *NoteSrv) UpdateExpirationTimeSettings(

	ctx context.Context,

	patchData dtos.PatchNote,

	slug dtos.NoteSlug,

	userID uuid.UUID,

) error {

	return n.noterepo.UpdateExpirationTimeSettingsBySlug(ctx, slug, patchData, userID)

}

func (n *NoteSrv) UpdatePassword(

	ctx context.Context,

	slug dtos.NoteSlug,

	passwd string,

	userID uuid.UUID,

) error {

	if len(passwd) == 0 {

		return ErrNotePasswordNotProvided

	}

	hashedPassword, err := n.hasher.Hash(passwd)

	if err != nil {

		return err

	}

	return n.noterepo.UpdatePasswordBySlug(ctx, slug, userID, hashedPassword)

}

func (n *NoteSrv) DeleteBySlug(

	ctx context.Context,

	slug dtos.NoteSlug,

	authorID uuid.UUID,

) error {

	return n.noterepo.DeleteNoteBySlug(ctx, slug, authorID)

}

func (n *NoteSrv) getNote(ctx context.Context, inp GetNoteBySlugInput) (models.Note, error) {

	if r, err := n.cache.GetNote(ctx, inp.Slug); err == nil {

		return r, nil

	}

	note, err := n.getNoteFromDBasedOnInput(ctx, inp)

	if err != nil {

		return models.Note{}, err

	}

	if !note.IsRead() {

		if err = n.cache.SetNote(ctx, inp.Slug, note); err != nil {

			slog.ErrorContext(ctx, "notecache", "err", err)

		}

	}

	return note, err

}

func (n *NoteSrv) getNoteFromDBasedOnInput(

	ctx context.Context,

	inp GetNoteBySlugInput,

) (models.Note, error) {

	if inp.HasPassword() {

		hashedPassword, err := n.hasher.Hash(inp.Password)

		if err != nil {

			return models.Note{}, err

		}

		return n.noterepo.GetBySlugAndPassword(ctx, inp.Slug, hashedPassword)

	}

	return n.noterepo.GetBySlug(ctx, inp.Slug)

}