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

package db

import (
	"context"

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

const createAlertRule = `-- name: CreateAlertRule :one
INSERT INTO alert_rules (check_id, name, threshold, operator, for_duration, severity)
VALUES ($1, $2, $3, $4, $5, $6)
RETURNING id, check_id, name, threshold, operator, for_duration, severity, created_at, updated_at
`

type CreateAlertRuleParams struct {
	CheckID     pgtype.UUID   `json:"check_id"`
	Name        string        `json:"name"`
	Threshold   float64       `json:"threshold"`
	Operator    string        `json:"operator"`
	ForDuration int64         `json:"for_duration"`
	Severity    AlertSeverity `json:"severity"`
}

func (q *Queries) CreateAlertRule(ctx context.Context, arg CreateAlertRuleParams) (AlertRule, error) {
	row := q.db.QueryRow(ctx, createAlertRule,
		arg.CheckID,
		arg.Name,
		arg.Threshold,
		arg.Operator,
		arg.ForDuration,
		arg.Severity,
	)
	var i AlertRule
	err := row.Scan(
		&i.ID,
		&i.CheckID,
		&i.Name,
		&i.Threshold,
		&i.Operator,
		&i.ForDuration,
		&i.Severity,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const createCheck = `-- name: CreateCheck :one
INSERT INTO checks (target_id, type, interval_seconds, timeout_seconds)
VALUES ($1, $2, $3, $4)
RETURNING id, target_id, type, interval_seconds, timeout_seconds, is_active, created_at, updated_at
`

type CreateCheckParams struct {
	TargetID        pgtype.UUID `json:"target_id"`
	Type            CheckType   `json:"type"`
	IntervalSeconds int32       `json:"interval_seconds"`
	TimeoutSeconds  int32       `json:"timeout_seconds"`
}

func (q *Queries) CreateCheck(ctx context.Context, arg CreateCheckParams) (Check, error) {
	row := q.db.QueryRow(ctx, createCheck,
		arg.TargetID,
		arg.Type,
		arg.IntervalSeconds,
		arg.TimeoutSeconds,
	)
	var i Check
	err := row.Scan(
		&i.ID,
		&i.TargetID,
		&i.Type,
		&i.IntervalSeconds,
		&i.TimeoutSeconds,
		&i.IsActive,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const createIncident = `-- name: CreateIncident :one
INSERT INTO incidents (alert_rule_id, status, start_time)
VALUES ($1, $2, $3)
RETURNING id, alert_rule_id, status, start_time, end_time, created_at, updated_at
`

type CreateIncidentParams struct {
	AlertRuleID pgtype.UUID        `json:"alert_rule_id"`
	Status      IncidentStatus     `json:"status"`
	StartTime   pgtype.Timestamptz `json:"start_time"`
}

func (q *Queries) CreateIncident(ctx context.Context, arg CreateIncidentParams) (Incident, error) {
	row := q.db.QueryRow(ctx, createIncident, arg.AlertRuleID, arg.Status, arg.StartTime)
	var i Incident
	err := row.Scan(
		&i.ID,
		&i.AlertRuleID,
		&i.Status,
		&i.StartTime,
		&i.EndTime,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const createMetric = `-- name: CreateMetric :one
INSERT INTO metrics (time, check_id, value, tags)
VALUES ($1, $2, $3, $4)
RETURNING time, check_id, value, tags
`

type CreateMetricParams struct {
	Time    pgtype.Timestamptz `json:"time"`
	CheckID pgtype.UUID        `json:"check_id"`
	Value   float64            `json:"value"`
	Tags    []byte             `json:"tags"`
}

func (q *Queries) CreateMetric(ctx context.Context, arg CreateMetricParams) (Metric, error) {
	row := q.db.QueryRow(ctx, createMetric,
		arg.Time,
		arg.CheckID,
		arg.Value,
		arg.Tags,
	)
	var i Metric
	err := row.Scan(
		&i.Time,
		&i.CheckID,
		&i.Value,
		&i.Tags,
	)
	return i, err
}

const createTarget = `-- name: CreateTarget :one
INSERT INTO targets (name, type, config)
VALUES ($1, $2, $3)
RETURNING id, name, type, config, created_at, updated_at
`

type CreateTargetParams struct {
	Name   string     `json:"name"`
	Type   TargetType `json:"type"`
	Config []byte     `json:"config"`
}

func (q *Queries) CreateTarget(ctx context.Context, arg CreateTargetParams) (Target, error) {
	row := q.db.QueryRow(ctx, createTarget, arg.Name, arg.Type, arg.Config)
	var i Target
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.Type,
		&i.Config,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const getCheck = `-- name: GetCheck :one
SELECT id, target_id, type, interval_seconds, timeout_seconds, is_active, created_at, updated_at FROM checks
WHERE id = $1
`

func (q *Queries) GetCheck(ctx context.Context, id pgtype.UUID) (Check, error) {
	row := q.db.QueryRow(ctx, getCheck, id)
	var i Check
	err := row.Scan(
		&i.ID,
		&i.TargetID,
		&i.Type,
		&i.IntervalSeconds,
		&i.TimeoutSeconds,
		&i.IsActive,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const getIncident = `-- name: GetIncident :one
SELECT id, alert_rule_id, status, start_time, end_time, created_at, updated_at FROM incidents
WHERE id = $1
`

func (q *Queries) GetIncident(ctx context.Context, id pgtype.UUID) (Incident, error) {
	row := q.db.QueryRow(ctx, getIncident, id)
	var i Incident
	err := row.Scan(
		&i.ID,
		&i.AlertRuleID,
		&i.Status,
		&i.StartTime,
		&i.EndTime,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const getMetricsForCheck = `-- name: GetMetricsForCheck :many
SELECT time, check_id, value, tags FROM metrics
WHERE check_id = $1 AND time >= $2 AND time <= $3
ORDER BY time DESC
`

type GetMetricsForCheckParams struct {
	CheckID pgtype.UUID        `json:"check_id"`
	Time    pgtype.Timestamptz `json:"time"`
	Time_2  pgtype.Timestamptz `json:"time_2"`
}

func (q *Queries) GetMetricsForCheck(ctx context.Context, arg GetMetricsForCheckParams) ([]Metric, error) {
	rows, err := q.db.Query(ctx, getMetricsForCheck, arg.CheckID, arg.Time, arg.Time_2)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Metric
	for rows.Next() {
		var i Metric
		if err := rows.Scan(
			&i.Time,
			&i.CheckID,
			&i.Value,
			&i.Tags,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getTarget = `-- name: GetTarget :one
SELECT id, name, type, config, created_at, updated_at FROM targets
WHERE id = $1
`

func (q *Queries) GetTarget(ctx context.Context, id pgtype.UUID) (Target, error) {
	row := q.db.QueryRow(ctx, getTarget, id)
	var i Target
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.Type,
		&i.Config,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const listAlertRules = `-- name: ListAlertRules :many
SELECT id, check_id, name, threshold, operator, for_duration, severity, created_at, updated_at FROM alert_rules
`

func (q *Queries) ListAlertRules(ctx context.Context) ([]AlertRule, error) {
	rows, err := q.db.Query(ctx, listAlertRules)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []AlertRule
	for rows.Next() {
		var i AlertRule
		if err := rows.Scan(
			&i.ID,
			&i.CheckID,
			&i.Name,
			&i.Threshold,
			&i.Operator,
			&i.ForDuration,
			&i.Severity,
			&i.CreatedAt,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listChecks = `-- name: ListChecks :many
SELECT id, target_id, type, interval_seconds, timeout_seconds, is_active, created_at, updated_at FROM checks
WHERE is_active = TRUE
`

func (q *Queries) ListChecks(ctx context.Context) ([]Check, error) {
	rows, err := q.db.Query(ctx, listChecks)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Check
	for rows.Next() {
		var i Check
		if err := rows.Scan(
			&i.ID,
			&i.TargetID,
			&i.Type,
			&i.IntervalSeconds,
			&i.TimeoutSeconds,
			&i.IsActive,
			&i.CreatedAt,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const updateIncidentStatus = `-- name: UpdateIncidentStatus :one
UPDATE incidents
SET status = $2, updated_at = NOW()
WHERE id = $1
RETURNING id, alert_rule_id, status, start_time, end_time, created_at, updated_at
`

type UpdateIncidentStatusParams struct {
	ID     pgtype.UUID    `json:"id"`
	Status IncidentStatus `json:"status"`
}

func (q *Queries) UpdateIncidentStatus(ctx context.Context, arg UpdateIncidentStatusParams) (Incident, error) {
	row := q.db.QueryRow(ctx, updateIncidentStatus, arg.ID, arg.Status)
	var i Incident
	err := row.Scan(
		&i.ID,
		&i.AlertRuleID,
		&i.Status,
		&i.StartTime,
		&i.EndTime,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}