foodtinder

type AuthorizedServer interface {
	// Logout invalidates the authorizing token.
	Logout(context.Context) error

	PostServer() PostServer
	UserServer() UserServer
}

type AuthorizerServer interface {
	// Authorize authorizes the user using the given session token. The session
	// is returned if the token points to a valid user.
	Authorize(ctx context.Context, token string) (*Session, error)
}

type Date struct {
	D uint8
	M uint8
	Y uint16
}

type FileServer interface {
	fs.FS

	// Create creates a file with the content from the given Reader. The new
	// asset hash is returned, or an error if there's one. Create may be called
	// concurrently; the implementation should guarantee that everything is
	// atomic and that there is no collision.
	Create(s *Session, src io.Reader) (string, error)
}

type FoodPreferences struct {
	// Likes is a list of categories of food that the user likes.
	Likes []foods.Category
	// Prefers maps each category that the user likes to a list of specific
	// foods that they've selected.
	Prefers map[foods.Category][]foods.Name
}

type ID = snowflake.ID

type LoginMetadata struct {
	// UserAgent is the user-agent that the user was on when they logged in.
	UserAgent string
}

type LoginServer interface {
	// Login authenticates the user by a username and password and returns a new
	// session.
	Login(ctx context.Context, username, password string, m LoginMetadata) (*Session, error)
	// Register registers a new user.
	Register(ctx context.Context, username, password string, m LoginMetadata) (*Session, error)
}

type Post struct {
	ID ID
	// Username is the username of the user who posted the food item.
	Username string
	// CoverHash is the blur hash of the cover image.
	CoverHash string
	// Images is the list of image asset hashes for this food item. The first
	// image should be used as the cover.
	Images []string
	// Description contains the description of the food item.
	Description string
	// Tags is a list of food names that this post is relevant to. It can be
	// used for the recommendation algorithm.
	Tags []foods.Name
	// Location is the location where the post was made.
	Location string
	// Likes is the number of likes of this post.
	Likes int
}

type PostListing struct {
	Post
	// Liked is whether or not the current user has liked a post.
	Liked bool
}

type PostServer interface {
	// Post queries a single post.
	Post(ctx context.Context, id ID) (*PostListing, error)
	// NextPosts returns the list of posts that the user will see next
	// starting from the given previous ID. If the ID is 0, then the top is
	// assumed.
	NextPosts(ctx context.Context, previousID ID) ([]PostListing, error)
	// LikedPosts returns the list of liked posts by the user.
	LikedPosts(ctx context.Context) ([]Post, error)
	// LikePost likes or unlikes the post with the given ID. The like belongs to
	// the logged in user.
	LikePost(ctx context.Context, id ID, like bool) error
	// DeletePosts deletes the given posts. Only the posts that belong to the
	// current user can be deleted.
	DeletePost(ctx context.Context, id ID) error
	// CreatePost creates a new post. The post's ID is ignored and a new one is
	// used. That ID is returned back.
	CreatePost(ctx context.Context, post Post) (ID, error)
}

type Self struct {
	User
	Birthday    Date
	Preferences FoodPreferences
}

type Server interface {
	FileServer() FileServer
	LoginServer() LoginServer
	AuthorizerServer() AuthorizerServer
	AuthorizedServer(s *Session) AuthorizedServer
}

type Session struct {
	// Username identifies the user that the session belongs to.
	Username string
	// Token is the token of the session.
	Token string
	// Expiry is the time that the session token expires.
	Expiry time.Time
	// Metadata is the metadata that was created when the user first logged in.
	Metadata LoginMetadata
}

type Throttle struct {
	Bursts   int
	Duration time.Duration
}

type User struct {
	// Username is the username which can contain spaces. All usernames must be
	// unique.
	Username string
	// DisplayName is the visible name that users actually see.
	DisplayName string
	// Avatar is the asset hash string that can be used to create a URL.
	Avatar string
	// Bio is the user biography (or description).
	Bio string
}

type UserLikedPosts struct {
	// Posts maps post IDs to the time that the user liked.
	Posts map[ID]time.Time
	// Remaining is the number of likes allowed by the user until the Expires
	// timestamp.
	Remaining int
	// Expires is the time that the rate limiter (the Remaining field)
	// replenishes.
	Expires time.Time
}

type UserPostPreferences struct {
	Post
	// LikedAt is not nil if the user has liked the post before.
	LikedAt *time.Time
}

type UserServer interface {
	// User fetches the user given the ID. Use this to fetch other users.
	User(ctx context.Context, username string) (*User, error)
	// Self returns the current user.
	Self(context.Context) (*Self, error)
	// UpdateSelf updates the current user. This method should change everything
	// except the Username and Password.
	UpdateSelf(context.Context, *Self) error
	// ChangePassword changes the password of the current user. All existing
	// sessions except for this one should be invalidated.
	ChangePassword(ctx context.Context, newPassword string) error
}