// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.30.0
// source: favorites.sql

package sqlc

import (
	"context"
	"database/sql"
)

const CreateFavorite = `-- name: CreateFavorite :one
INSERT INTO favorites (url, title, favicon_url, folder_id, position, created_at, updated_at)
VALUES (?, ?, ?, ?, COALESCE((SELECT MAX(position) + 1 FROM favorites), 0), CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
RETURNING id, url, title, favicon_url, folder_id, shortcut_key, position, created_at, updated_at
`

type CreateFavoriteParams struct {
	Url        string         `json:"url"`
	Title      sql.NullString `json:"title"`
	FaviconUrl sql.NullString `json:"favicon_url"`
	FolderID   sql.NullInt64  `json:"folder_id"`
}

func (q *Queries) CreateFavorite(ctx context.Context, arg CreateFavoriteParams) (Favorite, error) {
	row := q.db.QueryRowContext(ctx, CreateFavorite,
		arg.Url,
		arg.Title,
		arg.FaviconUrl,
		arg.FolderID,
	)
	var i Favorite
	err := row.Scan(
		&i.ID,
		&i.Url,
		&i.Title,
		&i.FaviconUrl,
		&i.FolderID,
		&i.ShortcutKey,
		&i.Position,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const DeleteFavorite = `-- name: DeleteFavorite :exec
DELETE FROM favorites WHERE id = ?
`

func (q *Queries) DeleteFavorite(ctx context.Context, id int64) error {
	_, err := q.db.ExecContext(ctx, DeleteFavorite, id)
	return err
}

const GetAllFavorites = `-- name: GetAllFavorites :many
SELECT id, url, title, favicon_url, folder_id, shortcut_key, position, created_at, updated_at FROM favorites ORDER BY position ASC
`

func (q *Queries) GetAllFavorites(ctx context.Context) ([]Favorite, error) {
	rows, err := q.db.QueryContext(ctx, GetAllFavorites)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []Favorite{}
	for rows.Next() {
		var i Favorite
		if err := rows.Scan(
			&i.ID,
			&i.Url,
			&i.Title,
			&i.FaviconUrl,
			&i.FolderID,
			&i.ShortcutKey,
			&i.Position,
			&i.CreatedAt,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetFavoriteByID = `-- name: GetFavoriteByID :one
SELECT id, url, title, favicon_url, folder_id, shortcut_key, position, created_at, updated_at FROM favorites WHERE id = ? LIMIT 1
`

func (q *Queries) GetFavoriteByID(ctx context.Context, id int64) (Favorite, error) {
	row := q.db.QueryRowContext(ctx, GetFavoriteByID, id)
	var i Favorite
	err := row.Scan(
		&i.ID,
		&i.Url,
		&i.Title,
		&i.FaviconUrl,
		&i.FolderID,
		&i.ShortcutKey,
		&i.Position,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const GetFavoriteByShortcut = `-- name: GetFavoriteByShortcut :one
SELECT id, url, title, favicon_url, folder_id, shortcut_key, position, created_at, updated_at FROM favorites WHERE shortcut_key = ? LIMIT 1
`

func (q *Queries) GetFavoriteByShortcut(ctx context.Context, shortcutKey sql.NullInt64) (Favorite, error) {
	row := q.db.QueryRowContext(ctx, GetFavoriteByShortcut, shortcutKey)
	var i Favorite
	err := row.Scan(
		&i.ID,
		&i.Url,
		&i.Title,
		&i.FaviconUrl,
		&i.FolderID,
		&i.ShortcutKey,
		&i.Position,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const GetFavoriteByURL = `-- name: GetFavoriteByURL :one
SELECT id, url, title, favicon_url, folder_id, shortcut_key, position, created_at, updated_at FROM favorites WHERE url = ? LIMIT 1
`

func (q *Queries) GetFavoriteByURL(ctx context.Context, url string) (Favorite, error) {
	row := q.db.QueryRowContext(ctx, GetFavoriteByURL, url)
	var i Favorite
	err := row.Scan(
		&i.ID,
		&i.Url,
		&i.Title,
		&i.FaviconUrl,
		&i.FolderID,
		&i.ShortcutKey,
		&i.Position,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const GetFavoritesByFolder = `-- name: GetFavoritesByFolder :many
SELECT id, url, title, favicon_url, folder_id, shortcut_key, position, created_at, updated_at FROM favorites WHERE folder_id = ? ORDER BY position ASC
`

func (q *Queries) GetFavoritesByFolder(ctx context.Context, folderID sql.NullInt64) ([]Favorite, error) {
	rows, err := q.db.QueryContext(ctx, GetFavoritesByFolder, folderID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []Favorite{}
	for rows.Next() {
		var i Favorite
		if err := rows.Scan(
			&i.ID,
			&i.Url,
			&i.Title,
			&i.FaviconUrl,
			&i.FolderID,
			&i.ShortcutKey,
			&i.Position,
			&i.CreatedAt,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetFavoritesWithoutFolder = `-- name: GetFavoritesWithoutFolder :many
SELECT id, url, title, favicon_url, folder_id, shortcut_key, position, created_at, updated_at FROM favorites WHERE folder_id IS NULL ORDER BY position ASC
`

func (q *Queries) GetFavoritesWithoutFolder(ctx context.Context) ([]Favorite, error) {
	rows, err := q.db.QueryContext(ctx, GetFavoritesWithoutFolder)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []Favorite{}
	for rows.Next() {
		var i Favorite
		if err := rows.Scan(
			&i.ID,
			&i.Url,
			&i.Title,
			&i.FaviconUrl,
			&i.FolderID,
			&i.ShortcutKey,
			&i.Position,
			&i.CreatedAt,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const SetFavoriteFolder = `-- name: SetFavoriteFolder :exec
UPDATE favorites SET folder_id = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?
`

type SetFavoriteFolderParams struct {
	FolderID sql.NullInt64 `json:"folder_id"`
	ID       int64         `json:"id"`
}

func (q *Queries) SetFavoriteFolder(ctx context.Context, arg SetFavoriteFolderParams) error {
	_, err := q.db.ExecContext(ctx, SetFavoriteFolder, arg.FolderID, arg.ID)
	return err
}

const SetFavoriteShortcut = `-- name: SetFavoriteShortcut :exec
UPDATE favorites SET shortcut_key = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?
`

type SetFavoriteShortcutParams struct {
	ShortcutKey sql.NullInt64 `json:"shortcut_key"`
	ID          int64         `json:"id"`
}

func (q *Queries) SetFavoriteShortcut(ctx context.Context, arg SetFavoriteShortcutParams) error {
	_, err := q.db.ExecContext(ctx, SetFavoriteShortcut, arg.ShortcutKey, arg.ID)
	return err
}

const UpdateFavorite = `-- name: UpdateFavorite :exec
UPDATE favorites
SET title = ?, favicon_url = ?, updated_at = CURRENT_TIMESTAMP
WHERE id = ?
`

type UpdateFavoriteParams struct {
	Title      sql.NullString `json:"title"`
	FaviconUrl sql.NullString `json:"favicon_url"`
	ID         int64          `json:"id"`
}

func (q *Queries) UpdateFavorite(ctx context.Context, arg UpdateFavoriteParams) error {
	_, err := q.db.ExecContext(ctx, UpdateFavorite, arg.Title, arg.FaviconUrl, arg.ID)
	return err
}

const UpdateFavoritePosition = `-- name: UpdateFavoritePosition :exec
UPDATE favorites SET position = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?
`

type UpdateFavoritePositionParams struct {
	Position int64 `json:"position"`
	ID       int64 `json:"id"`
}

func (q *Queries) UpdateFavoritePosition(ctx context.Context, arg UpdateFavoritePositionParams) error {
	_, err := q.db.ExecContext(ctx, UpdateFavoritePosition, arg.Position, arg.ID)
	return err
}