// SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Commercial
// SPDX-FileCopyrightText: 2025-2026 Christian Galo

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.29.0
// source: entitlement_sets.sql

package entitlements

import (
	"context"
	"database/sql"

	"github.com/lib/pq"
)

const anyActiveEntitlementSet = `-- name: AnyActiveEntitlementSet :one
SELECT EXISTS(SELECT 1 FROM core.entitlement_sets WHERE is_active = TRUE)
`

// Setup-checklist existence probe: the whole-table answer, not a lookup.
func (q *Queries) AnyActiveEntitlementSet(ctx context.Context) (bool, error) {
	row := q.db.QueryRowContext(ctx, anyActiveEntitlementSet)
	var exists bool
	err := row.Scan(&exists)
	return exists, err
}

const createEntitlementSet = `-- name: CreateEntitlementSet :one
INSERT INTO core.entitlement_sets (name, description, is_active, key)
VALUES ($1, $2, $3, $4)
RETURNING set_id, name, description, is_active, created_at, updated_at, key
`

type CreateEntitlementSetParams struct {
	Name        string         `json:"name"`
	Description sql.NullString `json:"description"`
	IsActive    bool           `json:"is_active"`
	Key         sql.NullString `json:"key"`
}

// `key` is the optional declarative address (entity-keys §3), root-scoped.
// The operator create form does not collect one, so a UI-created set leaves
// it NULL; a seed or a configuration loader supplies it.
func (q *Queries) CreateEntitlementSet(ctx context.Context, arg CreateEntitlementSetParams) (EntitlementSet, error) {
	row := q.db.QueryRowContext(ctx, createEntitlementSet,
		arg.Name,
		arg.Description,
		arg.IsActive,
		arg.Key,
	)
	var i EntitlementSet
	err := row.Scan(
		&i.SetID,
		&i.Name,
		&i.Description,
		&i.IsActive,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Key,
	)
	return i, err
}

const getEntitlementSetByID = `-- name: GetEntitlementSetByID :one
SELECT set_id, name, description, is_active, created_at, updated_at, key FROM core.entitlement_sets
WHERE set_id = $1
`

func (q *Queries) GetEntitlementSetByID(ctx context.Context, setID string) (EntitlementSet, error) {
	row := q.db.QueryRowContext(ctx, getEntitlementSetByID, setID)
	var i EntitlementSet
	err := row.Scan(
		&i.SetID,
		&i.Name,
		&i.Description,
		&i.IsActive,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Key,
	)
	return i, err
}

const getEntitlementSetByKey = `-- name: GetEntitlementSetByKey :one
SELECT set_id, name, description, is_active, created_at, updated_at, key FROM core.entitlement_sets
WHERE key = $1
`

// Root key resolver (entity-keys §5). uq_entitlement_sets_key guarantees at
// most one row matches.
func (q *Queries) GetEntitlementSetByKey(ctx context.Context, key sql.NullString) (EntitlementSet, error) {
	row := q.db.QueryRowContext(ctx, getEntitlementSetByKey, key)
	var i EntitlementSet
	err := row.Scan(
		&i.SetID,
		&i.Name,
		&i.Description,
		&i.IsActive,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Key,
	)
	return i, err
}

const listActiveEntitlementSets = `-- name: ListActiveEntitlementSets :many
SELECT set_id, name, description, is_active, created_at, updated_at, key FROM core.entitlement_sets
WHERE is_active = TRUE
ORDER BY name ASC
`

func (q *Queries) ListActiveEntitlementSets(ctx context.Context) ([]EntitlementSet, error) {
	rows, err := q.db.QueryContext(ctx, listActiveEntitlementSets)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []EntitlementSet{}
	for rows.Next() {
		var i EntitlementSet
		if err := rows.Scan(
			&i.SetID,
			&i.Name,
			&i.Description,
			&i.IsActive,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.Key,
		); 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 listEntitlementSets = `-- name: ListEntitlementSets :many
SELECT set_id, name, description, is_active, created_at, updated_at, key FROM core.entitlement_sets
ORDER BY name ASC
`

func (q *Queries) ListEntitlementSets(ctx context.Context) ([]EntitlementSet, error) {
	rows, err := q.db.QueryContext(ctx, listEntitlementSets)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []EntitlementSet{}
	for rows.Next() {
		var i EntitlementSet
		if err := rows.Scan(
			&i.SetID,
			&i.Name,
			&i.Description,
			&i.IsActive,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.Key,
		); 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 listEntitlementSetsByIDs = `-- name: ListEntitlementSetsByIDs :many
SELECT set_id, name, description, is_active, created_at, updated_at, key FROM core.entitlement_sets
WHERE set_id = ANY($1::uuid[])
ORDER BY name ASC
`

// The products list's set names for one page in one read (purchasability-
// status "The verdict per page, from batches, never cached", design D4,
// folded in on the maintainer's word 2026-09-06): the sets the page's
// products reference, instead of GetEntitlementSetByID once per row.
func (q *Queries) ListEntitlementSetsByIDs(ctx context.Context, setIds []string) ([]EntitlementSet, error) {
	rows, err := q.db.QueryContext(ctx, listEntitlementSetsByIDs, pq.Array(setIds))
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []EntitlementSet{}
	for rows.Next() {
		var i EntitlementSet
		if err := rows.Scan(
			&i.SetID,
			&i.Name,
			&i.Description,
			&i.IsActive,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.Key,
		); 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 lockEntitlementSet = `-- name: LockEntitlementSet :one
SELECT set_id FROM core.entitlement_sets
WHERE set_id = $1
FOR UPDATE
`

// The set row taken FOR UPDATE: the guard a rule change holds beside the
// exclusive materialization rendezvous against a writer that changes the set
// row without that lock. A batch takes it once for every act it files
// (entitlement-set-management, "A rule change commit reaches every carrying
// pool").
func (q *Queries) LockEntitlementSet(ctx context.Context, setID string) (string, error) {
	row := q.db.QueryRowContext(ctx, lockEntitlementSet, setID)
	var set_id string
	err := row.Scan(&set_id)
	return set_id, err
}

const updateEntitlementSet = `-- name: UpdateEntitlementSet :one
UPDATE core.entitlement_sets
SET name = $2, description = $3, is_active = $4
WHERE set_id = $1
RETURNING set_id, name, description, is_active, created_at, updated_at, key
`

type UpdateEntitlementSetParams struct {
	SetID       string         `json:"set_id"`
	Name        string         `json:"name"`
	Description sql.NullString `json:"description"`
	IsActive    bool           `json:"is_active"`
}

func (q *Queries) UpdateEntitlementSet(ctx context.Context, arg UpdateEntitlementSetParams) (EntitlementSet, error) {
	row := q.db.QueryRowContext(ctx, updateEntitlementSet,
		arg.SetID,
		arg.Name,
		arg.Description,
		arg.IsActive,
	)
	var i EntitlementSet
	err := row.Scan(
		&i.SetID,
		&i.Name,
		&i.Description,
		&i.IsActive,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Key,
	)
	return i, err
}