// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.27.0
// source: summary.sql

package database

import (
	"context"
)

const countAPITokens = `-- name: CountAPITokens :one
SELECT count(*) FROM api_tokens
`

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

const countActiveFlows = `-- name: CountActiveFlows :one
SELECT count(*) FROM flows WHERE deleted_at IS NULL AND status IN ('created', 'running', 'waiting')
`

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

const countAssistants = `-- name: CountAssistants :one
SELECT count(*) FROM assistants WHERE deleted_at IS NULL
`

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

const countContainers = `-- name: CountContainers :one
SELECT count(*) FROM containers
`

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

const countFlowTemplates = `-- name: CountFlowTemplates :one
SELECT count(*) FROM flow_templates
`

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

const countFlows = `-- name: CountFlows :one
SELECT count(*) FROM flows WHERE deleted_at IS NULL
`

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

const countPrompts = `-- name: CountPrompts :one
SELECT count(*) FROM prompts
`

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

const countSubtasks = `-- name: CountSubtasks :one
SELECT count(*) FROM subtasks
`

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

const countTasks = `-- name: CountTasks :one
SELECT count(*) FROM tasks
`

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

const countToolcalls = `-- name: CountToolcalls :one
SELECT count(*) FROM toolcalls
`

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

const countUsers = `-- name: CountUsers :one
SELECT count(*) FROM users
`

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

const getSummaryProviderCounts = `-- name: GetSummaryProviderCounts :many
SELECT type, count(*) AS total
FROM providers
WHERE deleted_at IS NULL
GROUP BY type
ORDER BY type
`

type GetSummaryProviderCountsRow struct {
	Type  ProviderType `json:"type"`
	Total int64        `json:"total"`
}

// Number of configured providers per type, for the instance summary.
func (q *Queries) GetSummaryProviderCounts(ctx context.Context) ([]GetSummaryProviderCountsRow, error) {
	rows, err := q.db.QueryContext(ctx, getSummaryProviderCounts)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetSummaryProviderCountsRow
	for rows.Next() {
		var i GetSummaryProviderCountsRow
		if err := rows.Scan(&i.Type, &i.Total); 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 getSummaryUsageByProvider = `-- name: GetSummaryUsageByProvider :many
SELECT
  model_provider,
  count(DISTINCT flow_id) AS flows,
  count(*) AS chains,
  COALESCE(SUM(usage_in), 0)::bigint AS tokens_in,
  COALESCE(SUM(usage_out), 0)::bigint AS tokens_out,
  COALESCE(SUM(usage_cache_in), 0)::bigint AS cache_in,
  COALESCE(SUM(usage_cache_out), 0)::bigint AS cache_out,
  COALESCE(SUM(usage_cost_in), 0.0)::double precision AS cost_in,
  COALESCE(SUM(usage_cost_out), 0.0)::double precision AS cost_out
FROM msgchains
GROUP BY model_provider
ORDER BY model_provider
`

type GetSummaryUsageByProviderRow struct {
	ModelProvider string  `json:"model_provider"`
	Flows         int64   `json:"flows"`
	Chains        int64   `json:"chains"`
	TokensIn      int64   `json:"tokens_in"`
	TokensOut     int64   `json:"tokens_out"`
	CacheIn       int64   `json:"cache_in"`
	CacheOut      int64   `json:"cache_out"`
	CostIn        float64 `json:"cost_in"`
	CostOut       float64 `json:"cost_out"`
}

// Aggregate LLM usage per provider type, over the whole life of the instance,
// for the instance summary.
func (q *Queries) GetSummaryUsageByProvider(ctx context.Context) ([]GetSummaryUsageByProviderRow, error) {
	rows, err := q.db.QueryContext(ctx, getSummaryUsageByProvider)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetSummaryUsageByProviderRow
	for rows.Next() {
		var i GetSummaryUsageByProviderRow
		if err := rows.Scan(
			&i.ModelProvider,
			&i.Flows,
			&i.Chains,
			&i.TokensIn,
			&i.TokensOut,
			&i.CacheIn,
			&i.CacheOut,
			&i.CostIn,
			&i.CostOut,
		); 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
}