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

package sqlc

import (
	"context"

	"anchorage/internal/pkg/ids"
)

const drainNode = `-- name: DrainNode :exec
UPDATE nodes SET status = 'drained' WHERE id = $1
`

func (q *Queries) DrainNode(ctx context.Context, id ids.NodeID) error {
	_, err := q.db.Exec(ctx, drainNode, id)
	return err
}

const getNode = `-- name: GetNode :one
SELECT id, display_name, multiaddrs, rpc_url, status, last_seen_at, joined_at, updated_at FROM nodes WHERE id = $1
`

func (q *Queries) GetNode(ctx context.Context, id ids.NodeID) (Node, error) {
	row := q.db.QueryRow(ctx, getNode, id)
	var i Node
	err := row.Scan(
		&i.ID,
		&i.DisplayName,
		&i.Multiaddrs,
		&i.RpcUrl,
		&i.Status,
		&i.LastSeenAt,
		&i.JoinedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const listAllNodes = `-- name: ListAllNodes :many
SELECT id, display_name, multiaddrs, rpc_url, status, last_seen_at, joined_at, updated_at FROM nodes ORDER BY id
`

func (q *Queries) ListAllNodes(ctx context.Context) ([]Node, error) {
	rows, err := q.db.Query(ctx, listAllNodes)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Node
	for rows.Next() {
		var i Node
		if err := rows.Scan(
			&i.ID,
			&i.DisplayName,
			&i.Multiaddrs,
			&i.RpcUrl,
			&i.Status,
			&i.LastSeenAt,
			&i.JoinedAt,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listLiveNodes = `-- name: ListLiveNodes :many
SELECT id, display_name, multiaddrs, rpc_url, status, last_seen_at, joined_at, updated_at FROM nodes WHERE status = 'up' ORDER BY id
`

func (q *Queries) ListLiveNodes(ctx context.Context) ([]Node, error) {
	rows, err := q.db.Query(ctx, listLiveNodes)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Node
	for rows.Next() {
		var i Node
		if err := rows.Scan(
			&i.ID,
			&i.DisplayName,
			&i.Multiaddrs,
			&i.RpcUrl,
			&i.Status,
			&i.LastSeenAt,
			&i.JoinedAt,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const markNodeDown = `-- name: MarkNodeDown :exec
UPDATE nodes SET status = 'down' WHERE id = $1 AND status = 'up'
`

func (q *Queries) MarkNodeDown(ctx context.Context, id ids.NodeID) error {
	_, err := q.db.Exec(ctx, markNodeDown, id)
	return err
}

const markStaleNodesDown = `-- name: MarkStaleNodesDown :many
UPDATE nodes
SET status = 'down'
WHERE status = 'up' AND last_seen_at < (now() - make_interval(secs => $1))
RETURNING id
`

func (q *Queries) MarkStaleNodesDown(ctx context.Context, secs float64) ([]ids.NodeID, error) {
	rows, err := q.db.Query(ctx, markStaleNodesDown, secs)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []ids.NodeID
	for rows.Next() {
		var id ids.NodeID
		if err := rows.Scan(&id); err != nil {
			return nil, err
		}
		items = append(items, id)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const touchNodeHeartbeat = `-- name: TouchNodeHeartbeat :exec
UPDATE nodes SET last_seen_at = now() WHERE id = $1
`

func (q *Queries) TouchNodeHeartbeat(ctx context.Context, id ids.NodeID) error {
	_, err := q.db.Exec(ctx, touchNodeHeartbeat, id)
	return err
}

const uncordonNode = `-- name: UncordonNode :exec
UPDATE nodes SET status = 'up' WHERE id = $1 AND status = 'drained'
`

func (q *Queries) UncordonNode(ctx context.Context, id ids.NodeID) error {
	_, err := q.db.Exec(ctx, uncordonNode, id)
	return err
}

const upsertNode = `-- name: UpsertNode :one
INSERT INTO nodes (id, display_name, multiaddrs, rpc_url, status)
VALUES ($1, $2, $3, $4, 'up')
ON CONFLICT (id) DO UPDATE
    SET display_name = EXCLUDED.display_name,
        multiaddrs   = EXCLUDED.multiaddrs,
        rpc_url      = EXCLUDED.rpc_url,
        status       = CASE WHEN nodes.status = 'drained' THEN 'drained' ELSE 'up' END,
        last_seen_at = now()
RETURNING id, display_name, multiaddrs, rpc_url, status, last_seen_at, joined_at, updated_at
`

type UpsertNodeParams struct {
	ID          ids.NodeID
	DisplayName string
	Multiaddrs  []string
	RpcUrl      string
}

func (q *Queries) UpsertNode(ctx context.Context, arg UpsertNodeParams) (Node, error) {
	row := q.db.QueryRow(ctx, upsertNode,
		arg.ID,
		arg.DisplayName,
		arg.Multiaddrs,
		arg.RpcUrl,
	)
	var i Node
	err := row.Scan(
		&i.ID,
		&i.DisplayName,
		&i.Multiaddrs,
		&i.RpcUrl,
		&i.Status,
		&i.LastSeenAt,
		&i.JoinedAt,
		&i.UpdatedAt,
	)
	return i, err
}