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

package sqlcdb

import (
	"context"
	"time"
)

const createHighlight = `-- name: CreateHighlight :exec
INSERT INTO highlights (uri, author_did, target_source, target_hash, target_title, selector_json, color, tags_json, created_at, indexed_at, cid)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
ON CONFLICT(uri) DO UPDATE SET
    target_source = EXCLUDED.target_source,
    target_hash = EXCLUDED.target_hash,
    target_title = EXCLUDED.target_title,
    selector_json = EXCLUDED.selector_json,
    color = EXCLUDED.color,
    tags_json = EXCLUDED.tags_json,
    indexed_at = EXCLUDED.indexed_at,
    cid = EXCLUDED.cid
`

type CreateHighlightParams struct {
	Uri          string    `json:"uri"`
	AuthorDid    string    `json:"authorDid"`
	TargetSource string    `json:"targetSource"`
	TargetHash   string    `json:"targetHash"`
	TargetTitle  *string   `json:"targetTitle"`
	SelectorJson *string   `json:"selectorJson"`
	Color        *string   `json:"color"`
	TagsJson     *string   `json:"tagsJson"`
	CreatedAt    time.Time `json:"createdAt"`
	IndexedAt    time.Time `json:"indexedAt"`
	Cid          *string   `json:"cid"`
}

func (q *Queries) CreateHighlight(ctx context.Context, arg CreateHighlightParams) error {
	_, err := q.db.Exec(ctx, createHighlight,
		arg.Uri,
		arg.AuthorDid,
		arg.TargetSource,
		arg.TargetHash,
		arg.TargetTitle,
		arg.SelectorJson,
		arg.Color,
		arg.TagsJson,
		arg.CreatedAt,
		arg.IndexedAt,
		arg.Cid,
	)
	return err
}

const deleteHighlight = `-- name: DeleteHighlight :exec
DELETE FROM highlights WHERE uri = $1
`

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

const getHighlightByURI = `-- name: GetHighlightByURI :one
SELECT uri, author_did, target_source, target_hash, target_title, selector_json, color, tags_json, created_at, indexed_at, cid
FROM all_highlights
WHERE uri = $1
`

func (q *Queries) GetHighlightByURI(ctx context.Context, uri string) (AllHighlight, error) {
	row := q.db.QueryRow(ctx, getHighlightByURI, uri)
	var i AllHighlight
	err := row.Scan(
		&i.Uri,
		&i.AuthorDid,
		&i.TargetSource,
		&i.TargetHash,
		&i.TargetTitle,
		&i.SelectorJson,
		&i.Color,
		&i.TagsJson,
		&i.CreatedAt,
		&i.IndexedAt,
		&i.Cid,
	)
	return i, err
}

const getHighlightURIs = `-- name: GetHighlightURIs :many
SELECT uri FROM all_highlights WHERE author_did = $1
`

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

const getHighlightsByAuthor = `-- name: GetHighlightsByAuthor :many
SELECT uri, author_did, target_source, target_hash, target_title, selector_json, color, tags_json, created_at, indexed_at, cid
FROM all_highlights
WHERE author_did = $1
ORDER BY created_at DESC
LIMIT $2 OFFSET $3
`

type GetHighlightsByAuthorParams struct {
	AuthorDid string `json:"authorDid"`
	Limit     int32  `json:"limit"`
	Offset    int32  `json:"offset"`
}

