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

package db

import (
	"context"
	"database/sql"
)

const createRecipeIngredient = `-- name: CreateRecipeIngredient :exec
INSERT INTO recipe_ingredients (
	id, recipe_id, position, raw_text, name, qty, unit, note,
	created_at, updated_at
) VALUES (
	?, ?, ?, ?, ?, ?, ?, ?,
	?, ?
)
`

type CreateRecipeIngredientParams struct {
	ID        string
	RecipeID  string
	Position  int64
	RawText   string
	Name      sql.NullString
	Qty       sql.NullString
	Unit      sql.NullString
	Note      sql.NullString
	CreatedAt string
	UpdatedAt string
}

func (q *Queries) CreateRecipeIngredient(ctx context.Context, arg CreateRecipeIngredientParams) error {
	_, err := q.db.ExecContext(ctx, createRecipeIngredient,
		arg.ID,
		arg.RecipeID,
		arg.Position,
		arg.RawText,
		arg.Name,
		arg.Qty,
		arg.Unit,
		arg.Note,
		arg.CreatedAt,
		arg.UpdatedAt,
	)
	return err
}

const createRecipeStep = `-- name: CreateRecipeStep :exec
INSERT INTO recipe_steps (
	id, recipe_id, position, text, created_at, updated_at
) VALUES (
	?, ?, ?, ?, ?, ?
)
`

type CreateRecipeStepParams struct {
	ID        string
	RecipeID  string
	Position  int64
	Text      string
	CreatedAt string
	UpdatedAt string
}

func (q *Queries) CreateRecipeStep(ctx context.Context, arg CreateRecipeStepParams) error {
	_, err := q.db.ExecContext(ctx, createRecipeStep,
		arg.ID,
		arg.RecipeID,
		arg.Position,
		arg.Text,
		arg.CreatedAt,
		arg.UpdatedAt,
	)
	return err
}

const deleteRecipeIngredients = `-- name: DeleteRecipeIngredients :exec
DELETE FROM recipe_ingredients
WHERE recipe_id = ?
`

func (q *Queries) DeleteRecipeIngredients(ctx context.Context, recipeID string) error {
	_, err := q.db.ExecContext(ctx, deleteRecipeIngredients, recipeID)
	return err
}

const deleteRecipeSteps = `-- name: DeleteRecipeSteps :exec
DELETE FROM recipe_steps
WHERE recipe_id = ?
`

func (q *Queries) DeleteRecipeSteps(ctx context.Context, recipeID string) error {
	_, err := q.db.ExecContext(ctx, deleteRecipeSteps, recipeID)
	return err
}

const getRecipe = `-- name: GetRecipe :one
SELECT id, source_url, site_name, title, total_minutes, prep_minutes, cook_minutes, yield, raw_jsonld, fetched_at, created_at, updated_at FROM recipes
WHERE id = ?
`

