persistence

type Db interface {
	// NewModelTx creates new ModelTx object
	NewModelTx(ctx context.Context) ModelTx
	// NewTx creates Tx object
	NewTx(ctx context.Context) Tx
}

type DbConfig struct {
	Host     string
	Port     string
	User     string
	Password string
	DbName   string
	SslMode  string
}

type DbContainer interface {
	io.Closer
	DbConfig() DbConfig
}

type DbOption func(cfg *DbConfig)

type DeleteNodesQuery struct {
	// FilterConditions contains the node selection filter
	FilterConditions string
	// Force flag allows to delete children for the selected folders. For example, if
	// the selected node is a folder, and it has children, that don't match the filter criteria,
	// they also will be deleted if the force is true.
	Force bool
}

type Format struct {
	ID        string    `db:"id"`
	Basis     []byte    `db:"basis"`
	CreatedAt time.Time `db:"created_at"`
	UpdatedAt time.Time `db:"updated_at"`
}

type IndexRecord struct {
	ID        string    `db:"id"`
	NodeID    int64     `db:"node_id"`
	Segment   string    `db:"segment"`
	Vector    []byte    `db:"vector"`
	Format    string    `db:"format"`
	RankMult  float64   `db:"rank_multiplier"`
	CreatedAt time.Time `db:"created_at"`
	UpdatedAt time.Time `db:"updated_at"`

	// search module specific fields
	SegmentTsVector string `db:"segment_tsvector"`
}

type IndexRecordQuery struct {
	// Format is filter records by the format. If empty no format filter
	Format string
	// NodeID sets the ID of the node
	NodeID        int64
	CreatedAfter  time.Time
	CreatedBefore time.Time
	FromID        string
	Limit         int
}

type ListNodesQuery struct {
	// FilterConditions contains the node selection filter
	FilterConditions string
	Offset           int64
	Limit            int64
}

type ModelTx interface {
	Tx

	// CreateFormat creates format entry
	CreateFormat(format Format) (Format, error)
	// GetFormat retrieves format entry by ID
	GetFormat(ID string) (Format, error)
	// DeleteFormat deletes format entry by ID (only if not referenced)
	DeleteFormat(ID string) error
	// ListFormats lists all the existing format entries
	ListFormats() ([]Format, error)

	// CreateNodes allows to create one or several new Nodes. If a Node with the path already exists,
	// the function will return ErrExists.
	CreateNodes(nodes ...Node) ([]Node, error)
	// ListAllNodesByPath returns all nodes for the path. For example for the path="/a/b/doc.txt"
	// the result nodes will be {<"/", "a">, {<"/a/", "b">, <"/a/b/", "doc.txt">}
	ListAllNodesByPath(path string) ([]Node, error)
	// ListNodes returns the nodes according to the query filter request
	ListNodes(query ListNodesQuery) ([]Node, error)

	// GetNode returns the node by its fqnp
	GetNode(fqnp string) (Node, error)
	// UpdateNode updates node data
	UpdateNode(node Node) error

	// DeleteNodes deletes the Nodes that matches to the DeleteNodesQuery and all the records associated with the nodes.
	// force allows to delete folder nodes with children. If the node is a folder, and there are children,
	// but the force flag is false, the function will return ErrConflict error
	//
	// NOTE: The operation is not atomic until an external transaction is not started,
	// the caller MUST start the transaction before using this method.
	DeleteNodes(DeleteNodesQuery) error

	// UpsertIndexRecords creates or updates index record entries. It returns the new records created
	UpsertIndexRecords(records ...IndexRecord) (int64, error)
	// DeleteIndexRecords deletes index record entries
	DeleteIndexRecords(records ...IndexRecord) (int64, error)
	// QueryIndexRecords lists query matching index record entries
	QueryIndexRecords(query IndexRecordQuery) (QueryResult[IndexRecord, string], error)

	// Search performs search across existing index records
	// the query string should be formed in accordance with the query
	// language of the underlying search engine
	//
	// NOTE: The operation is not atomic until an external transaction is not started,
	// the caller MUST start the transaction before using this method.
	Search(query SearchQuery) (SearchQueryResult, error)
}

type Node struct {
	ID   int64  `db:"id"`
	Path string `db:"path"`
	// Name is either name of the folder or a document
	Name      string    `db:"name"`
	Tags      Tags      `db:"tags"`
	Flags     int32     `db:"flags"`
	CreatedAt time.Time `db:"created_at"`
	UpdatedAt time.Time `db:"updated_at"`
}

type QueryResult[T any, N any] struct {
	Items  []T
	NextID N
	Total  int64
}

type SearchQuery struct {
	TextQuery        string
	FilterConditions string
	GroupByPathOff   bool // GroupByPathOff turns off results grouping by path.
	Offset           int
	Limit            int
}

type SearchQueryResult struct {
	Items []SearchQueryResultItem
	Total int64
}

type SearchQueryResultItem struct {
	IndexRecord
	Path                string   `db:"path"`
	MatchedKeywordsList []string // mapped manually after filling the MatchedKeywords
	MatchedKeywords     string   `db:"matched_keywords"`
	Score               float32  `db:"score"`
}

type Tags map[string]string

type Tx interface {
	// MustBegin starts the transaction
	MustBegin()
	// MustBeginSerializable starts new transaction with Serializable isolation level
	MustBeginSerializable()
	// Commit commits the changes made within the transaction
	Commit() error
	// Rollback rolls the transaction back
	Rollback() error
	// ExecScript allows to execute the sql statements from the file provided
	ExecScript(sqlScript string) error
}