// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.31.1
// source: runtime.sql

package sqlcdb

import (
	"context"
	"database/sql"

	"github.com/google/uuid"
)

const getLastDeployedImage = `-- name: GetLastDeployedImage :one
SELECT (image_name || ':' || image_tag)::text AS image FROM deployments
WHERE service_id = $1 AND status = 'deployed' AND image_name <> ''
ORDER BY created_at DESC LIMIT 1
`

func (q *Queries) GetLastDeployedImage(ctx context.Context, serviceID uuid.UUID) (string, error) {
	row := q.db.QueryRowContext(ctx, getLastDeployedImage, serviceID)
	var image string
	err := row.Scan(&image)
	return image, err
}

const getServiceDomainText = `-- name: GetServiceDomainText :one
SELECT COALESCE(domain,'') AS domain FROM services WHERE id = $1
`

func (q *Queries) GetServiceDomainText(ctx context.Context, id uuid.UUID) (string, error) {
	row := q.db.QueryRowContext(ctx, getServiceDomainText, id)
	var domain string
	err := row.Scan(&domain)
	return domain, err
}

const getServicePort = `-- name: GetServicePort :one
SELECT COALESCE(port, 0) AS port FROM services WHERE id = $1
`

func (q *Queries) GetServicePort(ctx context.Context, id uuid.UUID) (int32, error) {
	row := q.db.QueryRowContext(ctx, getServicePort, id)
	var port int32
	err := row.Scan(&port)
	return port, err
}

const getServiceRuntimeWithOwner = `-- name: GetServiceRuntimeWithOwner :one
SELECT s.id, s.project_id, s.name,
       COALESCE(s.type, s.service_type, '') AS type, COALESCE(s.status, '') AS status,
       COALESCE(s.image, s.image_name, '') AS image, COALESCE(s.command, s.start_command, '') AS command,
       COALESCE(s.environment, '') AS environment, COALESCE(s.git_repo, s.source_url, '') AS git_repo,
       COALESCE(s.git_branch, '') AS git_branch, COALESCE(s.build_path, '') AS build_path,
       COALESCE(s.cpu, '') AS cpu, COALESCE(s.memory, '') AS memory,
       COALESCE(s.replicas, 1) AS replicas, COALESCE(s.port, 0) AS port,
       COALESCE(s.domain, '') AS domain, COALESCE(s.healthcheck_path, '') AS healthcheck_path,
       COALESCE(s.restart_policy, 'unless-stopped') AS restart_policy,
       COALESCE(s.builder, 'auto') AS builder, COALESCE(s.cpu_reserve, '') AS cpu_reserve,
       COALESCE(s.memory_reserve, '') AS memory_reserve, COALESCE(s.static_build_cmd, '') AS static_build_cmd,
       COALESCE(s.static_dir, '') AS static_dir,
       s.created_at, s.updated_at, p.owner_id
FROM services s
JOIN projects p ON s.project_id = p.id
WHERE s.id = $1
`

type GetServiceRuntimeWithOwnerRow struct {
	ID              uuid.UUID    `json:"id"`
	ProjectID       uuid.UUID    `json:"project_id"`
	Name            string       `json:"name"`
	Type            string       `json:"type"`
	Status          string       `json:"status"`
	Image           string       `json:"image"`
	Command         string       `json:"command"`
	Environment     string       `json:"environment"`
	GitRepo         string       `json:"git_repo"`
	GitBranch       string       `json:"git_branch"`
	BuildPath       string       `json:"build_path"`
	Cpu             string       `json:"cpu"`
	Memory          string       `json:"memory"`
	Replicas        int32        `json:"replicas"`
	Port            int32        `json:"port"`
	Domain          string       `json:"domain"`
	HealthcheckPath string       `json:"healthcheck_path"`
	RestartPolicy   string       `json:"restart_policy"`
	Builder         string       `json:"builder"`
	CpuReserve      string       `json:"cpu_reserve"`
	MemoryReserve   string       `json:"memory_reserve"`
	StaticBuildCmd  string       `json:"static_build_cmd"`
	StaticDir       string       `json:"static_dir"`
	CreatedAt       sql.NullTime `json:"created_at"`
	UpdatedAt       sql.NullTime `json:"updated_at"`
	OwnerID         uuid.UUID    `json:"owner_id"`
}

func (q *Queries) GetServiceRuntimeWithOwner(ctx context.Context, id uuid.UUID) (GetServiceRuntimeWithOwnerRow, error) {
	row := q.db.QueryRowContext(ctx, getServiceRuntimeWithOwner, id)
	var i GetServiceRuntimeWithOwnerRow
	err := row.Scan(
		&i.ID,
		&i.ProjectID,
		&i.Name,
		&i.Type,
		&i.Status,
		&i.Image,
		&i.Command,
		&i.Environment,
		&i.GitRepo,
		&i.GitBranch,
		&i.BuildPath,
		&i.Cpu,
		&i.Memory,
		&i.Replicas,
		&i.Port,
		&i.Domain,
		&i.HealthcheckPath,
		&i.RestartPolicy,
		&i.Builder,
		&i.CpuReserve,
		&i.MemoryReserve,
		&i.StaticBuildCmd,
		&i.StaticDir,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.OwnerID,
	)
	return i, err
}

const getServiceStatusText = `-- name: GetServiceStatusText :one
SELECT COALESCE(status,'') AS status FROM services WHERE id = $1
`

func (q *Queries) GetServiceStatusText(ctx context.Context, id uuid.UUID) (string, error) {
	row := q.db.QueryRowContext(ctx, getServiceStatusText, id)
	var status string
	err := row.Scan(&status)
	return status, err
}

