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

package repository

import (
	"context"
	"time"

	"github.com/google/uuid"
)

const createServiceSession = `-- name: CreateServiceSession :one
INSERT INTO service_sessions (
    service_id, client_id, user_id, issued_at, expires_at, last_active,
    ip_address, user_agent, access_token_id, refresh_token_id,
    is_active, scope, claims
) VALUES (
    $1, $2, $3, NOW(), $4, $5,
    $6, $7, $8, $9,
    TRUE, $10, $11
)
RETURNING id, service_id, client_id, user_id, issued_at, expires_at, last_active, ip_address, user_agent, access_token_id, refresh_token_id, is_active, revoked_at, scope, claims
`

type CreateServiceSessionParams struct {
	ServiceID      uuid.UUID  `json:"service_id"`
	ClientID       string     `json:"client_id"`
	UserID         *uuid.UUID `json:"user_id"`
	ExpiresAt      *time.Time `json:"expires_at"`
	LastActive     *time.Time `json:"last_active"`
	IpAddress      *string    `json:"ip_address"`
	UserAgent      *string    `json:"user_agent"`
	AccessTokenID  *uuid.UUID `json:"access_token_id"`
	RefreshTokenID *uuid.UUID `json:"refresh_token_id"`
	Scope          *string    `json:"scope"`
	Claims         []byte     `json:"claims"`
}

func (q *Queries) CreateServiceSession(ctx context.Context, arg CreateServiceSessionParams) (ServiceSession, error) {
	row := q.db.QueryRow(ctx, createServiceSession,
		arg.ServiceID,
		arg.ClientID,
		arg.UserID,
		arg.ExpiresAt,
		arg.LastActive,
		arg.IpAddress,
		arg.UserAgent,
		arg.AccessTokenID,
		arg.RefreshTokenID,
		arg.Scope,
		arg.Claims,
	)
	var i ServiceSession
	err := row.Scan(
		&i.ID,
		&i.ServiceID,
		&i.ClientID,
		&i.UserID,
		&i.IssuedAt,
		&i.ExpiresAt,
		&i.LastActive,
		&i.IpAddress,
		&i.UserAgent,
		&i.AccessTokenID,
		&i.RefreshTokenID,
		&i.IsActive,
		&i.RevokedAt,
		&i.Scope,
		&i.Claims,
	)
	return i, err
}

const getServiceSessionByAccessJTI = `-- name: GetServiceSessionByAccessJTI :one
SELECT id, service_id, client_id, user_id, issued_at, expires_at, last_active, ip_address, user_agent, access_token_id, refresh_token_id, is_active, revoked_at, scope, claims FROM service_sessions
WHERE access_token_id = $1
  AND is_active = TRUE
`

func (q *Queries) GetServiceSessionByAccessJTI(ctx context.Context, accessTokenID *uuid.UUID) (ServiceSession, error) {
	row := q.db.QueryRow(ctx, getServiceSessionByAccessJTI, accessTokenID)
	var i ServiceSession
	err := row.Scan(
		&i.ID,
		&i.ServiceID,
		&i.ClientID,
		&i.UserID,
		&i.IssuedAt,
		&i.ExpiresAt,
		&i.LastActive,
		&i.IpAddress,
		&i.UserAgent,
		&i.AccessTokenID,
		&i.RefreshTokenID,
		&i.IsActive,
		&i.RevokedAt,
		&i.Scope,
		&i.Claims,
	)
	return i, err
}

const getServiceSessionByRefreshJTI = `-- name: GetServiceSessionByRefreshJTI :one
SELECT id, service_id, client_id, user_id, issued_at, expires_at, last_active, ip_address, user_agent, access_token_id, refresh_token_id, is_active, revoked_at, scope, claims FROM service_sessions
WHERE refresh_token_id = $1
`

func (q *Queries) GetServiceSessionByRefreshJTI(ctx context.Context, refreshTokenID *uuid.UUID) (ServiceSession, error) {
	row := q.db.QueryRow(ctx, getServiceSessionByRefreshJTI, refreshTokenID)
	var i ServiceSession
	err := row.Scan(
		&i.ID,
		&i.ServiceID,
		&i.ClientID,
		&i.UserID,
		&i.IssuedAt,
		&i.ExpiresAt,
		&i.LastActive,
		&i.IpAddress,
		&i.UserAgent,
		&i.AccessTokenID,
		&i.RefreshTokenID,
		&i.IsActive,
		&i.RevokedAt,
		&i.Scope,
		&i.Claims,
	)
	return i, err
}

