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

package dbgen

import (
	"context"

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

const CreateUserBonus = `-- name: CreateUserBonus :one
INSERT INTO user_bonuses (
        name,
        description,
        type,
        user_id,
        reward_amount,
        expires_at
    )
VALUES ($1, $2, $3, $4, $5, $6)
RETURNING id, name, description, type, user_id, reward_amount, is_claimed, expires_at, claimed_at, created_at, updated_at
`

type CreateUserBonusParams struct {
	Name         string           `json:"name"`
	Description  string           `json:"description"`
	Type         string           `json:"type"`
	UserID       int64            `json:"user_id"`
	RewardAmount int64            `json:"reward_amount"`
	ExpiresAt    pgtype.Timestamp `json:"expires_at"`
}

func (q *Queries) CreateUserBonus(ctx context.Context, arg CreateUserBonusParams) (UserBonuse, error) {
	row := q.db.QueryRow(ctx, CreateUserBonus,
		arg.Name,
		arg.Description,
		arg.Type,
		arg.UserID,
		arg.RewardAmount,
		arg.ExpiresAt,
	)
	var i UserBonuse
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.Description,
		&i.Type,
		&i.UserID,
		&i.RewardAmount,
		&i.IsClaimed,
		&i.ExpiresAt,
		&i.ClaimedAt,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const DeleteUserBonus = `-- name: DeleteUserBonus :exec
DELETE FROM user_bonuses
WHERE id = $1
`

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

const GetAllUserBonuses = `-- name: GetAllUserBonuses :many
SELECT id, name, description, type, user_id, reward_amount, is_claimed, expires_at, claimed_at, created_at, updated_at
FROM user_bonuses
WHERE (
        user_id = $1
        OR $1 IS NULL
    )
LIMIT $3 OFFSET $2
`

type GetAllUserBonusesParams struct {
	UserID pgtype.Int8 `json:"user_id"`
	Offset pgtype.Int4 `json:"offset"`
	Limit  pgtype.Int4 `json:"limit"`
}

func (q *Queries) GetAllUserBonuses(ctx context.Context, arg GetAllUserBonusesParams) ([]UserBonuse, error) {
	rows, err := q.db.Query(ctx, GetAllUserBonuses, arg.UserID, arg.Offset, arg.Limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []UserBonuse
	for rows.Next() {
		var i UserBonuse
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.Description,
			&i.Type,
			&i.UserID,
			&i.RewardAmount,
			&i.IsClaimed,
			&i.ExpiresAt,
			&i.ClaimedAt,
			&i.CreatedAt,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetBonusCount = `-- name: GetBonusCount :one
SELECT COUNT(*)
FROM user_bonuses
WHERE (
        user_id = $1
        OR $1 IS NULL
    )
`

func (q *Queries) GetBonusCount(ctx context.Context, userID pgtype.Int8) (int64, error) {
	row := q.db.QueryRow(ctx, GetBonusCount, userID)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const GetBonusStats = `-- name: GetBonusStats :one
SELECT COUNT(*) AS total_bonuses,
    COALESCE(SUM(reward_amount), 0)::bigint AS total_reward_earned,
    COUNT(
        CASE
            WHEN is_claimed = true THEN 1
        END
    ) AS claimed_bonuses,
    COUNT(
        CASE
            WHEN expires_at < now() THEN 1
        END
    ) AS expired_bonuses
FROM user_bonuses
    JOIN users ON users.id = user_bonuses.user_id
WHERE (
        company_id = $1
        OR $1 IS NULL
    )
    AND (
        user_id = $2
        OR $2 IS NULL
    )
`

type GetBonusStatsParams struct {
	CompanyID pgtype.Int8 `json:"company_id"`
	UserID    pgtype.Int8 `json:"user_id"`
}

type GetBonusStatsRow struct {
	TotalBonuses      int64 `json:"total_bonuses"`
	TotalRewardEarned int64 `json:"total_reward_earned"`
	ClaimedBonuses    int64 `json:"claimed_bonuses"`
	ExpiredBonuses    int64 `json:"expired_bonuses"`
}

func (q *Queries) GetBonusStats(ctx context.Context, arg GetBonusStatsParams) (GetBonusStatsRow, error) {
	row := q.db.QueryRow(ctx, GetBonusStats, arg.CompanyID, arg.UserID)
	var i GetBonusStatsRow
	err := row.Scan(
		&i.TotalBonuses,
		&i.TotalRewardEarned,
		&i.ClaimedBonuses,
		&i.ExpiredBonuses,
	)
	return i, err
}

const GetUserBonusByID = `-- name: GetUserBonusByID :one
SELECT id, name, description, type, user_id, reward_amount, is_claimed, expires_at, claimed_at, created_at, updated_at
FROM user_bonuses
WHERE id = $1
`

func (q *Queries) GetUserBonusByID(ctx context.Context, id int64) (UserBonuse, error) {
	row := q.db.QueryRow(ctx, GetUserBonusByID, id)
	var i UserBonuse
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.Description,
		&i.Type,
		&i.UserID,
		&i.RewardAmount,
		&i.IsClaimed,
		&i.ExpiresAt,
		&i.ClaimedAt,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const UpdateUserBonus = `-- name: UpdateUserBonus :exec
UPDATE user_bonuses
SET is_claimed = $2
WHERE id = $1
`

type UpdateUserBonusParams struct {
	ID        int64 `json:"id"`
	IsClaimed bool  `json:"is_claimed"`
}

func (q *Queries) UpdateUserBonus(ctx context.Context, arg UpdateUserBonusParams) error {
	_, err := q.db.Exec(ctx, UpdateUserBonus, arg.ID, arg.IsClaimed)
	return err
}