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

package sqlc

import (
	"context"

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

const countMessagesBySession = `-- name: CountMessagesBySession :one
SELECT COUNT(*)::bigint AS message_count
FROM bot_history_messages
WHERE session_id = $1
`

func (q *Queries) CountMessagesBySession(ctx context.Context, sessionID pgtype.UUID) (int64, error) {
	row := q.db.QueryRow(ctx, countMessagesBySession, sessionID)
	var message_count int64
	err := row.Scan(&message_count)
	return message_count, err
}

const getLatestAssistantUsage = `-- name: GetLatestAssistantUsage :one
SELECT
  COALESCE((m.usage->>'inputTokens')::bigint, 0)::bigint AS input_tokens
FROM bot_history_messages m
WHERE m.session_id = $1
  AND m.role = 'assistant'
  AND m.usage IS NOT NULL
ORDER BY m.created_at DESC
LIMIT 1
`

func (q *Queries) GetLatestAssistantUsage(ctx context.Context, sessionID pgtype.UUID) (int64, error) {
	row := q.db.QueryRow(ctx, getLatestAssistantUsage, sessionID)
	var input_tokens int64
	err := row.Scan(&input_tokens)
	return input_tokens, err
}

const getLatestSessionIDByBot = `-- name: GetLatestSessionIDByBot :one
SELECT s.id
FROM bot_sessions s
WHERE s.bot_id = $1
  AND s.type = 'chat'
  AND s.deleted_at IS NULL
ORDER BY s.updated_at DESC
LIMIT 1
`

func (q *Queries) GetLatestSessionIDByBot(ctx context.Context, botID pgtype.UUID) (pgtype.UUID, error) {
	row := q.db.QueryRow(ctx, getLatestSessionIDByBot, botID)
	var id pgtype.UUID
	err := row.Scan(&id)
	return id, err
}

const getSessionCacheStats = `-- name: GetSessionCacheStats :one
SELECT
  COALESCE(SUM((m.usage->>'inputTokens')::bigint), 0)::bigint AS total_input_tokens,
  COALESCE(SUM((m.usage->'inputTokenDetails'->>'cacheReadTokens')::bigint), 0)::bigint AS cache_read_tokens,
  COALESCE(SUM((m.usage->'inputTokenDetails'->>'cacheWriteTokens')::bigint), 0)::bigint AS cache_write_tokens
FROM bot_history_messages m
WHERE m.session_id = $1
  AND m.usage IS NOT NULL
`

type GetSessionCacheStatsRow struct {
	TotalInputTokens int64 `json:"total_input_tokens"`
	CacheReadTokens  int64 `json:"cache_read_tokens"`
	CacheWriteTokens int64 `json:"cache_write_tokens"`
}

func (q *Queries) GetSessionCacheStats(ctx context.Context, sessionID pgtype.UUID) (GetSessionCacheStatsRow, error) {
	row := q.db.QueryRow(ctx, getSessionCacheStats, sessionID)
	var i GetSessionCacheStatsRow
	err := row.Scan(&i.TotalInputTokens, &i.CacheReadTokens, &i.CacheWriteTokens)
	return i, err
}

const getSessionUsedSkills = `-- name: GetSessionUsedSkills :many
SELECT DISTINCT
  (part->'input'->>'skillName')::text AS skill_name
FROM bot_history_messages m,
  jsonb_array_elements(
    CASE WHEN jsonb_typeof(m.content->'content') = 'array'
         THEN m.content->'content'
         ELSE '[]'::jsonb
    END
  ) AS part
WHERE m.session_id = $1
  AND m.role = 'assistant'
  AND part->>'type' = 'tool-call'
  AND part->>'toolName' = 'use_skill'
  AND part->'input'->>'skillName' IS NOT NULL
  AND part->'input'->>'skillName' != ''
ORDER BY skill_name
`

func (q *Queries) GetSessionUsedSkills(ctx context.Context, sessionID pgtype.UUID) ([]string, error) {
	rows, err := q.db.Query(ctx, getSessionUsedSkills, sessionID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []string
	for rows.Next() {
		var skill_name string
		if err := rows.Scan(&skill_name); err != nil {
			return nil, err
		}
		items = append(items, skill_name)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}