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

package db

import (
	"context"

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

const addHostTag = `-- name: AddHostTag :exec
INSERT INTO host_tags (host_id, tag) VALUES ($1, $2) ON CONFLICT DO NOTHING
`

type AddHostTagParams struct {
	HostID pgtype.UUID `json:"host_id"`
	Tag    string      `json:"tag"`
}

func (q *Queries) AddHostTag(ctx context.Context, arg AddHostTagParams) error {
	_, err := q.db.Exec(ctx, addHostTag, arg.HostID, arg.Tag)
	return err
}

const deleteHost = `-- name: DeleteHost :exec
DELETE FROM hosts WHERE id = $1
`

func (q *Queries) DeleteHost(ctx context.Context, id pgtype.UUID) error {
	_, err := q.db.Exec(ctx, deleteHost, id)
	return err
}

const getHost = `-- name: GetHost :one
SELECT id, type, team_id, provider, availability_zone, arch, cpu_cores, memory_mb, disk_gb, address, status, last_heartbeat_at, metadata, created_by, created_at, updated_at, cert_fingerprint, cert_expires_at FROM hosts WHERE id = $1
`

func (q *Queries) GetHost(ctx context.Context, id pgtype.UUID) (Host, error) {
	row := q.db.QueryRow(ctx, getHost, id)
	var i Host
	err := row.Scan(
		&i.ID,
		&i.Type,
		&i.TeamID,
		&i.Provider,
		&i.AvailabilityZone,
		&i.Arch,
		&i.CpuCores,
		&i.MemoryMb,
		&i.DiskGb,
		&i.Address,
		&i.Status,
		&i.LastHeartbeatAt,
		&i.Metadata,
		&i.CreatedBy,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.CertFingerprint,
		&i.CertExpiresAt,
	)
	return i, err
}

const getHostByTeam = `-- name: GetHostByTeam :one
SELECT id, type, team_id, provider, availability_zone, arch, cpu_cores, memory_mb, disk_gb, address, status, last_heartbeat_at, metadata, created_by, created_at, updated_at, cert_fingerprint, cert_expires_at FROM hosts WHERE id = $1 AND team_id = $2
`

type GetHostByTeamParams struct {
	ID     pgtype.UUID `json:"id"`
	TeamID pgtype.UUID `json:"team_id"`
}

func (q *Queries) GetHostByTeam(ctx context.Context, arg GetHostByTeamParams) (Host, error) {
	row := q.db.QueryRow(ctx, getHostByTeam, arg.ID, arg.TeamID)
	var i Host
	err := row.Scan(
		&i.ID,
		&i.Type,
		&i.TeamID,
		&i.Provider,
		&i.AvailabilityZone,
		&i.Arch,
		&i.CpuCores,
		&i.MemoryMb,
		&i.DiskGb,
		&i.Address,
		&i.Status,
		&i.LastHeartbeatAt,
		&i.Metadata,
		&i.CreatedBy,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.CertFingerprint,
		&i.CertExpiresAt,
	)
	return i, err
}

const getHostTags = `-- name: GetHostTags :many
SELECT tag FROM host_tags WHERE host_id = $1 ORDER BY tag
`

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

const getHostTokensByHost = `-- name: GetHostTokensByHost :many
SELECT id, host_id, created_by, created_at, expires_at, used_at FROM host_tokens WHERE host_id = $1 ORDER BY created_at DESC
`

func (q *Queries) GetHostTokensByHost(ctx context.Context, hostID pgtype.UUID) ([]HostToken, error) {
	rows, err := q.db.Query(ctx, getHostTokensByHost, hostID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []HostToken
	for rows.Next() {
		var i HostToken
		if err := rows.Scan(
			&i.ID,
			&i.HostID,
			&i.CreatedBy,
			&i.CreatedAt,
			&i.ExpiresAt,
			&i.UsedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getHostsWithLoad = `-- name: GetHostsWithLoad :many
SELECT
    h.id,
    h.type,
    h.team_id,
    h.provider,
    h.availability_zone,
    h.arch,
    h.cpu_cores,
    h.memory_mb,
    h.disk_gb,
    h.address,
    h.status,
    h.last_heartbeat_at,
    h.metadata,
    h.created_by,
    h.created_at,
    h.updated_at,
    h.cert_fingerprint,
    h.cert_expires_at,
    COALESCE(SUM(s.vcpus)       FILTER (WHERE s.status IN ('running', 'starting', 'pending')), 0)::int AS running_vcpus,
    COALESCE(SUM(s.memory_mb)   FILTER (WHERE s.status IN ('running', 'starting', 'pending')), 0)::int AS running_memory_mb,
    COALESCE(SUM(s.disk_size_mb) FILTER (WHERE s.status IN ('running', 'starting', 'pending')), 0)::int AS running_disk_mb,
    COALESCE(SUM(s.memory_mb)   FILTER (WHERE s.status = 'paused'), 0)::int AS paused_memory_mb,
    COALESCE(SUM(s.disk_size_mb) FILTER (WHERE s.status = 'paused'), 0)::int AS paused_disk_mb
FROM hosts h
LEFT JOIN sandboxes s ON s.host_id = h.id
    AND s.status IN ('running', 'paused', 'starting', 'pending')
WHERE h.status = 'online'
  AND h.address != ''
GROUP BY h.id
ORDER BY h.created_at
`

type GetHostsWithLoadRow struct {
	ID               pgtype.UUID        `json:"id"`
	Type             string             `json:"type"`
	TeamID           pgtype.UUID        `json:"team_id"`
	Provider         string             `json:"provider"`
	AvailabilityZone string             `json:"availability_zone"`
	Arch             string             `json:"arch"`
	CpuCores         int32              `json:"cpu_cores"`
	MemoryMb         int32              `json:"memory_mb"`
	DiskGb           int32              `json:"disk_gb"`
	Address          string             `json:"address"`
	Status           string             `json:"status"`
	LastHeartbeatAt  pgtype.Timestamptz `json:"last_heartbeat_at"`
	Metadata         []byte             `json:"metadata"`
	CreatedBy        pgtype.UUID        `json:"created_by"`
	CreatedAt        pgtype.Timestamptz `json:"created_at"`
	UpdatedAt        pgtype.Timestamptz `json:"updated_at"`
	CertFingerprint  string             `json:"cert_fingerprint"`
	CertExpiresAt    pgtype.Timestamptz `json:"cert_expires_at"`
	RunningVcpus     int32              `json:"running_vcpus"`
	RunningMemoryMb  int32              `json:"running_memory_mb"`
	RunningDiskMb    int32              `json:"running_disk_mb"`
	PausedMemoryMb   int32              `json:"paused_memory_mb"`
	PausedDiskMb     int32              `json:"paused_disk_mb"`
}

// Returns all online hosts with raw per-host sandbox resource consumption.
// Separates running and paused sandbox totals so the caller can apply its own formulas.
func (q *Queries) GetHostsWithLoad(ctx context.Context) ([]GetHostsWithLoadRow, error) {
	rows, err := q.db.Query(ctx, getHostsWithLoad)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetHostsWithLoadRow
	for rows.Next() {
		var i GetHostsWithLoadRow
		if err := rows.Scan(
			&i.ID,
			&i.Type,
			&i.TeamID,
			&i.Provider,
			&i.AvailabilityZone,
			&i.Arch,
			&i.CpuCores,
			&i.MemoryMb,
			&i.DiskGb,
			&i.Address,
			&i.Status,
			&i.LastHeartbeatAt,
			&i.Metadata,
			&i.CreatedBy,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.CertFingerprint,
			&i.CertExpiresAt,
			&i.RunningVcpus,
			&i.RunningMemoryMb,
			&i.RunningDiskMb,
			&i.PausedMemoryMb,
			&i.PausedDiskMb,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const insertHost = `-- name: InsertHost :one
INSERT INTO hosts (id, type, team_id, provider, availability_zone, created_by)
VALUES ($1, $2, $3, $4, $5, $6)
RETURNING id, type, team_id, provider, availability_zone, arch, cpu_cores, memory_mb, disk_gb, address, status, last_heartbeat_at, metadata, created_by, created_at, updated_at, cert_fingerprint, cert_expires_at
`

type InsertHostParams struct {
	ID               pgtype.UUID `json:"id"`
	Type             string      `json:"type"`
	TeamID           pgtype.UUID `json:"team_id"`
	Provider         string      `json:"provider"`
	AvailabilityZone string      `json:"availability_zone"`
	CreatedBy        pgtype.UUID `json:"created_by"`
}

func (q *Queries) InsertHost(ctx context.Context, arg InsertHostParams) (Host, error) {
	row := q.db.QueryRow(ctx, insertHost,
		arg.ID,
		arg.Type,
		arg.TeamID,
		arg.Provider,
		arg.AvailabilityZone,
		arg.CreatedBy,
	)
	var i Host
	err := row.Scan(
		&i.ID,
		&i.Type,
		&i.TeamID,
		&i.Provider,
		&i.AvailabilityZone,
		&i.Arch,
		&i.CpuCores,
		&i.MemoryMb,
		&i.DiskGb,
		&i.Address,
		&i.Status,
		&i.LastHeartbeatAt,
		&i.Metadata,
		&i.CreatedBy,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.CertFingerprint,
		&i.CertExpiresAt,
	)
	return i, err
}

const insertHostToken = `-- name: InsertHostToken :one
INSERT INTO host_tokens (id, host_id, created_by, expires_at)
VALUES ($1, $2, $3, $4)
RETURNING id, host_id, created_by, created_at, expires_at, used_at
`

type InsertHostTokenParams struct {
	ID        pgtype.UUID        `json:"id"`
	HostID    pgtype.UUID        `json:"host_id"`
	CreatedBy pgtype.UUID        `json:"created_by"`
	ExpiresAt pgtype.Timestamptz `json:"expires_at"`
}

func (q *Queries) InsertHostToken(ctx context.Context, arg InsertHostTokenParams) (HostToken, error) {
	row := q.db.QueryRow(ctx, insertHostToken,
		arg.ID,
		arg.HostID,
		arg.CreatedBy,
		arg.ExpiresAt,
	)
	var i HostToken
	err := row.Scan(
		&i.ID,
		&i.HostID,
		&i.CreatedBy,
		&i.CreatedAt,
		&i.ExpiresAt,
		&i.UsedAt,
	)
	return i, err
}

const listActiveHosts = `-- name: ListActiveHosts :many
SELECT id, type, team_id, provider, availability_zone, arch, cpu_cores, memory_mb, disk_gb, address, status, last_heartbeat_at, metadata, created_by, created_at, updated_at, cert_fingerprint, cert_expires_at FROM hosts WHERE status NOT IN ('pending', 'offline') ORDER BY created_at
`

// Returns all hosts that have completed registration (not pending/offline).
func (q *Queries) ListActiveHosts(ctx context.Context) ([]Host, error) {
	rows, err := q.db.Query(ctx, listActiveHosts)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Host
	for rows.Next() {
		var i Host
		if err := rows.Scan(
			&i.ID,
			&i.Type,
			&i.TeamID,
			&i.Provider,
			&i.AvailabilityZone,
			&i.Arch,
			&i.CpuCores,
			&i.MemoryMb,
			&i.DiskGb,
			&i.Address,
			&i.Status,
			&i.LastHeartbeatAt,
			&i.Metadata,
			&i.CreatedBy,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.CertFingerprint,
			&i.CertExpiresAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listHosts = `-- name: ListHosts :many
SELECT id, type, team_id, provider, availability_zone, arch, cpu_cores, memory_mb, disk_gb, address, status, last_heartbeat_at, metadata, created_by, created_at, updated_at, cert_fingerprint, cert_expires_at FROM hosts ORDER BY created_at DESC
`

func (q *Queries) ListHosts(ctx context.Context) ([]Host, error) {
	rows, err := q.db.Query(ctx, listHosts)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Host
	for rows.Next() {
		var i Host
		if err := rows.Scan(
			&i.ID,
			&i.Type,
			&i.TeamID,
			&i.Provider,
			&i.AvailabilityZone,
			&i.Arch,
			&i.CpuCores,
			&i.MemoryMb,
			&i.DiskGb,
			&i.Address,
			&i.Status,
			&i.LastHeartbeatAt,
			&i.Metadata,
			&i.CreatedBy,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.CertFingerprint,
			&i.CertExpiresAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listHostsByStatus = `-- name: ListHostsByStatus :many
SELECT id, type, team_id, provider, availability_zone, arch, cpu_cores, memory_mb, disk_gb, address, status, last_heartbeat_at, metadata, created_by, created_at, updated_at, cert_fingerprint, cert_expires_at FROM hosts WHERE status = $1 ORDER BY created_at DESC
`

func (q *Queries) ListHostsByStatus(ctx context.Context, status string) ([]Host, error) {
	rows, err := q.db.Query(ctx, listHostsByStatus, status)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Host
	for rows.Next() {
		var i Host
		if err := rows.Scan(
			&i.ID,
			&i.Type,
			&i.TeamID,
			&i.Provider,
			&i.AvailabilityZone,
			&i.Arch,
			&i.CpuCores,
			&i.MemoryMb,
			&i.DiskGb,
			&i.Address,
			&i.Status,
			&i.LastHeartbeatAt,
			&i.Metadata,
			&i.CreatedBy,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.CertFingerprint,
			&i.CertExpiresAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listHostsByTag = `-- name: ListHostsByTag :many
SELECT h.id, h.type, h.team_id, h.provider, h.availability_zone, h.arch, h.cpu_cores, h.memory_mb, h.disk_gb, h.address, h.status, h.last_heartbeat_at, h.metadata, h.created_by, h.created_at, h.updated_at, h.cert_fingerprint, h.cert_expires_at FROM hosts h
JOIN host_tags ht ON ht.host_id = h.id
WHERE ht.tag = $1
ORDER BY h.created_at DESC
`

func (q *Queries) ListHostsByTag(ctx context.Context, tag string) ([]Host, error) {
	rows, err := q.db.Query(ctx, listHostsByTag, tag)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Host
	for rows.Next() {
		var i Host
		if err := rows.Scan(
			&i.ID,
			&i.Type,
			&i.TeamID,
			&i.Provider,
			&i.AvailabilityZone,
			&i.Arch,
			&i.CpuCores,
			&i.MemoryMb,
			&i.DiskGb,
			&i.Address,
			&i.Status,
			&i.LastHeartbeatAt,
			&i.Metadata,
			&i.CreatedBy,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.CertFingerprint,
			&i.CertExpiresAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listHostsByTeam = `-- name: ListHostsByTeam :many
SELECT id, type, team_id, provider, availability_zone, arch, cpu_cores, memory_mb, disk_gb, address, status, last_heartbeat_at, metadata, created_by, created_at, updated_at, cert_fingerprint, cert_expires_at FROM hosts WHERE team_id = $1 AND type = 'byoc' ORDER BY created_at DESC
`

func (q *Queries) ListHostsByTeam(ctx context.Context, teamID pgtype.UUID) ([]Host, error) {
	rows, err := q.db.Query(ctx, listHostsByTeam, teamID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Host
	for rows.Next() {
		var i Host
		if err := rows.Scan(
			&i.ID,
			&i.Type,
			&i.TeamID,
			&i.Provider,
			&i.AvailabilityZone,
			&i.Arch,
			&i.CpuCores,
			&i.MemoryMb,
			&i.DiskGb,
			&i.Address,
			&i.Status,
			&i.LastHeartbeatAt,
			&i.Metadata,
			&i.CreatedBy,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.CertFingerprint,
			&i.CertExpiresAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listHostsByType = `-- name: ListHostsByType :many
SELECT id, type, team_id, provider, availability_zone, arch, cpu_cores, memory_mb, disk_gb, address, status, last_heartbeat_at, metadata, created_by, created_at, updated_at, cert_fingerprint, cert_expires_at FROM hosts WHERE type = $1 ORDER BY created_at DESC
`

func (q *Queries) ListHostsByType(ctx context.Context, type_ string) ([]Host, error) {
	rows, err := q.db.Query(ctx, listHostsByType, type_)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Host
	for rows.Next() {
		var i Host
		if err := rows.Scan(
			&i.ID,
			&i.Type,
			&i.TeamID,
			&i.Provider,
			&i.AvailabilityZone,
			&i.Arch,
			&i.CpuCores,
			&i.MemoryMb,
			&i.DiskGb,
			&i.Address,
			&i.Status,
			&i.LastHeartbeatAt,
			&i.Metadata,
			&i.CreatedBy,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.CertFingerprint,
			&i.CertExpiresAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const markHostTokenUsed = `-- name: MarkHostTokenUsed :exec
UPDATE host_tokens SET used_at = NOW() WHERE id = $1
`

func (q *Queries) MarkHostTokenUsed(ctx context.Context, id pgtype.UUID) error {
	_, err := q.db.Exec(ctx, markHostTokenUsed, id)
	return err
}

const markHostUnreachable = `-- name: MarkHostUnreachable :exec
UPDATE hosts SET status = 'unreachable', updated_at = NOW() WHERE id = $1
`

func (q *Queries) MarkHostUnreachable(ctx context.Context, id pgtype.UUID) error {
	_, err := q.db.Exec(ctx, markHostUnreachable, id)
	return err
}

const registerHost = `-- name: RegisterHost :execrows
UPDATE hosts
SET arch             = $2,
    cpu_cores        = $3,
    memory_mb        = $4,
    disk_gb          = $5,
    address          = $6,
    cert_fingerprint = $7,
    cert_expires_at  = $8,
    status           = 'online',
    last_heartbeat_at = NOW(),
    updated_at        = NOW()
WHERE id = $1 AND status = 'pending'
`

type RegisterHostParams struct {
	ID              pgtype.UUID        `json:"id"`
	Arch            string             `json:"arch"`
	CpuCores        int32              `json:"cpu_cores"`
	MemoryMb        int32              `json:"memory_mb"`
	DiskGb          int32              `json:"disk_gb"`
	Address         string             `json:"address"`
	CertFingerprint string             `json:"cert_fingerprint"`
	CertExpiresAt   pgtype.Timestamptz `json:"cert_expires_at"`
}

func (q *Queries) RegisterHost(ctx context.Context, arg RegisterHostParams) (int64, error) {
	result, err := q.db.Exec(ctx, registerHost,
		arg.ID,
		arg.Arch,
		arg.CpuCores,
		arg.MemoryMb,
		arg.DiskGb,
		arg.Address,
		arg.CertFingerprint,
		arg.CertExpiresAt,
	)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected(), nil
}

const removeHostTag = `-- name: RemoveHostTag :exec
DELETE FROM host_tags WHERE host_id = $1 AND tag = $2
`

type RemoveHostTagParams struct {
	HostID pgtype.UUID `json:"host_id"`
	Tag    string      `json:"tag"`
}

func (q *Queries) RemoveHostTag(ctx context.Context, arg RemoveHostTagParams) error {
	_, err := q.db.Exec(ctx, removeHostTag, arg.HostID, arg.Tag)
	return err
}

const updateHostCert = `-- name: UpdateHostCert :exec
UPDATE hosts
SET cert_fingerprint = $2,
    cert_expires_at  = $3,
    updated_at       = NOW()
WHERE id = $1
`

type UpdateHostCertParams struct {
	ID              pgtype.UUID        `json:"id"`
	CertFingerprint string             `json:"cert_fingerprint"`
	CertExpiresAt   pgtype.Timestamptz `json:"cert_expires_at"`
}

func (q *Queries) UpdateHostCert(ctx context.Context, arg UpdateHostCertParams) error {
	_, err := q.db.Exec(ctx, updateHostCert, arg.ID, arg.CertFingerprint, arg.CertExpiresAt)
	return err
}

const updateHostHeartbeat = `-- name: UpdateHostHeartbeat :exec
UPDATE hosts SET last_heartbeat_at = NOW(), updated_at = NOW() WHERE id = $1
`

func (q *Queries) UpdateHostHeartbeat(ctx context.Context, id pgtype.UUID) error {
	_, err := q.db.Exec(ctx, updateHostHeartbeat, id)
	return err
}

const updateHostHeartbeatAndStatus = `-- name: UpdateHostHeartbeatAndStatus :execrows
UPDATE hosts
SET last_heartbeat_at = NOW(),
    status            = CASE WHEN status = 'unreachable' THEN 'online' ELSE status END,
    updated_at        = NOW()
WHERE id = $1
`

// Updates last_heartbeat_at and transitions unreachable hosts back to online.
// Returns 0 if no host was found (deleted), which the caller treats as 404.
func (q *Queries) UpdateHostHeartbeatAndStatus(ctx context.Context, id pgtype.UUID) (int64, error) {
	result, err := q.db.Exec(ctx, updateHostHeartbeatAndStatus, id)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected(), nil
}

const updateHostStatus = `-- name: UpdateHostStatus :exec
UPDATE hosts SET status = $2, updated_at = NOW() WHERE id = $1
`

type UpdateHostStatusParams struct {
	ID     pgtype.UUID `json:"id"`
	Status string      `json:"status"`
}

func (q *Queries) UpdateHostStatus(ctx context.Context, arg UpdateHostStatusParams) error {
	_, err := q.db.Exec(ctx, updateHostStatus, arg.ID, arg.Status)
	return err
}