const getServiceVariableValue = `-- name: GetServiceVariableValue :one
SELECT value FROM environment_variables WHERE service_id = $1 AND key = $2
`

type GetServiceVariableValueParams struct {
	ServiceID uuid.UUID `json:"service_id"`
	Key       string    `json:"key"`
}

func (q *Queries) GetServiceVariableValue(ctx context.Context, arg GetServiceVariableValueParams) (string, error) {
	row := q.db.QueryRowContext(ctx, getServiceVariableValue, arg.ServiceID, arg.Key)
	var value string
	err := row.Scan(&value)
	return value, err
}

const listNodeAgentsForService = `-- name: ListNodeAgentsForService :many
SELECT DISTINCT node_agent_id FROM container_instances WHERE service_id = $1
`

func (q *Queries) ListNodeAgentsForService(ctx context.Context, serviceID string) ([]string, error) {
	rows, err := q.db.QueryContext(ctx, listNodeAgentsForService, serviceID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []string{}
	for rows.Next() {
		var node_agent_id string
		if err := rows.Scan(&node_agent_id); err != nil {
			return nil, err
		}
		items = append(items, node_agent_id)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listProjectServiceRefs = `-- name: ListProjectServiceRefs :many
SELECT id, name FROM services WHERE project_id = $1
`

type ListProjectServiceRefsRow struct {
	ID   uuid.UUID `json:"id"`
	Name string    `json:"name"`
}

func (q *Queries) ListProjectServiceRefs(ctx context.Context, projectID uuid.UUID) ([]ListProjectServiceRefsRow, error) {
	rows, err := q.db.QueryContext(ctx, listProjectServiceRefs, projectID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListProjectServiceRefsRow{}
	for rows.Next() {
		var i ListProjectServiceRefsRow
		if err := rows.Scan(&i.ID, &i.Name); 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 listServiceVariableValues = `-- name: ListServiceVariableValues :many
SELECT key, value FROM environment_variables WHERE service_id = $1
`

type ListServiceVariableValuesRow struct {
	Key   string `json:"key"`
	Value string `json:"value"`
}

func (q *Queries) ListServiceVariableValues(ctx context.Context, serviceID uuid.UUID) ([]ListServiceVariableValuesRow, error) {
	rows, err := q.db.QueryContext(ctx, listServiceVariableValues, serviceID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListServiceVariableValuesRow{}
	for rows.Next() {
		var i ListServiceVariableValuesRow
		if err := rows.Scan(&i.Key, &i.Value); 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 listServiceVariablesWithSecret = `-- name: ListServiceVariablesWithSecret :many
SELECT key, value, COALESCE(is_secret, false) AS is_secret
FROM environment_variables WHERE service_id = $1
`

type ListServiceVariablesWithSecretRow struct {
	Key      string `json:"key"`
	Value    string `json:"value"`
	IsSecret bool   `json:"is_secret"`
}

func (q *Queries) ListServiceVariablesWithSecret(ctx context.Context, serviceID uuid.UUID) ([]ListServiceVariablesWithSecretRow, error) {
	rows, err := q.db.QueryContext(ctx, listServiceVariablesWithSecret, serviceID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListServiceVariablesWithSecretRow{}
	for rows.Next() {
		var i ListServiceVariablesWithSecretRow
		if err := rows.Scan(&i.Key, &i.Value, &i.IsSecret); 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 listSleepCandidates = `-- name: ListSleepCandidates :many
SELECT id, project_id, name, COALESCE(status,'') AS status,
       COALESCE(sleep_idle_minutes, 15) AS sleep_idle_minutes
FROM services
WHERE sleep_enabled AND COALESCE(status,'') IN ('running','deployed','degraded','starting')
`

type ListSleepCandidatesRow struct {
	ID               uuid.UUID `json:"id"`
	ProjectID        uuid.UUID `json:"project_id"`
	Name             string    `json:"name"`
	Status           string    `json:"status"`
	SleepIdleMinutes int32     `json:"sleep_idle_minutes"`
}

func (q *Queries) ListSleepCandidates(ctx context.Context) ([]ListSleepCandidatesRow, error) {
	rows, err := q.db.QueryContext(ctx, listSleepCandidates)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListSleepCandidatesRow{}
	for rows.Next() {
		var i ListSleepCandidatesRow
		if err := rows.Scan(
			&i.ID,
			&i.ProjectID,
			&i.Name,
			&i.Status,
			&i.SleepIdleMinutes,
		); 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 setServicePublishedPort = `-- name: SetServicePublishedPort :exec
UPDATE services SET published_port = $1 WHERE id = $2 AND published_port <> $1
`

type SetServicePublishedPortParams struct {
	PublishedPort int32     `json:"published_port"`
	ID            uuid.UUID `json:"id"`
}

func (q *Queries) SetServicePublishedPort(ctx context.Context, arg SetServicePublishedPortParams) error {
	_, err := q.db.ExecContext(ctx, setServicePublishedPort, arg.PublishedPort, arg.ID)
	return err
}

const setServiceReplicas = `-- name: SetServiceReplicas :exec
UPDATE services SET replicas = $1, updated_at = $2 WHERE id = $3
`

type SetServiceReplicasParams struct {
	Replicas  int32        `json:"replicas"`
	UpdatedAt sql.NullTime `json:"updated_at"`
	ID        uuid.UUID    `json:"id"`
}

func (q *Queries) SetServiceReplicas(ctx context.Context, arg SetServiceReplicasParams) error {
	_, err := q.db.ExecContext(ctx, setServiceReplicas, arg.Replicas, arg.UpdatedAt, arg.ID)
	return err
}