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

package sqlc

import (
	"context"
	"database/sql"
	"time"
)

const DeleteExitedSessionsBefore = `-- name: DeleteExitedSessionsBefore :execrows
DELETE FROM sessions
WHERE type = 'browser'
  AND ended_at IS NOT NULL
  AND ended_at < ?
`

// Deletes exited browser sessions older than the given cutoff time.
func (q *Queries) DeleteExitedSessionsBefore(ctx context.Context, endedAt sql.NullTime) (int64, error) {
	result, err := q.db.ExecContext(ctx, DeleteExitedSessionsBefore, endedAt)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected()
}

const DeleteOldestExitedSessions = `-- name: DeleteOldestExitedSessions :execrows
DELETE FROM sessions
WHERE id IN (
    SELECT id FROM sessions
    WHERE type = 'browser' AND ended_at IS NOT NULL
    ORDER BY ended_at DESC
    LIMIT -1 OFFSET ?
)
`

// Deletes exited browser sessions beyond the keep limit, keeping the most recent ones.
func (q *Queries) DeleteOldestExitedSessions(ctx context.Context, offset int64) (int64, error) {
	result, err := q.db.ExecContext(ctx, DeleteOldestExitedSessions, offset)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected()
}

const DeleteSession = `-- name: DeleteSession :exec
DELETE FROM sessions WHERE id = ?
`

func (q *Queries) DeleteSession(ctx context.Context, id string) error {
	_, err := q.db.ExecContext(ctx, DeleteSession, id)
	return err
}

const GetActiveBrowserSession = `-- name: GetActiveBrowserSession :one
SELECT id, type, started_at, ended_at, process_id FROM sessions
WHERE type = 'browser' AND ended_at IS NULL
ORDER BY started_at DESC
LIMIT 1
`

func (q *Queries) GetActiveBrowserSession(ctx context.Context) (Session, error) {
	row := q.db.QueryRowContext(ctx, GetActiveBrowserSession)
	var i Session
	err := row.Scan(
		&i.ID,
		&i.Type,
		&i.StartedAt,
		&i.EndedAt,
		&i.ProcessID,
	)
	return i, err
}

const GetRecentSessions = `-- name: GetRecentSessions :many
SELECT id, type, started_at, ended_at, process_id FROM sessions
ORDER BY started_at DESC
LIMIT ?
`

func (q *Queries) GetRecentSessions(ctx context.Context, limit int64) ([]Session, error) {
	rows, err := q.db.QueryContext(ctx, GetRecentSessions, limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []Session{}
	for rows.Next() {
		var i Session
		if err := rows.Scan(
			&i.ID,
			&i.Type,
			&i.StartedAt,
			&i.EndedAt,
			&i.ProcessID,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetSessionByID = `-- name: GetSessionByID :one
SELECT id, type, started_at, ended_at, process_id FROM sessions WHERE id = ? LIMIT 1
`

func (q *Queries) GetSessionByID(ctx context.Context, id string) (Session, error) {
	row := q.db.QueryRowContext(ctx, GetSessionByID, id)
	var i Session
	err := row.Scan(
		&i.ID,
		&i.Type,
		&i.StartedAt,
		&i.EndedAt,
		&i.ProcessID,
	)
	return i, err
}

const InsertSession = `-- name: InsertSession :exec
INSERT INTO sessions (id, type, started_at, ended_at, process_id)
VALUES (?, ?, ?, ?, ?)
`

type InsertSessionParams struct {
	ID        string        `json:"id"`
	Type      string        `json:"type"`
	StartedAt time.Time     `json:"started_at"`
	EndedAt   sql.NullTime  `json:"ended_at"`
	ProcessID sql.NullInt64 `json:"process_id"`
}

func (q *Queries) InsertSession(ctx context.Context, arg InsertSessionParams) error {
	_, err := q.db.ExecContext(ctx, InsertSession,
		arg.ID,
		arg.Type,
		arg.StartedAt,
		arg.EndedAt,
		arg.ProcessID,
	)
	return err
}

const MarkSessionEnded = `-- name: MarkSessionEnded :exec
UPDATE sessions
SET ended_at = ?
WHERE id = ?
`

type MarkSessionEndedParams struct {
	EndedAt sql.NullTime `json:"ended_at"`
	ID      string       `json:"id"`
}

func (q *Queries) MarkSessionEnded(ctx context.Context, arg MarkSessionEndedParams) error {
	_, err := q.db.ExecContext(ctx, MarkSessionEnded, arg.EndedAt, arg.ID)
	return err
}