func (q *Queries) GetRecipe(ctx context.Context, id string) (Recipe, error) {
	row := q.db.QueryRowContext(ctx, getRecipe, id)
	var i Recipe
	err := row.Scan(
		&i.ID,
		&i.SourceUrl,
		&i.SiteName,
		&i.Title,
		&i.TotalMinutes,
		&i.PrepMinutes,
		&i.CookMinutes,
		&i.Yield,
		&i.RawJsonld,
		&i.FetchedAt,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const getRecipeBySourceURL = `-- name: GetRecipeBySourceURL :one
SELECT id, source_url, site_name, title, total_minutes, prep_minutes, cook_minutes, yield, raw_jsonld, fetched_at, created_at, updated_at FROM recipes
WHERE source_url = ?
`

func (q *Queries) GetRecipeBySourceURL(ctx context.Context, sourceUrl string) (Recipe, error) {
	row := q.db.QueryRowContext(ctx, getRecipeBySourceURL, sourceUrl)
	var i Recipe
	err := row.Scan(
		&i.ID,
		&i.SourceUrl,
		&i.SiteName,
		&i.Title,
		&i.TotalMinutes,
		&i.PrepMinutes,
		&i.CookMinutes,
		&i.Yield,
		&i.RawJsonld,
		&i.FetchedAt,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const listRecipeIngredients = `-- name: ListRecipeIngredients :many
SELECT id, recipe_id, position, raw_text, name, qty, unit, note, created_at, updated_at FROM recipe_ingredients
WHERE recipe_id = ?
ORDER BY position, id
`

func (q *Queries) ListRecipeIngredients(ctx context.Context, recipeID string) ([]RecipeIngredient, error) {
	rows, err := q.db.QueryContext(ctx, listRecipeIngredients, recipeID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []RecipeIngredient
	for rows.Next() {
		var i RecipeIngredient
		if err := rows.Scan(
			&i.ID,
			&i.RecipeID,
			&i.Position,
			&i.RawText,
			&i.Name,
			&i.Qty,
			&i.Unit,
			&i.Note,
			&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 listRecipeSteps = `-- name: ListRecipeSteps :many
SELECT id, recipe_id, position, text, created_at, updated_at FROM recipe_steps
WHERE recipe_id = ?
ORDER BY position, id
`

func (q *Queries) ListRecipeSteps(ctx context.Context, recipeID string) ([]RecipeStep, error) {
	rows, err := q.db.QueryContext(ctx, listRecipeSteps, recipeID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []RecipeStep
	for rows.Next() {
		var i RecipeStep
		if err := rows.Scan(
			&i.ID,
			&i.RecipeID,
			&i.Position,
			&i.Text,
			&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 upsertRecipe = `-- name: UpsertRecipe :one
INSERT INTO recipes (
	id, source_url, site_name, title, total_minutes, prep_minutes,
	cook_minutes, yield, raw_jsonld, fetched_at, created_at, updated_at
) VALUES (
	?, ?, ?, ?, ?, ?,
	?, ?, ?, ?, ?, ?
)
ON CONFLICT (source_url) DO UPDATE SET
	site_name = excluded.site_name,
	title = excluded.title,
	total_minutes = excluded.total_minutes,
	prep_minutes = excluded.prep_minutes,
	cook_minutes = excluded.cook_minutes,
	yield = excluded.yield,
	raw_jsonld = excluded.raw_jsonld,
	fetched_at = excluded.fetched_at,
	updated_at = excluded.updated_at
RETURNING id, source_url, site_name, title, total_minutes, prep_minutes, cook_minutes, yield, raw_jsonld, fetched_at, created_at, updated_at
`

type UpsertRecipeParams struct {
	ID           string
	SourceUrl    string
	SiteName     sql.NullString
	Title        string
	TotalMinutes sql.NullInt64
	PrepMinutes  sql.NullInt64
	CookMinutes  sql.NullInt64
	Yield        sql.NullString
	RawJsonld    string
	FetchedAt    string
	CreatedAt    string
	UpdatedAt    string
}

// A recipe is keyed by source_url: re-fetching the same URL updates the
// existing row and keeps its id and created_at, which the returned row
// carries. Replace its ingredients and steps in the same transaction with
// DeleteRecipeIngredients/DeleteRecipeSteps then the Create queries.
func (q *Queries) UpsertRecipe(ctx context.Context, arg UpsertRecipeParams) (Recipe, error) {
	row := q.db.QueryRowContext(ctx, upsertRecipe,
		arg.ID,
		arg.SourceUrl,
		arg.SiteName,
		arg.Title,
		arg.TotalMinutes,
		arg.PrepMinutes,
		arg.CookMinutes,
		arg.Yield,
		arg.RawJsonld,
		arg.FetchedAt,
		arg.CreatedAt,
		arg.UpdatedAt,
	)
	var i Recipe
	err := row.Scan(
		&i.ID,
		&i.SourceUrl,
		&i.SiteName,
		&i.Title,
		&i.TotalMinutes,
		&i.PrepMinutes,
		&i.CookMinutes,
		&i.Yield,
		&i.RawJsonld,
		&i.FetchedAt,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}