package entry

import "strings"

type SortField string

type SortDirection string

const (
	SortByID        SortField = "id"
	SortByCreatedAt SortField = "created_at"
	SortByUpdatedAt SortField = "updated_at"

	SortAsc  SortDirection = "asc"
	SortDesc SortDirection = "desc"
)

type Sort struct {
	Field     SortField
	Direction SortDirection
}

func (s Sort) Valid() bool {
	switch s.Field {
	case SortByID, SortByCreatedAt, SortByUpdatedAt:
	default:
		return false
	}
	return s.Direction == SortAsc || s.Direction == SortDesc
}

func (s Sort) String() string {
	return string(s.Field) + ":" + string(s.Direction)
}

func ParseSort(value string) (Sort, error) {
	field, direction, found := strings.Cut(value, ":")
	parsed := Sort{Field: SortField(field), Direction: SortDirection(direction)}
	if !found || !parsed.Valid() {
		return Sort{}, ErrInvalidSort
	}
	return parsed, nil
}

func DefaultSort() Sort {
	return Sort{Field: SortByUpdatedAt, Direction: SortDesc}
}

type Filters struct {
	ContentTypeID uint32
	CreatedBy     *uint32
	Page          int
	Size          int
	Sort          Sort
	Unpaged       bool
}

type PageResult struct {
	Items []Entry
	Total int
}

type Repository interface {
	Create(entry Entry) (Entry, error)
	Get(contentTypeID uint32, id uint32) (Entry, error)
	ListPage(filters Filters) (PageResult, error)
	ListByCreator(creatorID uint32) ([]Entry, error)
	Update(entry Entry) (Entry, error)
	Delete(contentTypeID uint32, id uint32) error
	DeleteByContentType(contentTypeID uint32) error
	CountByContentType(contentTypeID uint32) (int, error)
	FindByFieldValue(contentTypeID uint32, fieldKey string, value any, excludeID uint32) ([]Entry, error)
}