func (q *Queries) GetHighlightsByAuthor(ctx context.Context, arg GetHighlightsByAuthorParams) ([]AllHighlight, error) {
	rows, err := q.db.Query(ctx, getHighlightsByAuthor, arg.AuthorDid, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []AllHighlight
	for rows.Next() {
		var i AllHighlight
		if err := rows.Scan(
			&i.Uri,
			&i.AuthorDid,
			&i.TargetSource,
			&i.TargetHash,
			&i.TargetTitle,
			&i.SelectorJson,
			&i.Color,
			&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 getHighlightsByAuthorAndTargetHash = `-- name: GetHighlightsByAuthorAndTargetHash :many
SELECT uri, author_did, target_source, target_hash, target_title, selector_json, color, tags_json, created_at, indexed_at, cid
FROM all_highlights
WHERE author_did = $1 AND target_hash = $2
ORDER BY created_at DESC
LIMIT $3 OFFSET $4
`

type GetHighlightsByAuthorAndTargetHashParams struct {
	AuthorDid  string `json:"authorDid"`
	TargetHash string `json:"targetHash"`
	Limit      int32  `json:"limit"`
	Offset     int32  `json:"offset"`
}

func (q *Queries) GetHighlightsByAuthorAndTargetHash(ctx context.Context, arg GetHighlightsByAuthorAndTargetHashParams) ([]AllHighlight, error) {
	rows, err := q.db.Query(ctx, getHighlightsByAuthorAndTargetHash,
		arg.AuthorDid,
		arg.TargetHash,
		arg.Limit,
		arg.Offset,
	)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []AllHighlight
	for rows.Next() {
		var i AllHighlight
		if err := rows.Scan(
			&i.Uri,
			&i.AuthorDid,
			&i.TargetSource,
			&i.TargetHash,
			&i.TargetTitle,
			&i.SelectorJson,
			&i.Color,
			&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 getHighlightsByTag = `-- name: GetHighlightsByTag :many
SELECT uri, author_did, target_source, target_hash, target_title, selector_json, color, tags_json, created_at, indexed_at, cid
FROM all_highlights
WHERE lower(tags_json)::jsonb ? $1
ORDER BY created_at DESC
LIMIT $2 OFFSET $3
`

type GetHighlightsByTagParams struct {
	TagsJson *string `json:"tagsJson"`
	Limit    int32   `json:"limit"`
	Offset   int32   `json:"offset"`
}

func (q *Queries) GetHighlightsByTag(ctx context.Context, arg GetHighlightsByTagParams) ([]AllHighlight, error) {
	rows, err := q.db.Query(ctx, getHighlightsByTag, arg.TagsJson, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []AllHighlight
	for rows.Next() {
		var i AllHighlight
		if err := rows.Scan(
			&i.Uri,
			&i.AuthorDid,
			&i.TargetSource,
			&i.TargetHash,
			&i.TargetTitle,
			&i.SelectorJson,
			&i.Color,
			&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 getHighlightsByTagAndAuthor = `-- name: GetHighlightsByTagAndAuthor :many
SELECT uri, author_did, target_source, target_hash, target_title, selector_json, color, tags_json, created_at, indexed_at, cid
FROM all_highlights
WHERE author_did = $1 AND lower(tags_json)::jsonb ? $2
ORDER BY created_at DESC
LIMIT $3 OFFSET $4
`

type GetHighlightsByTagAndAuthorParams struct {
	AuthorDid string  `json:"authorDid"`
	TagsJson  *string `json:"tagsJson"`
	Limit     int32   `json:"limit"`
	Offset    int32   `json:"offset"`
}

func (q *Queries) GetHighlightsByTagAndAuthor(ctx context.Context, arg GetHighlightsByTagAndAuthorParams) ([]AllHighlight, error) {
	rows, err := q.db.Query(ctx, getHighlightsByTagAndAuthor,
		arg.AuthorDid,
		arg.TagsJson,
		arg.Limit,
		arg.Offset,
	)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []AllHighlight
	for rows.Next() {
		var i AllHighlight
		if err := rows.Scan(
			&i.Uri,
			&i.AuthorDid,
			&i.TargetSource,
			&i.TargetHash,
			&i.TargetTitle,
			&i.SelectorJson,
			&i.Color,
			&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 getHighlightsByTargetHash = `-- name: GetHighlightsByTargetHash :many
SELECT uri, author_did, target_source, target_hash, target_title, selector_json, color, tags_json, created_at, indexed_at, cid
FROM all_highlights
WHERE target_hash = $1
ORDER BY created_at DESC
LIMIT $2 OFFSET $3
`

type GetHighlightsByTargetHashParams struct {
	TargetHash string `json:"targetHash"`
	Limit      int32  `json:"limit"`
	Offset     int32  `json:"offset"`
}

func (q *Queries) GetHighlightsByTargetHash(ctx context.Context, arg GetHighlightsByTargetHashParams) ([]AllHighlight, error) {
	rows, err := q.db.Query(ctx, getHighlightsByTargetHash, arg.TargetHash, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []AllHighlight
	for rows.Next() {
		var i AllHighlight
		if err := rows.Scan(
			&i.Uri,
			&i.AuthorDid,
			&i.TargetSource,
			&i.TargetHash,
			&i.TargetTitle,
			&i.SelectorJson,
			&i.Color,
			&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 getHighlightsByURIs = `-- name: GetHighlightsByURIs :many
SELECT uri, author_did, target_source, target_hash, target_title, selector_json, color, tags_json, created_at, indexed_at, cid
FROM all_highlights
WHERE uri = ANY($1::text[])
`

func (q *Queries) GetHighlightsByURIs(ctx context.Context, dollar_1 []string) ([]AllHighlight, error) {
	rows, err := q.db.Query(ctx, getHighlightsByURIs, dollar_1)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []AllHighlight
	for rows.Next() {
		var i AllHighlight
		if err := rows.Scan(
			&i.Uri,
			&i.AuthorDid,
			&i.TargetSource,
			&i.TargetHash,
			&i.TargetTitle,
			&i.SelectorJson,
			&i.Color,
			&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 getMarginHighlights = `-- name: GetMarginHighlights :many
SELECT uri, author_did, target_source, target_hash, target_title, selector_json, color, tags_json, created_at, indexed_at, cid
FROM all_highlights
WHERE uri NOT LIKE '%network.cosmik%'
ORDER BY created_at DESC
LIMIT $1 OFFSET $2
`

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

func (q *Queries) GetMarginHighlights(ctx context.Context, arg GetMarginHighlightsParams) ([]AllHighlight, error) {
	rows, err := q.db.Query(ctx, getMarginHighlights, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []AllHighlight
	for rows.Next() {
		var i AllHighlight
		if err := rows.Scan(
			&i.Uri,
			&i.AuthorDid,
			&i.TargetSource,
			&i.TargetHash,
			&i.TargetTitle,
			&i.SelectorJson,
			&i.Color,
			&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 getMarginHighlightsByAuthor = `-- name: GetMarginHighlightsByAuthor :many
SELECT uri, author_did, target_source, target_hash, target_title, selector_json, color, tags_json, created_at, indexed_at, cid
FROM all_highlights
WHERE author_did = $1 AND uri NOT LIKE '%network.cosmik%'
ORDER BY created_at DESC
LIMIT $2 OFFSET $3
`

type GetMarginHighlightsByAuthorParams struct {
	AuthorDid string `json:"authorDid"`
	Limit     int32  `json:"limit"`
	Offset    int32  `json:"offset"`
}

func (q *Queries) GetMarginHighlightsByAuthor(ctx context.Context, arg GetMarginHighlightsByAuthorParams) ([]AllHighlight, error) {
	rows, err := q.db.Query(ctx, getMarginHighlightsByAuthor, arg.AuthorDid, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []AllHighlight
	for rows.Next() {
		var i AllHighlight
		if err := rows.Scan(
			&i.Uri,
			&i.AuthorDid,
			&i.TargetSource,
			&i.TargetHash,
			&i.TargetTitle,
			&i.SelectorJson,
			&i.Color,
			&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 getMarginHighlightsByTag = `-- name: GetMarginHighlightsByTag :many
SELECT uri, author_did, target_source, target_hash, target_title, selector_json, color, tags_json, created_at, indexed_at, cid
FROM all_highlights
WHERE lower(tags_json)::jsonb ? $1 AND uri NOT LIKE '%network.cosmik%'
ORDER BY created_at DESC
LIMIT $2 OFFSET $3
`

type GetMarginHighlightsByTagParams struct {
	TagsJson *string `json:"tagsJson"`
	Limit    int32   `json:"limit"`
	Offset   int32   `json:"offset"`
}

func (q *Queries) GetMarginHighlightsByTag(ctx context.Context, arg GetMarginHighlightsByTagParams) ([]AllHighlight, error) {
	rows, err := q.db.Query(ctx, getMarginHighlightsByTag, arg.TagsJson, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []AllHighlight
	for rows.Next() {
		var i AllHighlight
		if err := rows.Scan(
			&i.Uri,
			&i.AuthorDid,
			&i.TargetSource,
			&i.TargetHash,
			&i.TargetTitle,
			&i.SelectorJson,
			&i.Color,
			&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 getMarginHighlightsByTagAndAuthor = `-- name: GetMarginHighlightsByTagAndAuthor :many
SELECT uri, author_did, target_source, target_hash, target_title, selector_json, color, tags_json, created_at, indexed_at, cid
FROM all_highlights
WHERE author_did = $1 AND lower(tags_json)::jsonb ? $2 AND uri NOT LIKE '%network.cosmik%'
ORDER BY created_at DESC
LIMIT $3 OFFSET $4
`

type GetMarginHighlightsByTagAndAuthorParams struct {
	AuthorDid string  `json:"authorDid"`
	TagsJson  *string `json:"tagsJson"`
	Limit     int32   `json:"limit"`
	Offset    int32   `json:"offset"`
}

func (q *Queries) GetMarginHighlightsByTagAndAuthor(ctx context.Context, arg GetMarginHighlightsByTagAndAuthorParams) ([]AllHighlight, error) {
	rows, err := q.db.Query(ctx, getMarginHighlightsByTagAndAuthor,
		arg.AuthorDid,
		arg.TagsJson,
		arg.Limit,
		arg.Offset,
	)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []AllHighlight
	for rows.Next() {
		var i AllHighlight
		if err := rows.Scan(
			&i.Uri,
			&i.AuthorDid,
			&i.TargetSource,
			&i.TargetHash,
			&i.TargetTitle,
			&i.SelectorJson,
			&i.Color,
			&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 getPopularHighlights = `-- name: GetPopularHighlights :many
SELECT
    h.uri, h.author_did, h.target_source, h.target_hash, h.target_title,
    h.selector_json, h.color, h.tags_json, h.created_at, h.indexed_at, h.cid
FROM all_highlights h
LEFT JOIN LATERAL (
    SELECT COUNT(*) as cnt FROM likes WHERE subject_uri = h.uri
) l ON true
LEFT JOIN LATERAL (
    SELECT COUNT(*) as cnt FROM replies WHERE root_uri = h.uri
) r ON true
WHERE h.created_at > $1 AND (l.cnt + r.cnt) > 0
ORDER BY (l.cnt + r.cnt) DESC, h.created_at DESC
LIMIT $2 OFFSET $3
`

type GetPopularHighlightsParams struct {
	CreatedAt time.Time `json:"createdAt"`
	Limit     int32     `json:"limit"`
	Offset    int32     `json:"offset"`
}

func (q *Queries) GetPopularHighlights(ctx context.Context, arg GetPopularHighlightsParams) ([]AllHighlight, error) {
	rows, err := q.db.Query(ctx, getPopularHighlights, arg.CreatedAt, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []AllHighlight
	for rows.Next() {
		var i AllHighlight
		if err := rows.Scan(
			&i.Uri,
			&i.AuthorDid,
			&i.TargetSource,
			&i.TargetHash,
			&i.TargetTitle,
			&i.SelectorJson,
			&i.Color,
			&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 getRecentHighlights = `-- name: GetRecentHighlights :many
SELECT uri, author_did, target_source, target_hash, target_title, selector_json, color, tags_json, created_at, indexed_at, cid
FROM all_highlights
ORDER BY created_at DESC
LIMIT $1 OFFSET $2
`

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

func (q *Queries) GetRecentHighlights(ctx context.Context, arg GetRecentHighlightsParams) ([]AllHighlight, error) {
	rows, err := q.db.Query(ctx, getRecentHighlights, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []AllHighlight
	for rows.Next() {
		var i AllHighlight
		if err := rows.Scan(
			&i.Uri,
			&i.AuthorDid,
			&i.TargetSource,
			&i.TargetHash,
			&i.TargetTitle,
			&i.SelectorJson,
			&i.Color,
			&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 getSembleHighlights = `-- name: GetSembleHighlights :many
SELECT uri, author_did, target_source, target_hash, target_title, selector_json, color, tags_json, created_at, indexed_at, cid
FROM all_highlights
WHERE uri LIKE '%network.cosmik%'
ORDER BY created_at DESC
LIMIT $1 OFFSET $2
`

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

func (q *Queries) GetSembleHighlights(ctx context.Context, arg GetSembleHighlightsParams) ([]AllHighlight, error) {
	rows, err := q.db.Query(ctx, getSembleHighlights, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []AllHighlight
	for rows.Next() {
		var i AllHighlight
		if err := rows.Scan(
			&i.Uri,
			&i.AuthorDid,
			&i.TargetSource,
			&i.TargetHash,
			&i.TargetTitle,
			&i.SelectorJson,
			&i.Color,
			&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 getSembleHighlightsByAuthor = `-- name: GetSembleHighlightsByAuthor :many
SELECT uri, author_did, target_source, target_hash, target_title, selector_json, color, tags_json, created_at, indexed_at, cid
FROM all_highlights
WHERE author_did = $1 AND uri LIKE '%network.cosmik%'
ORDER BY created_at DESC
LIMIT $2 OFFSET $3
`

type GetSembleHighlightsByAuthorParams struct {
	AuthorDid string `json:"authorDid"`
	Limit     int32  `json:"limit"`
	Offset    int32  `json:"offset"`
}

func (q *Queries) GetSembleHighlightsByAuthor(ctx context.Context, arg GetSembleHighlightsByAuthorParams) ([]AllHighlight, error) {
	rows, err := q.db.Query(ctx, getSembleHighlightsByAuthor, arg.AuthorDid, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []AllHighlight
	for rows.Next() {
		var i AllHighlight
		if err := rows.Scan(
			&i.Uri,
			&i.AuthorDid,
			&i.TargetSource,
			&i.TargetHash,
			&i.TargetTitle,
			&i.SelectorJson,
			&i.Color,
			&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 getSembleHighlightsByTag = `-- name: GetSembleHighlightsByTag :many
SELECT uri, author_did, target_source, target_hash, target_title, selector_json, color, tags_json, created_at, indexed_at, cid
FROM all_highlights
WHERE lower(tags_json)::jsonb ? $1 AND uri LIKE '%network.cosmik%'
ORDER BY created_at DESC
LIMIT $2 OFFSET $3
`

type GetSembleHighlightsByTagParams struct {
	TagsJson *string `json:"tagsJson"`
	Limit    int32   `json:"limit"`
	Offset   int32   `json:"offset"`
}

func (q *Queries) GetSembleHighlightsByTag(ctx context.Context, arg GetSembleHighlightsByTagParams) ([]AllHighlight, error) {
	rows, err := q.db.Query(ctx, getSembleHighlightsByTag, arg.TagsJson, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []AllHighlight
	for rows.Next() {
		var i AllHighlight
		if err := rows.Scan(
			&i.Uri,
			&i.AuthorDid,
			&i.TargetSource,
			&i.TargetHash,
			&i.TargetTitle,
			&i.SelectorJson,
			&i.Color,
			&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 getSembleHighlightsByTagAndAuthor = `-- name: GetSembleHighlightsByTagAndAuthor :many
SELECT uri, author_did, target_source, target_hash, target_title, selector_json, color, tags_json, created_at, indexed_at, cid
FROM all_highlights
WHERE author_did = $1 AND lower(tags_json)::jsonb ? $2 AND uri LIKE '%network.cosmik%'
ORDER BY created_at DESC
LIMIT $3 OFFSET $4
`

type GetSembleHighlightsByTagAndAuthorParams struct {
	AuthorDid string  `json:"authorDid"`
	TagsJson  *string `json:"tagsJson"`
	Limit     int32   `json:"limit"`
	Offset    int32   `json:"offset"`
}

func (q *Queries) GetSembleHighlightsByTagAndAuthor(ctx context.Context, arg GetSembleHighlightsByTagAndAuthorParams) ([]AllHighlight, error) {
	rows, err := q.db.Query(ctx, getSembleHighlightsByTagAndAuthor,
		arg.AuthorDid,
		arg.TagsJson,
		arg.Limit,
		arg.Offset,
	)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []AllHighlight
	for rows.Next() {
		var i AllHighlight
		if err := rows.Scan(
			&i.Uri,
			&i.AuthorDid,
			&i.TargetSource,
			&i.TargetHash,
			&i.TargetTitle,
			&i.SelectorJson,
			&i.Color,
			&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 getShelvedHighlights = `-- name: GetShelvedHighlights :many
SELECT
    h.uri, h.author_did, h.target_source, h.target_hash, h.target_title,
    h.selector_json, h.color, h.tags_json, h.created_at, h.indexed_at, h.cid
FROM all_highlights h
WHERE h.created_at < $1 AND h.created_at > $2
    AND NOT EXISTS (SELECT 1 FROM likes WHERE subject_uri = h.uri)
    AND NOT EXISTS (SELECT 1 FROM replies WHERE root_uri = h.uri)
ORDER BY RANDOM()
LIMIT $3 OFFSET $4
`

type GetShelvedHighlightsParams struct {
	CreatedAt   time.Time `json:"createdAt"`
	CreatedAt_2 time.Time `json:"createdAt2"`
	Limit       int32     `json:"limit"`
	Offset      int32     `json:"offset"`
}

func (q *Queries) GetShelvedHighlights(ctx context.Context, arg GetShelvedHighlightsParams) ([]AllHighlight, error) {
	rows, err := q.db.Query(ctx, getShelvedHighlights,
		arg.CreatedAt,
		arg.CreatedAt_2,
		arg.Limit,
		arg.Offset,
	)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []AllHighlight
	for rows.Next() {
		var i AllHighlight
		if err := rows.Scan(
			&i.Uri,
			&i.AuthorDid,
			&i.TargetSource,
			&i.TargetHash,
			&i.TargetTitle,
			&i.SelectorJson,
			&i.Color,
			&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 updateHighlight = `-- name: UpdateHighlight :exec
UPDATE highlights
SET color = $1, tags_json = $2, cid = $3, indexed_at = $4
WHERE uri = $5
`

type UpdateHighlightParams struct {
	Color     *string   `json:"color"`
	TagsJson  *string   `json:"tagsJson"`
	Cid       *string   `json:"cid"`
	IndexedAt time.Time `json:"indexedAt"`
	Uri       string    `json:"uri"`
}

func (q *Queries) UpdateHighlight(ctx context.Context, arg UpdateHighlightParams) error {
	_, err := q.db.Exec(ctx, updateHighlight,
		arg.Color,
		arg.TagsJson,
		arg.Cid,
		arg.IndexedAt,
		arg.Uri,
	)
	return err
}