// 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"
	"github.com/jackc/pgx/v5/pgtype"
)

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, $8, $9
)
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      pgtype.Text `json:"ip_address"`
	UserAgent      *string     `json:"user_agent"`
	AccessTokenID  *uuid.UUID  `json:"access_token_id"`
	RefreshTokenID *uuid.UUID  `json:"refresh_token_id"`
}

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,
	)
	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
  AND is_active = TRUE
`

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 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
`

func (q *Queries) ListActiveServiceSessionsByClient(ctx context.Context, clientID string) ([]ServiceSession, error) {
	rows, err := q.db.Query(ctx, listActiveServiceSessionsByClient, clientID)
	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
`

func (q *Queries) ListActiveServiceSessionsByUser(ctx context.Context, userID *uuid.UUID) ([]ServiceSession, error) {
	rows, err := q.db.Query(ctx, listActiveServiceSessionsByUser, userID)
	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
}