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

package db

import (
    "context"
)

const countSessions = `-- name: CountSessions :one
SELECT COUNT(*) FROM sessions
`

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

const createSession = `-- name: CreateSession :one
INSERT INTO sessions (title, model, mode) VALUES (?, ?, ?) RETURNING id, title, model, mode, created_at, updated_at
`

type CreateSessionParams struct {
    Title string `json:"title"`
    Model string `json:"model"`
    Mode  string `json:"mode"`
}

func (q *Queries) CreateSession(ctx context.Context, arg CreateSessionParams) (Session, error) {
    row := q.db.QueryRowContext(ctx, createSession, arg.Title, arg.Model, arg.Mode)
    var i Session
    err := row.Scan(
        &i.ID,
        &i.Title,
        &i.Model,
        &i.Mode,
        &i.CreatedAt,
        &i.UpdatedAt,
    )
    return i, err
}

const createSessionMessage = `-- name: CreateSessionMessage :one
INSERT INTO session_messages (session_id, role, content, tool_name, tool_args, is_error, thinking)
VALUES (?, ?, ?, ?, ?, ?, ?) RETURNING id, session_id, role, content, tool_name, tool_args, is_error, thinking, created_at
`

type CreateSessionMessageParams struct {
    SessionID int64  `json:"session_id"`
    Role      string `json:"role"`
    Content   string `json:"content"`
    ToolName  string `json:"tool_name"`
    ToolArgs  string `json:"tool_args"`
    IsError   int64  `json:"is_error"`
    Thinking  string `json:"thinking"`
}

func (q *Queries) CreateSessionMessage(ctx context.Context, arg CreateSessionMessageParams) (SessionMessage, error) {
    row := q.db.QueryRowContext(ctx, createSessionMessage,
        arg.SessionID,
        arg.Role,
        arg.Content,
        arg.ToolName,
        arg.ToolArgs,
        arg.IsError,
        arg.Thinking,
    )
    var i SessionMessage
    err := row.Scan(
        &i.ID,
        &i.SessionID,
        &i.Role,
        &i.Content,
        &i.ToolName,
        &i.ToolArgs,
        &i.IsError,
        &i.Thinking,
        &i.CreatedAt,
    )
    return i, err
}

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

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

const getSession = `-- name: GetSession :one
SELECT id, title, model, mode, created_at, updated_at FROM sessions WHERE id = ?
`

func (q *Queries) GetSession(ctx context.Context, id int64) (Session, error) {
    row := q.db.QueryRowContext(ctx, getSession, id)
    var i Session
    err := row.Scan(
        &i.ID,
        &i.Title,
        &i.Model,
        &i.Mode,
        &i.CreatedAt,
        &i.UpdatedAt,
    )
    return i, err
}

const getSessionMessages = `-- name: GetSessionMessages :many
SELECT id, session_id, role, content, tool_name, tool_args, is_error, thinking, created_at FROM session_messages WHERE session_id = ? ORDER BY id ASC
`

func (q *Queries) GetSessionMessages(ctx context.Context, sessionID int64) ([]SessionMessage, error) {
    rows, err := q.db.QueryContext(ctx, getSessionMessages, sessionID)
    if err != nil {
        return nil, err
    }
    defer rows.Close()
    items := []SessionMessage{}
    for rows.Next() {
        var i SessionMessage
        if err := rows.Scan(
            &i.ID,
            &i.SessionID,
            &i.Role,
            &i.Content,
            &i.ToolName,
            &i.ToolArgs,
            &i.IsError,
            &i.Thinking,
            &i.CreatedAt,
        ); 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 listSessions = `-- name: ListSessions :many
SELECT id, title, model, mode, created_at, updated_at FROM sessions ORDER BY updated_at DESC LIMIT ?
`

func (q *Queries) ListSessions(ctx context.Context, limit int64) ([]Session, error) {
    rows, err := q.db.QueryContext(ctx, listSessions, 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.Title,
            &i.Model,
            &i.Mode,
            &i.CreatedAt,
            &i.UpdatedAt,
        ); 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 updateSessionTimestamp = `-- name: UpdateSessionTimestamp :exec
UPDATE sessions SET updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now') WHERE id = ?
`

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

const updateSessionTitle = `-- name: UpdateSessionTitle :exec
UPDATE sessions SET title = ?, updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now') WHERE id = ?
`

type UpdateSessionTitleParams struct {
    Title string `json:"title"`
    ID    int64  `json:"id"`
}

func (q *Queries) UpdateSessionTitle(ctx context.Context, arg UpdateSessionTitleParams) error {
    _, err := q.db.ExecContext(ctx, updateSessionTitle, arg.Title, arg.ID)
    return err
}