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

package usersdb

import (
	"context"

	"github.com/jackc/pgx/v5/pgtype"
)

const bumpUserSessionEpoch = `-- name: BumpUserSessionEpoch :exec
UPDATE users SET session_epoch = session_epoch + 1 WHERE id = $1
`

func (q *Queries) BumpUserSessionEpoch(ctx context.Context, db DBTX, id int64) error {
	_, err := db.Exec(ctx, bumpUserSessionEpoch, id)
	return err
}

const countRecentUsernameChanges = `-- name: CountRecentUsernameChanges :one
SELECT count(*) FROM username_redirects
WHERE user_id = $1 AND changed_at > $2
`

type CountRecentUsernameChangesParams struct {
	UserID    int64
	ChangedAt pgtype.Timestamptz
}

// Drives the 3-changes-per-60d cap.
func (q *Queries) CountRecentUsernameChanges(ctx context.Context, db DBTX, arg CountRecentUsernameChangesParams) (int64, error) {
	row := db.QueryRow(ctx, countRecentUsernameChanges, arg.UserID, arg.ChangedAt)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const countUsers = `-- name: CountUsers :one
SELECT count(*) FROM users WHERE deleted_at IS NULL
`

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

const createUser = `-- name: CreateUser :one

INSERT INTO users (username, display_name, password_hash)
VALUES ($1, $2, $3)
RETURNING id, username, display_name, primary_email_id, password_hash, password_algo, password_updated_at, email_verified, last_login_at, suspended_at, suspended_reason, deleted_at, created_at, updated_at, bio, location, website, company, pronouns, avatar_object_key, theme, session_epoch, is_site_admin, include_private_contributions, plan
`

type CreateUserParams struct {
	Username     string
	DisplayName  string
	PasswordHash string
}

// SPDX-License-Identifier: AGPL-3.0-or-later
func (q *Queries) CreateUser(ctx context.Context, db DBTX, arg CreateUserParams) (User, error) {
	row := db.QueryRow(ctx, createUser, arg.Username, arg.DisplayName, arg.PasswordHash)
	var i User
	err := row.Scan(
		&i.ID,
		&i.Username,
		&i.DisplayName,
		&i.PrimaryEmailID,
		&i.PasswordHash,
		&i.PasswordAlgo,
		&i.PasswordUpdatedAt,
		&i.EmailVerified,
		&i.LastLoginAt,
		&i.SuspendedAt,
		&i.SuspendedReason,
		&i.DeletedAt,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Bio,
		&i.Location,
		&i.Website,
		&i.Company,
		&i.Pronouns,
		&i.AvatarObjectKey,
		&i.Theme,
		&i.SessionEpoch,
		&i.IsSiteAdmin,
		&i.IncludePrivateContributions,
		&i.Plan,
	)
	return i, err
}

const getUserByID = `-- name: GetUserByID :one
SELECT id, username, display_name, primary_email_id, password_hash, password_algo, password_updated_at, email_verified, last_login_at, suspended_at, suspended_reason, deleted_at, created_at, updated_at, bio, location, website, company, pronouns, avatar_object_key, theme, session_epoch, is_site_admin, include_private_contributions, plan
FROM users
WHERE id = $1 AND deleted_at IS NULL
`

func (q *Queries) GetUserByID(ctx context.Context, db DBTX, id int64) (User, error) {
	row := db.QueryRow(ctx, getUserByID, id)
	var i User
	err := row.Scan(
		&i.ID,
		&i.Username,
		&i.DisplayName,
		&i.PrimaryEmailID,
		&i.PasswordHash,
		&i.PasswordAlgo,
		&i.PasswordUpdatedAt,
		&i.EmailVerified,
		&i.LastLoginAt,
		&i.SuspendedAt,
		&i.SuspendedReason,
		&i.DeletedAt,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Bio,
		&i.Location,
		&i.Website,
		&i.Company,
		&i.Pronouns,
		&i.AvatarObjectKey,
		&i.Theme,
		&i.SessionEpoch,
		&i.IsSiteAdmin,
		&i.IncludePrivateContributions,
		&i.Plan,
	)
	return i, err
}

const getUserByUsername = `-- name: GetUserByUsername :one
SELECT id, username, display_name, primary_email_id, password_hash, password_algo, password_updated_at, email_verified, last_login_at, suspended_at, suspended_reason, deleted_at, created_at, updated_at, bio, location, website, company, pronouns, avatar_object_key, theme, session_epoch, is_site_admin, include_private_contributions, plan
FROM users
WHERE username = $1 AND deleted_at IS NULL
`

func (q *Queries) GetUserByUsername(ctx context.Context, db DBTX, username string) (User, error) {
	row := db.QueryRow(ctx, getUserByUsername, username)
	var i User
	err := row.Scan(
		&i.ID,
		&i.Username,
		&i.DisplayName,
		&i.PrimaryEmailID,
		&i.PasswordHash,
		&i.PasswordAlgo,
		&i.PasswordUpdatedAt,
		&i.EmailVerified,
		&i.LastLoginAt,
		&i.SuspendedAt,
		&i.SuspendedReason,
		&i.DeletedAt,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Bio,
		&i.Location,
		&i.Website,
		&i.Company,
		&i.Pronouns,
		&i.AvatarObjectKey,
		&i.Theme,
		&i.SessionEpoch,
		&i.IsSiteAdmin,
		&i.IncludePrivateContributions,
		&i.Plan,
	)
	return i, err
}

const getUserByUsernameIncludingDeleted = `-- name: GetUserByUsernameIncludingDeleted :one
SELECT id, username, display_name, primary_email_id, password_hash, password_algo, password_updated_at, email_verified, last_login_at, suspended_at, suspended_reason, deleted_at, created_at, updated_at, bio, location, website, company, pronouns, avatar_object_key, theme, session_epoch, is_site_admin, include_private_contributions, plan FROM users WHERE username = $1
`

func (q *Queries) GetUserByUsernameIncludingDeleted(ctx context.Context, db DBTX, username string) (User, error) {
	row := db.QueryRow(ctx, getUserByUsernameIncludingDeleted, username)
	var i User
	err := row.Scan(
		&i.ID,
		&i.Username,
		&i.DisplayName,
		&i.PrimaryEmailID,
		&i.PasswordHash,
		&i.PasswordAlgo,
		&i.PasswordUpdatedAt,
		&i.EmailVerified,
		&i.LastLoginAt,
		&i.SuspendedAt,
		&i.SuspendedReason,
		&i.DeletedAt,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Bio,
		&i.Location,
		&i.Website,
		&i.Company,
		&i.Pronouns,
		&i.AvatarObjectKey,
		&i.Theme,
		&i.SessionEpoch,
		&i.IsSiteAdmin,
		&i.IncludePrivateContributions,
		&i.Plan,
	)
	return i, err
}

const getUserIncludingDeleted = `-- name: GetUserIncludingDeleted :one
SELECT id, username, display_name, primary_email_id, password_hash, password_algo, password_updated_at, email_verified, last_login_at, suspended_at, suspended_reason, deleted_at, created_at, updated_at, bio, location, website, company, pronouns, avatar_object_key, theme, session_epoch, is_site_admin, include_private_contributions, plan FROM users WHERE id = $1
`

// Like GetUserByID but returns the row even when deleted_at IS NOT NULL.
func (q *Queries) GetUserIncludingDeleted(ctx context.Context, db DBTX, id int64) (User, error) {
	row := db.QueryRow(ctx, getUserIncludingDeleted, id)
	var i User
	err := row.Scan(
		&i.ID,
		&i.Username,
		&i.DisplayName,
		&i.PrimaryEmailID,
		&i.PasswordHash,
		&i.PasswordAlgo,
		&i.PasswordUpdatedAt,
		&i.EmailVerified,
		&i.LastLoginAt,
		&i.SuspendedAt,
		&i.SuspendedReason,
		&i.DeletedAt,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Bio,
		&i.Location,
		&i.Website,
		&i.Company,
		&i.Pronouns,
		&i.AvatarObjectKey,
		&i.Theme,
		&i.SessionEpoch,
		&i.IsSiteAdmin,
		&i.IncludePrivateContributions,
		&i.Plan,
	)
	return i, err
}

const getUserSessionEpoch = `-- name: GetUserSessionEpoch :one
SELECT session_epoch FROM users WHERE id = $1
`

func (q *Queries) GetUserSessionEpoch(ctx context.Context, db DBTX, id int64) (int32, error) {
	row := db.QueryRow(ctx, getUserSessionEpoch, id)
	var session_epoch int32
	err := row.Scan(&session_epoch)
	return session_epoch, err
}

const linkUserPrimaryEmail = `-- name: LinkUserPrimaryEmail :exec
UPDATE users
SET primary_email_id = $2
WHERE id = $1
`

type LinkUserPrimaryEmailParams struct {
	ID             int64
	PrimaryEmailID pgtype.Int8
}

// Sets the FK only. Does NOT flip users.email_verified — that happens via
// MarkUserEmailPrimaryVerified after the user clicks the verification link.
func (q *Queries) LinkUserPrimaryEmail(ctx context.Context, db DBTX, arg LinkUserPrimaryEmailParams) error {
	_, err := db.Exec(ctx, linkUserPrimaryEmail, arg.ID, arg.PrimaryEmailID)
	return err
}

const markUserEmailPrimaryVerified = `-- name: MarkUserEmailPrimaryVerified :exec
UPDATE users
SET email_verified = true
WHERE id = $1
`

// Called after MarkUserEmailVerified for the primary email, to flip the
// denormalized users.email_verified flag.
func (q *Queries) MarkUserEmailPrimaryVerified(ctx context.Context, db DBTX, id int64) error {
	_, err := db.Exec(ctx, markUserEmailPrimaryVerified, id)
	return err
}

const renameUser = `-- name: RenameUser :exec
UPDATE users
SET username = $2
WHERE id = $1
`

type RenameUserParams struct {
	ID       int64
	Username string
}

// Wrapped by the username-change flow inside a tx that also writes
// username_redirects, so the old name becomes a redirect target atomically.
func (q *Queries) RenameUser(ctx context.Context, db DBTX, arg RenameUserParams) error {
	_, err := db.Exec(ctx, renameUser, arg.ID, arg.Username)
	return err
}

const restoreUserAccount = `-- name: RestoreUserAccount :exec
UPDATE users SET deleted_at = NULL WHERE id = $1
`

// Clears deleted_at; called when a user logs in within the 14-day grace
// window. The login handler enforces the window check before calling.
func (q *Queries) RestoreUserAccount(ctx context.Context, db DBTX, id int64) error {
	_, err := db.Exec(ctx, restoreUserAccount, id)
	return err
}

const softDeleteUser = `-- name: SoftDeleteUser :exec
UPDATE users
SET deleted_at = now()
WHERE id = $1
`

func (q *Queries) SoftDeleteUser(ctx context.Context, db DBTX, id int64) error {
	_, err := db.Exec(ctx, softDeleteUser, id)
	return err
}

const suspendUser = `-- name: SuspendUser :exec
UPDATE users
SET suspended_at     = now(),
    suspended_reason = $2
WHERE id = $1
`

type SuspendUserParams struct {
	ID              int64
	SuspendedReason pgtype.Text
}

func (q *Queries) SuspendUser(ctx context.Context, db DBTX, arg SuspendUserParams) error {
	_, err := db.Exec(ctx, suspendUser, arg.ID, arg.SuspendedReason)
	return err
}

const touchUserLastLogin = `-- name: TouchUserLastLogin :exec
UPDATE users
SET last_login_at = now()
WHERE id = $1
`

func (q *Queries) TouchUserLastLogin(ctx context.Context, db DBTX, id int64) error {
	_, err := db.Exec(ctx, touchUserLastLogin, id)
	return err
}

const unsuspendUser = `-- name: UnsuspendUser :exec
UPDATE users
SET suspended_at     = NULL,
    suspended_reason = NULL
WHERE id = $1
`

// Clears the suspended state. Mirrors SuspendUser; used by the
// /admin/users/{id}/unsuspend handler. Replaces an inline UPDATE
// in admin/users.go (SR2 M2).
func (q *Queries) UnsuspendUser(ctx context.Context, db DBTX, id int64) error {
	_, err := db.Exec(ctx, unsuspendUser, id)
	return err
}

const updateUserAvatarKey = `-- name: UpdateUserAvatarKey :exec
UPDATE users
SET avatar_object_key = $2
WHERE id = $1
`

type UpdateUserAvatarKeyParams struct {
	ID              int64
	AvatarObjectKey pgtype.Text
}

func (q *Queries) UpdateUserAvatarKey(ctx context.Context, db DBTX, arg UpdateUserAvatarKeyParams) error {
	_, err := db.Exec(ctx, updateUserAvatarKey, arg.ID, arg.AvatarObjectKey)
	return err
}

const updateUserPassword = `-- name: UpdateUserPassword :exec
UPDATE users
SET password_hash       = $2,
    password_algo       = $3,
    password_updated_at = now()
WHERE id = $1
`

type UpdateUserPasswordParams struct {
	ID           int64
	PasswordHash string
	PasswordAlgo string
}

func (q *Queries) UpdateUserPassword(ctx context.Context, db DBTX, arg UpdateUserPasswordParams) error {
	_, err := db.Exec(ctx, updateUserPassword, arg.ID, arg.PasswordHash, arg.PasswordAlgo)
	return err
}

const updateUserPrivateContributions = `-- name: UpdateUserPrivateContributions :exec
UPDATE users SET include_private_contributions = $2 WHERE id = $1
`

type UpdateUserPrivateContributionsParams struct {
	ID                          int64
	IncludePrivateContributions bool
}

func (q *Queries) UpdateUserPrivateContributions(ctx context.Context, db DBTX, arg UpdateUserPrivateContributionsParams) error {
	_, err := db.Exec(ctx, updateUserPrivateContributions, arg.ID, arg.IncludePrivateContributions)
	return err
}

const updateUserProfile = `-- name: UpdateUserProfile :exec
UPDATE users
SET display_name = $2,
    bio          = $3,
    location     = $4,
    website      = $5,
    company      = $6,
    pronouns     = $7
WHERE id = $1
`

type UpdateUserProfileParams struct {
	ID          int64
	DisplayName string
	Bio         string
	Location    string
	Website     string
	Company     string
	Pronouns    string
}

func (q *Queries) UpdateUserProfile(ctx context.Context, db DBTX, arg UpdateUserProfileParams) error {
	_, err := db.Exec(ctx, updateUserProfile,
		arg.ID,
		arg.DisplayName,
		arg.Bio,
		arg.Location,
		arg.Website,
		arg.Company,
		arg.Pronouns,
	)
	return err
}

const updateUserTheme = `-- name: UpdateUserTheme :exec
UPDATE users SET theme = $2 WHERE id = $1
`

type UpdateUserThemeParams struct {
	ID    int64
	Theme string
}

func (q *Queries) UpdateUserTheme(ctx context.Context, db DBTX, arg UpdateUserThemeParams) error {
	_, err := db.Exec(ctx, updateUserTheme, arg.ID, arg.Theme)
	return err
}