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

package sqlc

import (
	"context"

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

const createUserProfile = `-- name: CreateUserProfile :one
INSERT INTO user_profiles (
    user_id,
    display_name,
    avatar_url
) VALUES (
    $1, $2, $3
)
RETURNING user_id, display_name, full_name, avatar_url, bio, location, website, country_code, phone, created_at, updated_at
`

type CreateUserProfileParams struct {
	UserID      pgtype.UUID `json:"user_id"`
	DisplayName pgtype.Text `json:"display_name"`
	AvatarUrl   pgtype.Text `json:"avatar_url"`
}

func (q *Queries) CreateUserProfile(ctx context.Context, arg CreateUserProfileParams) (UserProfile, error) {
	row := q.db.QueryRow(ctx, createUserProfile, arg.UserID, arg.DisplayName, arg.AvatarUrl)
	var i UserProfile
	err := row.Scan(
		&i.UserID,
		&i.DisplayName,
		&i.FullName,
		&i.AvatarUrl,
		&i.Bio,
		&i.Location,
		&i.Website,
		&i.CountryCode,
		&i.Phone,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const deleteUser = `-- name: DeleteUser :exec
UPDATE users
SET
    is_deleted = true
WHERE id = $1
`

func (q *Queries) DeleteUser(ctx context.Context, id pgtype.UUID) error {
	_, err := q.db.Exec(ctx, deleteUser, id)
	return err
}

const getTokenVersion = `-- name: GetTokenVersion :one
SELECT token_version
FROM users
WHERE id = $1 AND is_deleted = false
`

func (q *Queries) GetTokenVersion(ctx context.Context, id pgtype.UUID) (int32, error) {
	row := q.db.QueryRow(ctx, getTokenVersion, id)
	var token_version int32
	err := row.Scan(&token_version)
	return token_version, err
}

const getUserByEmail = `-- name: GetUserByEmail :one
SELECT
    u.id,
    u.email,
    u.password_hash,
    u.is_verified,
    u.token_version,
    u.is_deleted,
    u.created_at,
    u.updated_at,

    (
        SELECT json_build_object(
            'display_name', p.display_name,
            'full_name', p.full_name,
            'avatar_url', p.avatar_url,
            'bio', p.bio,
            'location', p.location,
            'website', p.website,
            'country_code', p.country_code,
            'phone', p.phone
        )
        FROM user_profiles p
        WHERE p.user_id = u.id
    ) AS profile,

    (
        SELECT COALESCE(
            json_agg(json_build_object('id', r.id, 'name', r.name)),
            '[]'
        )::json
        FROM user_roles ur
        JOIN roles r ON ur.role_id = r.id
        WHERE ur.user_id = u.id
    ) AS roles

FROM users u
WHERE u.email = $1 AND u.is_deleted = false
`

type GetUserByEmailRow struct {
	ID           pgtype.UUID        `json:"id"`
	Email        string             `json:"email"`
	PasswordHash pgtype.Text        `json:"password_hash"`
	IsVerified   bool               `json:"is_verified"`
	TokenVersion int32              `json:"token_version"`
	IsDeleted    bool               `json:"is_deleted"`
	CreatedAt    pgtype.Timestamptz `json:"created_at"`
	UpdatedAt    pgtype.Timestamptz `json:"updated_at"`
	Profile      []byte             `json:"profile"`
	Roles        []byte             `json:"roles"`
}

func (q *Queries) GetUserByEmail(ctx context.Context, email string) (GetUserByEmailRow, error) {
	row := q.db.QueryRow(ctx, getUserByEmail, email)
	var i GetUserByEmailRow
	err := row.Scan(
		&i.ID,
		&i.Email,
		&i.PasswordHash,
		&i.IsVerified,
		&i.TokenVersion,
		&i.IsDeleted,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Profile,
		&i.Roles,
	)
	return i, err
}

const getUserByID = `-- name: GetUserByID :one
SELECT
    u.id,
    u.email,
    u.password_hash,
    u.is_verified,
    u.token_version,
    u.refresh_token,
    u.is_deleted,
    u.created_at,
    u.updated_at,

    -- profile JSON
    (
        SELECT json_build_object(
            'display_name', p.display_name,
            'full_name', p.full_name,
            'avatar_url', p.avatar_url,
            'bio', p.bio,
            'location', p.location,
            'website', p.website,
            'country_code', p.country_code,
            'phone', p.phone
        )
        FROM user_profiles p
        WHERE p.user_id = u.id
    ) AS profile,

    -- roles JSON
    (
        SELECT COALESCE(
            json_agg(json_build_object('id', r.id, 'name', r.name)),
            '[]'
        )::json
        FROM user_roles ur
        JOIN roles r ON ur.role_id = r.id
        WHERE ur.user_id = u.id
    ) AS roles

FROM users u
WHERE u.id = $1 AND u.is_deleted = false
`

type GetUserByIDRow struct {
	ID           pgtype.UUID        `json:"id"`
	Email        string             `json:"email"`
	PasswordHash pgtype.Text        `json:"password_hash"`
	IsVerified   bool               `json:"is_verified"`
	TokenVersion int32              `json:"token_version"`
	RefreshToken pgtype.Text        `json:"refresh_token"`
	IsDeleted    bool               `json:"is_deleted"`
	CreatedAt    pgtype.Timestamptz `json:"created_at"`
	UpdatedAt    pgtype.Timestamptz `json:"updated_at"`
	Profile      []byte             `json:"profile"`
	Roles        []byte             `json:"roles"`
}

func (q *Queries) GetUserByID(ctx context.Context, id pgtype.UUID) (GetUserByIDRow, error) {
	row := q.db.QueryRow(ctx, getUserByID, id)
	var i GetUserByIDRow
	err := row.Scan(
		&i.ID,
		&i.Email,
		&i.PasswordHash,
		&i.IsVerified,
		&i.TokenVersion,
		&i.RefreshToken,
		&i.IsDeleted,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Profile,
		&i.Roles,
	)
	return i, err
}

const getUsers = `-- name: GetUsers :many
SELECT
    u.id,
    u.email,
    u.password_hash,
    u.is_verified,
    u.token_version,
    u.refresh_token,
    u.is_deleted,
    u.created_at,
    u.updated_at,

    (
        SELECT json_build_object(
            'display_name', p.display_name,
            'full_name', p.full_name,
            'avatar_url', p.avatar_url,
            'bio', p.bio,
            'location', p.location,
            'website', p.website,
            'country_code', p.country_code,
            'phone', p.phone
        )
        FROM user_profiles p
        WHERE p.user_id = u.id
    ) AS profile,

    (
        SELECT COALESCE(
            json_agg(json_build_object('id', r.id, 'name', r.name)),
            '[]'
        )::json
        FROM user_roles ur
        JOIN roles r ON ur.role_id = r.id
        WHERE ur.user_id = u.id
    ) AS roles

FROM users u
WHERE u.is_deleted = false
`

type GetUsersRow struct {
	ID           pgtype.UUID        `json:"id"`
	Email        string             `json:"email"`
	PasswordHash pgtype.Text        `json:"password_hash"`
	IsVerified   bool               `json:"is_verified"`
	TokenVersion int32              `json:"token_version"`
	RefreshToken pgtype.Text        `json:"refresh_token"`
	IsDeleted    bool               `json:"is_deleted"`
	CreatedAt    pgtype.Timestamptz `json:"created_at"`
	UpdatedAt    pgtype.Timestamptz `json:"updated_at"`
	Profile      []byte             `json:"profile"`
	Roles        []byte             `json:"roles"`
}

func (q *Queries) GetUsers(ctx context.Context) ([]GetUsersRow, error) {
	rows, err := q.db.Query(ctx, getUsers)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []GetUsersRow{}
	for rows.Next() {
		var i GetUsersRow
		if err := rows.Scan(
			&i.ID,
			&i.Email,
			&i.PasswordHash,
			&i.IsVerified,
			&i.TokenVersion,
			&i.RefreshToken,
			&i.IsDeleted,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.Profile,
			&i.Roles,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const restoreUser = `-- name: RestoreUser :exec
UPDATE users
SET
    is_deleted = false
WHERE id = $1
`

func (q *Queries) RestoreUser(ctx context.Context, id pgtype.UUID) error {
	_, err := q.db.Exec(ctx, restoreUser, id)
	return err
}

const updateTokenVersion = `-- name: UpdateTokenVersion :exec
UPDATE users
SET token_version = $2
WHERE id = $1 AND is_deleted = false
`

type UpdateTokenVersionParams struct {
	ID           pgtype.UUID `json:"id"`
	TokenVersion int32       `json:"token_version"`
}

func (q *Queries) UpdateTokenVersion(ctx context.Context, arg UpdateTokenVersionParams) error {
	_, err := q.db.Exec(ctx, updateTokenVersion, arg.ID, arg.TokenVersion)
	return err
}

const updateUserPassword = `-- name: UpdateUserPassword :exec
UPDATE users
SET
    password_hash = $2
WHERE id = $1
  AND is_deleted = false
`

type UpdateUserPasswordParams struct {
	ID           pgtype.UUID `json:"id"`
	PasswordHash pgtype.Text `json:"password_hash"`
}

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

const updateUserProfile = `-- name: UpdateUserProfile :one
UPDATE user_profiles
SET
    display_name = $1,
    full_name = $2,
    avatar_url = $3,
    bio = $4,
    location = $5,
    website = $6,
    country_code = $7,
    phone = $8,
    updated_at = now()
WHERE user_id = $9
RETURNING user_id, display_name, full_name, avatar_url, bio, location, website, country_code, phone, created_at, updated_at
`

type UpdateUserProfileParams struct {
	DisplayName pgtype.Text `json:"display_name"`
	FullName    pgtype.Text `json:"full_name"`
	AvatarUrl   pgtype.Text `json:"avatar_url"`
	Bio         pgtype.Text `json:"bio"`
	Location    pgtype.Text `json:"location"`
	Website     pgtype.Text `json:"website"`
	CountryCode pgtype.Text `json:"country_code"`
	Phone       pgtype.Text `json:"phone"`
	UserID      pgtype.UUID `json:"user_id"`
}

func (q *Queries) UpdateUserProfile(ctx context.Context, arg UpdateUserProfileParams) (UserProfile, error) {
	row := q.db.QueryRow(ctx, updateUserProfile,
		arg.DisplayName,
		arg.FullName,
		arg.AvatarUrl,
		arg.Bio,
		arg.Location,
		arg.Website,
		arg.CountryCode,
		arg.Phone,
		arg.UserID,
	)
	var i UserProfile
	err := row.Scan(
		&i.UserID,
		&i.DisplayName,
		&i.FullName,
		&i.AvatarUrl,
		&i.Bio,
		&i.Location,
		&i.Website,
		&i.CountryCode,
		&i.Phone,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const updateUserRefreshToken = `-- name: UpdateUserRefreshToken :exec
UPDATE users
SET
    refresh_token = $2
WHERE id = $1
  AND is_deleted = false
`

type UpdateUserRefreshTokenParams struct {
	ID           pgtype.UUID `json:"id"`
	RefreshToken pgtype.Text `json:"refresh_token"`
}

func (q *Queries) UpdateUserRefreshToken(ctx context.Context, arg UpdateUserRefreshTokenParams) error {
	_, err := q.db.Exec(ctx, updateUserRefreshToken, arg.ID, arg.RefreshToken)
	return err
}

const upsertUser = `-- name: UpsertUser :one
INSERT INTO users (
    email,
    password_hash,
    google_id,
    auth_provider,
    is_verified
) VALUES (
    $1, $2, $3, $4, $5
)
ON CONFLICT (email) 
DO UPDATE SET
    google_id = EXCLUDED.google_id,
    auth_provider = EXCLUDED.auth_provider,
    is_verified = users.is_verified OR EXCLUDED.is_verified,
    updated_at = now()
RETURNING id, email, password_hash, google_id, auth_provider, is_verified, is_deleted, token_version, refresh_token, created_at, updated_at
`

type UpsertUserParams struct {
	Email        string      `json:"email"`
	PasswordHash pgtype.Text `json:"password_hash"`
	GoogleID     pgtype.Text `json:"google_id"`
	AuthProvider string      `json:"auth_provider"`
	IsVerified   bool        `json:"is_verified"`
}

func (q *Queries) UpsertUser(ctx context.Context, arg UpsertUserParams) (User, error) {
	row := q.db.QueryRow(ctx, upsertUser,
		arg.Email,
		arg.PasswordHash,
		arg.GoogleID,
		arg.AuthProvider,
		arg.IsVerified,
	)
	var i User
	err := row.Scan(
		&i.ID,
		&i.Email,
		&i.PasswordHash,
		&i.GoogleID,
		&i.AuthProvider,
		&i.IsVerified,
		&i.IsDeleted,
		&i.TokenVersion,
		&i.RefreshToken,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const verifyUser = `-- name: VerifyUser :exec
UPDATE users
SET
    is_verified = true
WHERE id = $1
  AND is_deleted = false
`

func (q *Queries) VerifyUser(ctx context.Context, id pgtype.UUID) error {
	_, err := q.db.Exec(ctx, verifyUser, id)
	return err
}