const getServiceSessions = `-- name: GetServiceSessions :many
SELECT session.id, session.service_id, session.client_id, session.user_id, session.issued_at, session.expires_at, session.last_active, session.ip_address, session.user_agent, session.access_token_id, session.refresh_token_id, session.is_active, session.revoked_at, session.scope, session.claims, service.id, service.client_id, service.client_secret, service.name, service.redirect_uris, service.scopes, service.grant_types, service.created_at, service.updated_at, service.is_active, service.description, service.icon_url, u.id, u.email, u.full_name, u.password_hash, u.is_admin, u.created_at, u.updated_at, u.last_login, u.phone_number, u.profile_picture, u.created_by, u.email_verified, u.avatar_verified, u.verified
FROM service_sessions AS session
JOIN api_services AS service ON service.id = session.service_id
JOIN users AS u ON u.id = session.user_id
ORDER BY session.issued_at DESC
LIMIT $1 OFFSET $2
`

type GetServiceSessionsParams struct {
	Limit  int32 `json:"limit"`
	Offset int32 `json:"offset"`
}

type GetServiceSessionsRow struct {
	ServiceSession ServiceSession `json:"service_session"`
	ApiService     ApiService     `json:"api_service"`
	User           User           `json:"user"`
}

func (q *Queries) GetServiceSessions(ctx context.Context, arg GetServiceSessionsParams) ([]GetServiceSessionsRow, error) {
	rows, err := q.db.Query(ctx, getServiceSessions, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetServiceSessionsRow
	for rows.Next() {
		var i GetServiceSessionsRow
		if err := rows.Scan(
			&i.ServiceSession.ID,
			&i.ServiceSession.ServiceID,
			&i.ServiceSession.ClientID,
			&i.ServiceSession.UserID,
			&i.ServiceSession.IssuedAt,
			&i.ServiceSession.ExpiresAt,
			&i.ServiceSession.LastActive,
			&i.ServiceSession.IpAddress,
			&i.ServiceSession.UserAgent,
			&i.ServiceSession.AccessTokenID,
			&i.ServiceSession.RefreshTokenID,
			&i.ServiceSession.IsActive,
			&i.ServiceSession.RevokedAt,
			&i.ServiceSession.Scope,
			&i.ServiceSession.Claims,
			&i.ApiService.ID,
			&i.ApiService.ClientID,
			&i.ApiService.ClientSecret,
			&i.ApiService.Name,
			&i.ApiService.RedirectUris,
			&i.ApiService.Scopes,
			&i.ApiService.GrantTypes,
			&i.ApiService.CreatedAt,
			&i.ApiService.UpdatedAt,
			&i.ApiService.IsActive,
			&i.ApiService.Description,
			&i.ApiService.IconUrl,
			&i.User.ID,
			&i.User.Email,
			&i.User.FullName,
			&i.User.PasswordHash,
			&i.User.IsAdmin,
			&i.User.CreatedAt,
			&i.User.UpdatedAt,
			&i.User.LastLogin,
			&i.User.PhoneNumber,
			&i.User.ProfilePicture,
			&i.User.CreatedBy,
			&i.User.EmailVerified,
			&i.User.AvatarVerified,
			&i.User.Verified,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getServiceSessionsCount = `-- name: GetServiceSessionsCount :one
SELECT COUNT(*) FROM service_sessions
`

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

const listActiveServiceSessionsByClient = `-- name: ListActiveServiceSessionsByClient :many
SELECT id, service_id, client_id, user_id, issued_at, expires_at, last_active, ip_address, user_agent, access_token_id, refresh_token_id, is_active, revoked_at, scope, claims FROM service_sessions
WHERE client_id = $1
  AND is_active = TRUE
ORDER BY issued_at DESC
LIMIT $1 OFFSET $2
`

type ListActiveServiceSessionsByClientParams struct {
	Limit  int32 `json:"limit"`
	Offset int32 `json:"offset"`
}

func (q *Queries) ListActiveServiceSessionsByClient(ctx context.Context, arg ListActiveServiceSessionsByClientParams) ([]ServiceSession, error) {
	rows, err := q.db.Query(ctx, listActiveServiceSessionsByClient, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []ServiceSession
	for rows.Next() {
		var i ServiceSession
		if err := rows.Scan(
			&i.ID,
			&i.ServiceID,
			&i.ClientID,
			&i.UserID,
			&i.IssuedAt,
			&i.ExpiresAt,
			&i.LastActive,
			&i.IpAddress,
			&i.UserAgent,
			&i.AccessTokenID,
			&i.RefreshTokenID,
			&i.IsActive,
			&i.RevokedAt,
			&i.Scope,
			&i.Claims,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listActiveServiceSessionsByUser = `-- name: ListActiveServiceSessionsByUser :many
SELECT id, service_id, client_id, user_id, issued_at, expires_at, last_active, ip_address, user_agent, access_token_id, refresh_token_id, is_active, revoked_at, scope, claims FROM service_sessions
WHERE user_id = $1
  AND is_active = TRUE
ORDER BY issued_at DESC
LIMIT $1 OFFSET $2
`

type ListActiveServiceSessionsByUserParams struct {
	Limit  int32 `json:"limit"`
	Offset int32 `json:"offset"`
}

func (q *Queries) ListActiveServiceSessionsByUser(ctx context.Context, arg ListActiveServiceSessionsByUserParams) ([]ServiceSession, error) {
	rows, err := q.db.Query(ctx, listActiveServiceSessionsByUser, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []ServiceSession
	for rows.Next() {
		var i ServiceSession
		if err := rows.Scan(
			&i.ID,
			&i.ServiceID,
			&i.ClientID,
			&i.UserID,
			&i.IssuedAt,
			&i.ExpiresAt,
			&i.LastActive,
			&i.IpAddress,
			&i.UserAgent,
			&i.AccessTokenID,
			&i.RefreshTokenID,
			&i.IsActive,
			&i.RevokedAt,
			&i.Scope,
			&i.Claims,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listAllServiceSessions = `-- name: ListAllServiceSessions :many
SELECT id, service_id, client_id, user_id, issued_at, expires_at, last_active, ip_address, user_agent, access_token_id, refresh_token_id, is_active, revoked_at, scope, claims FROM service_sessions
ORDER BY issued_at DESC
LIMIT $1 OFFSET $2
`

type ListAllServiceSessionsParams struct {
	Limit  int32 `json:"limit"`
	Offset int32 `json:"offset"`
}

func (q *Queries) ListAllServiceSessions(ctx context.Context, arg ListAllServiceSessionsParams) ([]ServiceSession, error) {
	rows, err := q.db.Query(ctx, listAllServiceSessions, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []ServiceSession
	for rows.Next() {
		var i ServiceSession
		if err := rows.Scan(
			&i.ID,
			&i.ServiceID,
			&i.ClientID,
			&i.UserID,
			&i.IssuedAt,
			&i.ExpiresAt,
			&i.LastActive,
			&i.IpAddress,
			&i.UserAgent,
			&i.AccessTokenID,
			&i.RefreshTokenID,
			&i.IsActive,
			&i.RevokedAt,
			&i.Scope,
			&i.Claims,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const revokeServiceSession = `-- name: RevokeServiceSession :exec
UPDATE service_sessions
SET is_active = FALSE,
    revoked_at = NOW()
WHERE id = $1
  AND is_active = TRUE
`

func (q *Queries) RevokeServiceSession(ctx context.Context, id uuid.UUID) error {
	_, err := q.db.Exec(ctx, revokeServiceSession, id)
	return err
}

const updateServiceSessionLastActive = `-- name: UpdateServiceSessionLastActive :exec
UPDATE service_sessions
SET last_active = NOW()
WHERE id = $1
  AND is_active = TRUE
`

func (q *Queries) UpdateServiceSessionLastActive(ctx context.Context, id uuid.UUID) error {
	_, err := q.db.Exec(ctx, updateServiceSessionLastActive, id)
	return err
}

const updateServiceSessionTokens = `-- name: UpdateServiceSessionTokens :exec
UPDATE service_sessions
SET access_token_id = $2, refresh_token_id = $3, expires_at = $4
WHERE id = $1
  AND is_active = TRUE
`

type UpdateServiceSessionTokensParams struct {
	ID             uuid.UUID  `json:"id"`
	AccessTokenID  *uuid.UUID `json:"access_token_id"`
	RefreshTokenID *uuid.UUID `json:"refresh_token_id"`
	ExpiresAt      *time.Time `json:"expires_at"`
}

func (q *Queries) UpdateServiceSessionTokens(ctx context.Context, arg UpdateServiceSessionTokensParams) error {
	_, err := q.db.Exec(ctx, updateServiceSessionTokens,
		arg.ID,
		arg.AccessTokenID,
		arg.RefreshTokenID,
		arg.ExpiresAt,
	)
	return err
}