// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.31.1
// source: recommendations.sql

package sqlcdb

import (
	"context"
	"time"
)

const deleteAnnotationEmbedding = `-- name: DeleteAnnotationEmbedding :exec
DELETE FROM annotation_embeddings WHERE annotation_uri = $1
`

func (q *Queries) DeleteAnnotationEmbedding(ctx context.Context, annotationUri string) error {
	_, err := q.db.Exec(ctx, deleteAnnotationEmbedding, annotationUri)
	return err
}

const deleteDocument = `-- name: DeleteDocument :exec
DELETE FROM documents WHERE uri = $1
`

func (q *Queries) DeleteDocument(ctx context.Context, uri string) error {
	_, err := q.db.Exec(ctx, deleteDocument, uri)
	return err
}

const deletePublication = `-- name: DeletePublication :exec
DELETE FROM publications WHERE uri = $1
`

func (q *Queries) DeletePublication(ctx context.Context, uri string) error {
	_, err := q.db.Exec(ctx, deletePublication, uri)
	return err
}

const getAnnotationEmbeddingsByAuthor = `-- name: GetAnnotationEmbeddingsByAuthor :many
SELECT annotation_uri, author_did, document_uri, embedding, updated_at FROM annotation_embeddings WHERE author_did = $1
`

func (q *Queries) GetAnnotationEmbeddingsByAuthor(ctx context.Context, authorDid string) ([]AnnotationEmbedding, error) {
	rows, err := q.db.Query(ctx, getAnnotationEmbeddingsByAuthor, authorDid)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []AnnotationEmbedding
	for rows.Next() {
		var i AnnotationEmbedding
		if err := rows.Scan(
			&i.AnnotationUri,
			&i.AuthorDid,
			&i.DocumentUri,
			&i.Embedding,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getAnnotationsWithoutEmbeddings = `-- name: GetAnnotationsWithoutEmbeddings :many
SELECT a.uri, a.author_did, a.motivation, a.body_value, a.body_format, a.body_uri, a.target_source, a.target_hash, a.target_title, a.selector_json, a.tags_json, a.created_at, a.indexed_at, a.cid
FROM annotations a
LEFT JOIN annotation_embeddings ae ON a.uri = ae.annotation_uri
WHERE ae.annotation_uri IS NULL AND a.motivation IN ('commenting', 'highlighting')
ORDER BY a.created_at DESC
LIMIT $1
`

func (q *Queries) GetAnnotationsWithoutEmbeddings(ctx context.Context, limit int32) ([]Annotation, error) {
	rows, err := q.db.Query(ctx, getAnnotationsWithoutEmbeddings, limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Annotation
	for rows.Next() {
		var i Annotation
		if err := rows.Scan(
			&i.Uri,
			&i.AuthorDid,
			&i.Motivation,
			&i.BodyValue,
			&i.BodyFormat,
			&i.BodyUri,
			&i.TargetSource,
			&i.TargetHash,
			&i.TargetTitle,
			&i.SelectorJson,
			&i.TagsJson,
			&i.CreatedAt,
			&i.IndexedAt,
			&i.Cid,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getCandidateDocuments = `-- name: GetCandidateDocuments :many
SELECT
    d.uri, d.author_did, d.site, d.path, d.title, d.description, d.tags_json,
    d.canonical_url, d.published_at, de.embedding,
    COALESCE(eng.cnt, 0) AS engagement
FROM documents d
JOIN document_embeddings de ON d.uri = de.document_uri
LEFT JOIN (
    SELECT document_uri, COUNT(DISTINCT author_did) AS cnt
    FROM annotation_embeddings
    WHERE document_uri IS NOT NULL
    GROUP BY document_uri
) eng ON eng.document_uri = d.uri
LEFT JOIN publications p ON d.site = p.uri OR d.site = p.url
WHERE d.author_did != $1
  AND (p.show_in_discover IS NULL OR p.show_in_discover = true)
  AND LENGTH(d.title) > 15
  AND (LENGTH(COALESCE(d.description, '')) >= 30 OR LENGTH(COALESCE(d.text_content, '')) >= 100)
  AND LOWER(d.title) NOT LIKE '%test%'
  AND LOWER(d.title) NOT LIKE '%testing%'
  AND LOWER(d.title) NOT LIKE '%hello world%'
  AND LOWER(d.title) NOT LIKE '%untitled%'
  AND LOWER(d.title) NOT LIKE '%draft%'
  AND LOWER(d.title) NOT LIKE '%asdf%'
  AND LOWER(d.title) NOT LIKE '%lorem%'
  AND LOWER(d.title) NOT LIKE '%placeholder%'
  AND d.uri NOT IN (
    SELECT DISTINCT ae2.document_uri FROM annotation_embeddings ae2
    WHERE ae2.author_did = $2 AND ae2.document_uri IS NOT NULL
  )
ORDER BY d.published_at DESC
LIMIT $3
`

type GetCandidateDocumentsParams struct {
	AuthorDid   string `json:"authorDid"`
	AuthorDid_2 string `json:"authorDid2"`
	Limit       int32  `json:"limit"`
}

type GetCandidateDocumentsRow struct {
	Uri          string    `json:"uri"`
	AuthorDid    string    `json:"authorDid"`
	Site         string    `json:"site"`
	Path         *string   `json:"path"`
	Title        string    `json:"title"`
	Description  *string   `json:"description"`
	TagsJson     *string   `json:"tagsJson"`
	CanonicalUrl *string   `json:"canonicalUrl"`
	PublishedAt  time.Time `json:"publishedAt"`
	Embedding    string    `json:"embedding"`
	Engagement   int64     `json:"engagement"`
}

func (q *Queries) GetCandidateDocuments(ctx context.Context, arg GetCandidateDocumentsParams) ([]GetCandidateDocumentsRow, error) {
	rows, err := q.db.Query(ctx, getCandidateDocuments, arg.AuthorDid, arg.AuthorDid_2, arg.Limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetCandidateDocumentsRow
	for rows.Next() {
		var i GetCandidateDocumentsRow
		if err := rows.Scan(
			&i.Uri,
			&i.AuthorDid,
			&i.Site,
			&i.Path,
			&i.Title,
			&i.Description,
			&i.TagsJson,
			&i.CanonicalUrl,
			&i.PublishedAt,
			&i.Embedding,
			&i.Engagement,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getDistinctAnnotationAuthors = `-- name: GetDistinctAnnotationAuthors :many
SELECT DISTINCT author_did FROM annotation_embeddings
`

func (q *Queries) GetDistinctAnnotationAuthors(ctx context.Context) ([]string, error) {
	rows, err := q.db.Query(ctx, getDistinctAnnotationAuthors)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []string
	for rows.Next() {
		var author_did string
		if err := rows.Scan(&author_did); err != nil {
			return nil, err
		}
		items = append(items, author_did)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getDocumentByCanonicalURL = `-- name: GetDocumentByCanonicalURL :one
SELECT uri, author_did, site, path, title, description, text_content, tags_json, canonical_url, published_at, indexed_at
FROM documents WHERE canonical_url = $1
`

func (q *Queries) GetDocumentByCanonicalURL(ctx context.Context, canonicalUrl *string) (Document, error) {
	row := q.db.QueryRow(ctx, getDocumentByCanonicalURL, canonicalUrl)
	var i Document
	err := row.Scan(
		&i.Uri,
		&i.AuthorDid,
		&i.Site,
		&i.Path,
		&i.Title,
		&i.Description,
		&i.TextContent,
		&i.TagsJson,
		&i.CanonicalUrl,
		&i.PublishedAt,
		&i.IndexedAt,
	)
	return i, err
}

const getDocumentByURI = `-- name: GetDocumentByURI :one
SELECT uri, author_did, site, path, title, description, text_content, tags_json, canonical_url, published_at, indexed_at
FROM documents WHERE uri = $1
`

func (q *Queries) GetDocumentByURI(ctx context.Context, uri string) (Document, error) {
	row := q.db.QueryRow(ctx, getDocumentByURI, uri)
	var i Document
	err := row.Scan(
		&i.Uri,
		&i.AuthorDid,
		&i.Site,
		&i.Path,
		&i.Title,
		&i.Description,
		&i.TextContent,
		&i.TagsJson,
		&i.CanonicalUrl,
		&i.PublishedAt,
		&i.IndexedAt,
	)
	return i, err
}

const getDocumentCount = `-- name: GetDocumentCount :one
SELECT COUNT(*) FROM documents
`

func (q *Queries) GetDocumentCount(ctx context.Context) (int64, error) {
	row := q.db.QueryRow(ctx, getDocumentCount)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const getDocumentsWithoutEmbeddings = `-- name: GetDocumentsWithoutEmbeddings :many
SELECT d.uri, d.author_did, d.site, d.path, d.title, d.description, d.text_content, d.tags_json, d.canonical_url, d.published_at, d.indexed_at
FROM documents d
LEFT JOIN document_embeddings de ON d.uri = de.document_uri
WHERE de.document_uri IS NULL
ORDER BY d.indexed_at DESC
LIMIT $1
`

func (q *Queries) GetDocumentsWithoutEmbeddings(ctx context.Context, limit int32) ([]Document, error) {
	rows, err := q.db.Query(ctx, getDocumentsWithoutEmbeddings, limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Document
	for rows.Next() {
		var i Document
		if err := rows.Scan(
			&i.Uri,
			&i.AuthorDid,
			&i.Site,
			&i.Path,
			&i.Title,
			&i.Description,
			&i.TextContent,
			&i.TagsJson,
			&i.CanonicalUrl,
			&i.PublishedAt,
			&i.IndexedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getHighlightsWithoutEmbeddings = `-- name: GetHighlightsWithoutEmbeddings :many
SELECT h.uri, h.author_did, h.target_source, h.target_title, h.selector_json, h.tags_json
FROM highlights h
LEFT JOIN annotation_embeddings ae ON h.uri = ae.annotation_uri
WHERE ae.annotation_uri IS NULL
ORDER BY h.created_at DESC
LIMIT $1
`

type GetHighlightsWithoutEmbeddingsRow struct {
	Uri          string  `json:"uri"`
	AuthorDid    string  `json:"authorDid"`
	TargetSource string  `json:"targetSource"`
	TargetTitle  *string `json:"targetTitle"`
	SelectorJson *string `json:"selectorJson"`
	TagsJson     *string `json:"tagsJson"`
}

func (q *Queries) GetHighlightsWithoutEmbeddings(ctx context.Context, limit int32) ([]GetHighlightsWithoutEmbeddingsRow, error) {
	rows, err := q.db.Query(ctx, getHighlightsWithoutEmbeddings, limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetHighlightsWithoutEmbeddingsRow
	for rows.Next() {
		var i GetHighlightsWithoutEmbeddingsRow
		if err := rows.Scan(
			&i.Uri,
			&i.AuthorDid,
			&i.TargetSource,
			&i.TargetTitle,
			&i.SelectorJson,
			&i.TagsJson,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getPopularDocuments = `-- name: GetPopularDocuments :many
SELECT d.uri, d.author_did, d.site, d.path, d.title, d.description, d.text_content, d.tags_json, d.canonical_url, d.published_at, d.indexed_at
FROM documents d
LEFT JOIN annotations a ON a.target_source = d.canonical_url
GROUP BY d.uri
ORDER BY COUNT(a.uri) DESC, d.published_at DESC
LIMIT $1 OFFSET $2
`

type GetPopularDocumentsParams struct {
	Limit  int32 `json:"limit"`
	Offset int32 `json:"offset"`
}

func (q *Queries) GetPopularDocuments(ctx context.Context, arg GetPopularDocumentsParams) ([]Document, error) {
	rows, err := q.db.Query(ctx, getPopularDocuments, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Document
	for rows.Next() {
		var i Document
		if err := rows.Scan(
			&i.Uri,
			&i.AuthorDid,
			&i.Site,
			&i.Path,
			&i.Title,
			&i.Description,
			&i.TextContent,
			&i.TagsJson,
			&i.CanonicalUrl,
			&i.PublishedAt,
			&i.IndexedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getPublicationByURL = `-- name: GetPublicationByURL :one
SELECT uri, author_did, url, name, description, show_in_discover, indexed_at
FROM publications WHERE url = $1
`

func (q *Queries) GetPublicationByURL(ctx context.Context, url string) (Publication, error) {
	row := q.db.QueryRow(ctx, getPublicationByURL, url)
	var i Publication
	err := row.Scan(
		&i.Uri,
		&i.AuthorDid,
		&i.Url,
		&i.Name,
		&i.Description,
		&i.ShowInDiscover,
		&i.IndexedAt,
	)
	return i, err
}

const getRecentAnnotationEmbeddingsByAuthor = `-- name: GetRecentAnnotationEmbeddingsByAuthor :many
SELECT annotation_uri, author_did, document_uri, embedding, updated_at FROM annotation_embeddings WHERE author_did = $1 ORDER BY updated_at DESC LIMIT $2
`

type GetRecentAnnotationEmbeddingsByAuthorParams struct {
	AuthorDid string `json:"authorDid"`
	Limit     int32  `json:"limit"`
}

func (q *Queries) GetRecentAnnotationEmbeddingsByAuthor(ctx context.Context, arg GetRecentAnnotationEmbeddingsByAuthorParams) ([]AnnotationEmbedding, error) {
	rows, err := q.db.Query(ctx, getRecentAnnotationEmbeddingsByAuthor, arg.AuthorDid, arg.Limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []AnnotationEmbedding
	for rows.Next() {
		var i AnnotationEmbedding
		if err := rows.Scan(
			&i.AnnotationUri,
			&i.AuthorDid,
			&i.DocumentUri,
			&i.Embedding,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getRecentDocuments = `-- name: GetRecentDocuments :many
SELECT uri, author_did, site, path, title, description, text_content, tags_json, canonical_url, published_at, indexed_at
FROM documents
ORDER BY published_at DESC
LIMIT $1 OFFSET $2
`

type GetRecentDocumentsParams struct {
	Limit  int32 `json:"limit"`
	Offset int32 `json:"offset"`
}

func (q *Queries) GetRecentDocuments(ctx context.Context, arg GetRecentDocumentsParams) ([]Document, error) {
	rows, err := q.db.Query(ctx, getRecentDocuments, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Document
	for rows.Next() {
		var i Document
		if err := rows.Scan(
			&i.Uri,
			&i.AuthorDid,
			&i.Site,
			&i.Path,
			&i.Title,
			&i.Description,
			&i.TextContent,
			&i.TagsJson,
			&i.CanonicalUrl,
			&i.PublishedAt,
			&i.IndexedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getUserProfile = `-- name: GetUserProfile :one
SELECT author_did, embedding, tag_affinities, annotation_count, updated_at FROM user_profiles WHERE author_did = $1
`

func (q *Queries) GetUserProfile(ctx context.Context, authorDid string) (UserProfile, error) {
	row := q.db.QueryRow(ctx, getUserProfile, authorDid)
	var i UserProfile
	err := row.Scan(
		&i.AuthorDid,
		&i.Embedding,
		&i.TagAffinities,
		&i.AnnotationCount,
		&i.UpdatedAt,
	)
	return i, err
}

const matchAnnotationToDocument = `-- name: MatchAnnotationToDocument :one
SELECT uri FROM documents WHERE canonical_url = $1
`

func (q *Queries) MatchAnnotationToDocument(ctx context.Context, canonicalUrl *string) (string, error) {
	row := q.db.QueryRow(ctx, matchAnnotationToDocument, canonicalUrl)
	var uri string
	err := row.Scan(&uri)
	return uri, err
}

const upsertAnnotationEmbedding = `-- name: UpsertAnnotationEmbedding :exec
INSERT INTO annotation_embeddings (annotation_uri, author_did, document_uri, embedding, updated_at) VALUES ($1, $2, $3, $4, $5)
ON CONFLICT(annotation_uri) DO UPDATE SET embedding = EXCLUDED.embedding, document_uri = EXCLUDED.document_uri, updated_at = EXCLUDED.updated_at
`

type UpsertAnnotationEmbeddingParams struct {
	AnnotationUri string    `json:"annotationUri"`
	AuthorDid     string    `json:"authorDid"`
	DocumentUri   *string   `json:"documentUri"`
	Embedding     string    `json:"embedding"`
	UpdatedAt     time.Time `json:"updatedAt"`
}

func (q *Queries) UpsertAnnotationEmbedding(ctx context.Context, arg UpsertAnnotationEmbeddingParams) error {
	_, err := q.db.Exec(ctx, upsertAnnotationEmbedding,
		arg.AnnotationUri,
		arg.AuthorDid,
		arg.DocumentUri,
		arg.Embedding,
		arg.UpdatedAt,
	)
	return err
}

const upsertDocument = `-- name: UpsertDocument :exec
INSERT INTO documents (uri, author_did, site, path, title, description, text_content, tags_json, canonical_url, published_at, indexed_at)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
ON CONFLICT(uri) DO UPDATE SET
    title = EXCLUDED.title,
    description = EXCLUDED.description,
    text_content = EXCLUDED.text_content,
    tags_json = EXCLUDED.tags_json,
    canonical_url = EXCLUDED.canonical_url,
    indexed_at = EXCLUDED.indexed_at
`

type UpsertDocumentParams struct {
	Uri          string    `json:"uri"`
	AuthorDid    string    `json:"authorDid"`
	Site         string    `json:"site"`
	Path         *string   `json:"path"`
	Title        string    `json:"title"`
	Description  *string   `json:"description"`
	TextContent  *string   `json:"textContent"`
	TagsJson     *string   `json:"tagsJson"`
	CanonicalUrl *string   `json:"canonicalUrl"`
	PublishedAt  time.Time `json:"publishedAt"`
	IndexedAt    time.Time `json:"indexedAt"`
}

func (q *Queries) UpsertDocument(ctx context.Context, arg UpsertDocumentParams) error {
	_, err := q.db.Exec(ctx, upsertDocument,
		arg.Uri,
		arg.AuthorDid,
		arg.Site,
		arg.Path,
		arg.Title,
		arg.Description,
		arg.TextContent,
		arg.TagsJson,
		arg.CanonicalUrl,
		arg.PublishedAt,
		arg.IndexedAt,
	)
	return err
}

const upsertDocumentEmbedding = `-- name: UpsertDocumentEmbedding :exec
INSERT INTO document_embeddings (document_uri, embedding, updated_at) VALUES ($1, $2, $3)
ON CONFLICT(document_uri) DO UPDATE SET embedding = EXCLUDED.embedding, updated_at = EXCLUDED.updated_at
`

type UpsertDocumentEmbeddingParams struct {
	DocumentUri string    `json:"documentUri"`
	Embedding   string    `json:"embedding"`
	UpdatedAt   time.Time `json:"updatedAt"`
}

func (q *Queries) UpsertDocumentEmbedding(ctx context.Context, arg UpsertDocumentEmbeddingParams) error {
	_, err := q.db.Exec(ctx, upsertDocumentEmbedding, arg.DocumentUri, arg.Embedding, arg.UpdatedAt)
	return err
}

const upsertPublication = `-- name: UpsertPublication :exec
INSERT INTO publications (uri, author_did, url, name, description, show_in_discover, indexed_at)
VALUES ($1, $2, $3, $4, $5, $6, $7)
ON CONFLICT(uri) DO UPDATE SET
    name = EXCLUDED.name,
    description = EXCLUDED.description,
    show_in_discover = EXCLUDED.show_in_discover,
    indexed_at = EXCLUDED.indexed_at
`

type UpsertPublicationParams struct {
	Uri            string    `json:"uri"`
	AuthorDid      string    `json:"authorDid"`
	Url            string    `json:"url"`
	Name           string    `json:"name"`
	Description    *string   `json:"description"`
	ShowInDiscover bool      `json:"showInDiscover"`
	IndexedAt      time.Time `json:"indexedAt"`
}

func (q *Queries) UpsertPublication(ctx context.Context, arg UpsertPublicationParams) error {
	_, err := q.db.Exec(ctx, upsertPublication,
		arg.Uri,
		arg.AuthorDid,
		arg.Url,
		arg.Name,
		arg.Description,
		arg.ShowInDiscover,
		arg.IndexedAt,
	)
	return err
}

const upsertUserProfile = `-- name: UpsertUserProfile :exec
INSERT INTO user_profiles (author_did, embedding, tag_affinities, annotation_count, updated_at) VALUES ($1, $2, $3, $4, $5)
ON CONFLICT(author_did) DO UPDATE SET embedding = EXCLUDED.embedding, tag_affinities = EXCLUDED.tag_affinities, annotation_count = EXCLUDED.annotation_count, updated_at = EXCLUDED.updated_at
`

type UpsertUserProfileParams struct {
	AuthorDid       string    `json:"authorDid"`
	Embedding       string    `json:"embedding"`
	TagAffinities   *string   `json:"tagAffinities"`
	AnnotationCount int32     `json:"annotationCount"`
	UpdatedAt       time.Time `json:"updatedAt"`
}

func (q *Queries) UpsertUserProfile(ctx context.Context, arg UpsertUserProfileParams) error {
	_, err := q.db.Exec(ctx, upsertUserProfile,
		arg.AuthorDid,
		arg.Embedding,
		arg.TagAffinities,
		arg.AnnotationCount,
		arg.UpdatedAt,
	)
	return err
}