// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.27.0
// source: batch.go

package database

import (
	"context"
	"errors"

	"dynatron.me/x/stillbox/internal/jsontypes"
	"dynatron.me/x/stillbox/pkg/alerting/rules"
	"github.com/jackc/pgx/v5"
)

var (
	ErrBatchAlreadyClosed = errors.New("batch already closed")
)

const upsertTalkgroup = `-- name: UpsertTalkgroup :batchone
INSERT INTO talkgroups AS tg (
	system_id, tgid, name, alpha_tag, tg_group, frequency, metadata, tags, alert, alert_config, weight, learned
) VALUES (
	$1,
	$2,
	$3,
	$4,
	$5,
	$6,
	$7,
	$8,
	$9,
	$10,
	$11,
	$12
)
ON CONFLICT (system_id, tgid) DO UPDATE
SET
	name = COALESCE($3, tg.name),
	alpha_tag = COALESCE($4, tg.alpha_tag),
	tg_group = COALESCE($5, tg.tg_group),
	frequency = COALESCE($6, tg.frequency),
	metadata = COALESCE($7, tg.metadata),
	tags = COALESCE($8, tg.tags),
	alert = COALESCE($9, tg.alert),
	alert_config = COALESCE($10, tg.alert_config),
	weight = COALESCE($11, tg.weight),
	learned = COALESCE($12, tg.learned)
RETURNING id, system_id, tgid, name, alpha_tag, tg_group, frequency, metadata, tags, alert, alert_config, weight, learned
`

type UpsertTalkgroupBatchResults struct {
	br     pgx.BatchResults
	tot    int
	closed bool
}

type UpsertTalkgroupParams struct {
	SystemID    int32              `json:"system_id"`
	TGID        int32              `json:"tgid"`
	Name        *string            `json:"name"`
	AlphaTag    *string            `json:"alpha_tag"`
	TGGroup     *string            `json:"tg_group"`
	Frequency   *int32             `json:"frequency"`
	Metadata    jsontypes.Metadata `json:"metadata"`
	Tags        []string           `json:"tags"`
	Alert       *bool              `json:"alert"`
	AlertConfig rules.AlertRules   `json:"alert_config"`
	Weight      *float32           `json:"weight"`
	Learned     *bool              `json:"learned"`
}

func (q *Queries) UpsertTalkgroup(ctx context.Context, arg []UpsertTalkgroupParams) *UpsertTalkgroupBatchResults {
	batch := &pgx.Batch{}
	for _, a := range arg {
		vals := []interface{}{
			a.SystemID,
			a.TGID,
			a.Name,
			a.AlphaTag,
			a.TGGroup,
			a.Frequency,
			a.Metadata,
			a.Tags,
			a.Alert,
			a.AlertConfig,
			a.Weight,
			a.Learned,
		}
		batch.Queue(upsertTalkgroup, vals...)
	}
	br := q.db.SendBatch(ctx, batch)
	return &UpsertTalkgroupBatchResults{br, len(arg), false}
}

func (b *UpsertTalkgroupBatchResults) QueryRow(f func(int, Talkgroup, error)) {
	defer b.br.Close()
	for t := 0; t < b.tot; t++ {
		var i Talkgroup
		if b.closed {
			if f != nil {
				f(t, i, ErrBatchAlreadyClosed)
			}
			continue
		}
		row := b.br.QueryRow()
		err := row.Scan(
			&i.ID,
			&i.SystemID,
			&i.TGID,
			&i.Name,
			&i.AlphaTag,
			&i.TGGroup,
			&i.Frequency,
			&i.Metadata,
			&i.Tags,
			&i.Alert,
			&i.AlertConfig,
			&i.Weight,
			&i.Learned,
		)
		if f != nil {
			f(t, i, err)
		}
	}
}

func (b *UpsertTalkgroupBatchResults) Close() error {
	b.closed = true
	return b.br.Close()
}