package v2

import (
	"cue.dev/x/k8s.io/apimachinery/pkg/api/resource"
	"cue.dev/x/k8s.io/apimachinery/pkg/apis/meta/v1"
)

// ContainerResourceMetricSource indicates how to scale on a
// resource metric known to Kubernetes, as specified in requests
// and limits, describing each pod in the current scale target
// (e.g. CPU or memory). The values will be averaged together
// before being compared to the target. Such metrics are built in
// to Kubernetes, and have special scaling options on top of
// those available to normal per-pod metrics using the "pods"
// source. Only one "target" type should be set.
#ContainerResourceMetricSource: {
	// container is the name of the container in the pods of the
	// scaling target
	"container"!: string

	// name is the name of the resource in question.
	"name"!: string

	// target specifies the target value for the given metric
	"target"!: #MetricTarget
}

// ContainerResourceMetricStatus indicates the current value of a
// resource metric known to Kubernetes, as specified in requests
// and limits, describing a single container in each pod in the
// current scale target (e.g. CPU or memory). Such metrics are
// built in to Kubernetes, and have special scaling options on
// top of those available to normal per-pod metrics using the
// "pods" source.
#ContainerResourceMetricStatus: {
	// container is the name of the container in the pods of the
	// scaling target
	"container"!: string

	// current contains the current value for the given metric
	"current"!: #MetricValueStatus

	// name is the name of the resource in question.
	"name"!: string
}

// CrossVersionObjectReference contains enough information to let
// you identify the referred resource.
#CrossVersionObjectReference: {
	// apiVersion is the API version of the referent
	"apiVersion"?: string

	// kind is the kind of the referent; More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	"kind"!: string

	// name is the name of the referent; More info:
	// https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
	"name"!: string
}

// ExternalMetricSource indicates how to scale on a metric not
// associated with any Kubernetes object (for example length of
// queue in cloud messaging service, or QPS from loadbalancer
// running outside of cluster).
#ExternalMetricSource: {
	// metric identifies the target metric by name and selector
	"metric"!: #MetricIdentifier

	// target specifies the target value for the given metric
	"target"!: #MetricTarget
}

// ExternalMetricStatus indicates the current value of a global
// metric not associated with any Kubernetes object.
#ExternalMetricStatus: {
	// current contains the current value for the given metric
	"current"!: #MetricValueStatus

	// metric identifies the target metric by name and selector
	"metric"!: #MetricIdentifier
}

// HPAScalingPolicy is a single policy which must hold true for a
// specified past interval.
#HPAScalingPolicy: {
	// periodSeconds specifies the window of time for which the policy
	// should hold true. PeriodSeconds must be greater than zero and
	// less than or equal to 1800 (30 min).
	"periodSeconds"!: int32 & int

	// type is used to specify the scaling policy.
	"type"!: string

	// value contains the amount of change which is permitted by the
	// policy. It must be greater than zero
	"value"!: int32 & int
}

// HPAScalingRules configures the scaling behavior for one
// direction via scaling Policy Rules and a configurable metric
// tolerance.
//
// Scaling Policy Rules are applied after calculating
// DesiredReplicas from metrics for the HPA. They can limit the
// scaling velocity by specifying scaling policies. They can
// prevent flapping by specifying the stabilization window, so
// that the number of replicas is not set instantly, instead, the
// safest value from the stabilization window is chosen.
//
// The tolerance is applied to the metric values and prevents
// scaling too eagerly for small metric variations. (Note that
// setting a tolerance requires the beta HPAConfigurableTolerance
// feature gate to be enabled.)
#HPAScalingRules: {
	// policies is a list of potential scaling polices which can be
	// used during scaling. If not set, use the default values: - For
	// scale up: allow doubling the number of pods, or an absolute
	// change of 4 pods in a 15s window. - For scale down: allow all
	// pods to be removed in a 15s window.
	"policies"?: [...#HPAScalingPolicy]

	// selectPolicy is used to specify which policy should be used. If
	// not set, the default value Max is used.
	"selectPolicy"?: string

	// stabilizationWindowSeconds is the number of seconds for which
	// past recommendations should be considered while scaling up or
	// scaling down. StabilizationWindowSeconds must be greater than
	// or equal to zero and less than or equal to 3600 (one hour). If
	// not set, use the default values: - For scale up: 0 (i.e. no
	// stabilization is done). - For scale down: 300 (i.e. the
	// stabilization window is 300 seconds long).
	"stabilizationWindowSeconds"?: int32 & int

	// tolerance is the tolerance on the ratio between the current and
	// desired metric value under which no updates are made to the
	// desired number of replicas (e.g. 0.01 for 1%). Must be greater
	// than or equal to zero. If not set, the default cluster-wide
	// tolerance is applied (by default 10%).
	//
	// For example, if autoscaling is configured with a memory
	// consumption target of 100Mi, and scale-down and scale-up
	// tolerances of 5% and 1% respectively, scaling will be
	// triggered when the actual consumption falls below 95Mi or
	// exceeds 101Mi.
	//
	// This is an beta field and requires the HPAConfigurableTolerance
	// feature gate to be enabled.
	"tolerance"?: resource.#Quantity
}

// HorizontalPodAutoscaler is the configuration for a horizontal
// pod autoscaler, which automatically manages the replica count
// of any resource implementing the scale subresource based on
// the metrics specified.
#HorizontalPodAutoscaler: {
	// APIVersion defines the versioned schema of this representation
	// of an object. Servers should convert recognized schemas to the
	// latest internal value, and may reject unrecognized values.
	// More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
	"apiVersion": "autoscaling/v2"

	// Kind is a string value representing the REST resource this
	// object represents. Servers may infer this from the endpoint
	// the client submits requests to. Cannot be updated. In
	// CamelCase. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	"kind": "HorizontalPodAutoscaler"

	// metadata is the standard object metadata. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	"metadata"?: v1.#ObjectMeta

	// spec is the specification for the behaviour of the autoscaler.
	// More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status.
	"spec"?: #HorizontalPodAutoscalerSpec

	// status is the current information about the autoscaler.
	"status"?: #HorizontalPodAutoscalerStatus
}

// HorizontalPodAutoscalerBehavior configures the scaling behavior
// of the target in both Up and Down directions (scaleUp and
// scaleDown fields respectively).
#HorizontalPodAutoscalerBehavior: {
	// scaleDown is scaling policy for scaling Down. If not set, the
	// default value is to allow to scale down to minReplicas pods,
	// with a 300 second stabilization window (i.e., the highest
	// recommendation for the last 300sec is used).
	"scaleDown"?: #HPAScalingRules

	// scaleUp is scaling policy for scaling Up. If not set, the
	// default value is the higher of:
	// * increase no more than 4 pods per 60 seconds
	// * double the number of pods per 60 seconds
	// No stabilization is used.
	"scaleUp"?: #HPAScalingRules
}

// HorizontalPodAutoscalerCondition describes the state of a
// HorizontalPodAutoscaler at a certain point.
#HorizontalPodAutoscalerCondition: {
	// lastTransitionTime is the last time the condition transitioned
	// from one status to another
	"lastTransitionTime"?: v1.#Time

	// message is a human-readable explanation containing details
	// about the transition
	"message"?: string

	// reason is the reason for the condition's last transition.
	"reason"?: string

	// status is the status of the condition (True, False, Unknown)
	"status"!: string

	// type describes the current condition
	"type"!: string
}

// HorizontalPodAutoscalerList is a list of horizontal pod
// autoscaler objects.
#HorizontalPodAutoscalerList: {
	// APIVersion defines the versioned schema of this representation
	// of an object. Servers should convert recognized schemas to the
	// latest internal value, and may reject unrecognized values.
	// More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
	"apiVersion": "autoscaling/v2"

	// items is the list of horizontal pod autoscaler objects.
	"items"!: [...#HorizontalPodAutoscaler]

	// Kind is a string value representing the REST resource this
	// object represents. Servers may infer this from the endpoint
	// the client submits requests to. Cannot be updated. In
	// CamelCase. More info:
	// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	"kind": "HorizontalPodAutoscalerList"

	// metadata is the standard list metadata.
	"metadata"?: v1.#ListMeta
}

// HorizontalPodAutoscalerSpec describes the desired functionality
// of the HorizontalPodAutoscaler.
#HorizontalPodAutoscalerSpec: {
	// behavior configures the scaling behavior of the target in both
	// Up and Down directions (scaleUp and scaleDown fields
	// respectively). If not set, the default HPAScalingRules for
	// scale up and scale down are used.
	"behavior"?: #HorizontalPodAutoscalerBehavior

	// maxReplicas is the upper limit for the number of replicas to
	// which the autoscaler can scale up. It cannot be less that
	// minReplicas.
	"maxReplicas"!: int32 & int

	// metrics contains the specifications for which to use to
	// calculate the desired replica count (the maximum replica count
	// across all metrics will be used). The desired replica count is
	// calculated multiplying the ratio between the target value and
	// the current value by the current number of pods. Ergo, metrics
	// used must decrease as the pod count is increased, and
	// vice-versa. See the individual metric source types for more
	// information about how each type of metric must respond. If not
	// set, the default metric will be set to 80% average CPU
	// utilization.
	"metrics"?: [...#MetricSpec]

	// minReplicas is the lower limit for the number of replicas to
	// which the autoscaler can scale down. It defaults to 1 pod.
	// minReplicas is allowed to be 0 if the alpha feature gate
	// HPAScaleToZero is enabled and at least one Object or External
	// metric is configured. Scaling is active as long as at least
	// one metric value is available.
	"minReplicas"?: int32 & int

	// scaleTargetRef points to the target resource to scale, and is
	// used to the pods for which metrics should be collected, as
	// well as to actually change the replica count.
	"scaleTargetRef"!: #CrossVersionObjectReference
}

// HorizontalPodAutoscalerStatus describes the current status of a
// horizontal pod autoscaler.
#HorizontalPodAutoscalerStatus: {
	// conditions is the set of conditions required for this
	// autoscaler to scale its target, and indicates whether or not
	// those conditions are met.
	"conditions"?: [...#HorizontalPodAutoscalerCondition]

	// currentMetrics is the last read state of the metrics used by
	// this autoscaler.
	"currentMetrics"?: [...#MetricStatus]

	// currentReplicas is current number of replicas of pods managed
	// by this autoscaler, as last seen by the autoscaler.
	"currentReplicas"?: int32 & int

	// desiredReplicas is the desired number of replicas of pods
	// managed by this autoscaler, as last calculated by the
	// autoscaler.
	"desiredReplicas"!: int32 & int

	// lastScaleTime is the last time the HorizontalPodAutoscaler
	// scaled the number of pods, used by the autoscaler to control
	// how often the number of pods is changed.
	"lastScaleTime"?: v1.#Time

	// observedGeneration is the most recent generation observed by
	// this autoscaler.
	"observedGeneration"?: int64 & int
}

// MetricIdentifier defines the name and optionally selector for a
// metric
#MetricIdentifier: {
	// name is the name of the given metric
	"name"!: string

	// selector is the string-encoded form of a standard kubernetes
	// label selector for the given metric When set, it is passed as
	// an additional parameter to the metrics server for more
	// specific metrics scoping. When unset, just the metricName will
	// be used to gather metrics.
	"selector"?: v1.#LabelSelector
}

// MetricSpec specifies how to scale based on a single metric
// (only `type` and one other matching field should be set at
// once).
#MetricSpec: {
	// containerResource refers to a resource metric (such as those
	// specified in requests and limits) known to Kubernetes
	// describing a single container in each pod of the current scale
	// target (e.g. CPU or memory). Such metrics are built in to
	// Kubernetes, and have special scaling options on top of those
	// available to normal per-pod metrics using the "pods" source.
	"containerResource"?: #ContainerResourceMetricSource

	// external refers to a global metric that is not associated with
	// any Kubernetes object. It allows autoscaling based on
	// information coming from components running outside of cluster
	// (for example length of queue in cloud messaging service, or
	// QPS from loadbalancer running outside of cluster).
	"external"?: #ExternalMetricSource

	// object refers to a metric describing a single kubernetes object
	// (for example, hits-per-second on an Ingress object).
	"object"?: #ObjectMetricSource

	// pods refers to a metric describing each pod in the current
	// scale target (for example, transactions-processed-per-second).
	// The values will be averaged together before being compared to
	// the target value.
	"pods"?: #PodsMetricSource

	// resource refers to a resource metric (such as those specified
	// in requests and limits) known to Kubernetes describing each
	// pod in the current scale target (e.g. CPU or memory). Such
	// metrics are built in to Kubernetes, and have special scaling
	// options on top of those available to normal per-pod metrics
	// using the "pods" source.
	"resource"?: #ResourceMetricSource

	// type is the type of metric source. It should be one of
	// "ContainerResource", "External", "Object", "Pods" or
	// "Resource", each mapping to a matching field in the object.
	"type"!: string
}

// MetricStatus describes the last-read state of a single metric.
#MetricStatus: {
	// container resource refers to a resource metric (such as those
	// specified in requests and limits) known to Kubernetes
	// describing a single container in each pod in the current scale
	// target (e.g. CPU or memory). Such metrics are built in to
	// Kubernetes, and have special scaling options on top of those
	// available to normal per-pod metrics using the "pods" source.
	"containerResource"?: #ContainerResourceMetricStatus

	// external refers to a global metric that is not associated with
	// any Kubernetes object. It allows autoscaling based on
	// information coming from components running outside of cluster
	// (for example length of queue in cloud messaging service, or
	// QPS from loadbalancer running outside of cluster).
	"external"?: #ExternalMetricStatus

	// object refers to a metric describing a single kubernetes object
	// (for example, hits-per-second on an Ingress object).
	"object"?: #ObjectMetricStatus

	// pods refers to a metric describing each pod in the current
	// scale target (for example, transactions-processed-per-second).
	// The values will be averaged together before being compared to
	// the target value.
	"pods"?: #PodsMetricStatus

	// resource refers to a resource metric (such as those specified
	// in requests and limits) known to Kubernetes describing each
	// pod in the current scale target (e.g. CPU or memory). Such
	// metrics are built in to Kubernetes, and have special scaling
	// options on top of those available to normal per-pod metrics
	// using the "pods" source.
	"resource"?: #ResourceMetricStatus

	// type is the type of metric source. It will be one of
	// "ContainerResource", "External", "Object", "Pods" or
	// "Resource", each corresponds to a matching field in the
	// object.
	"type"!: string
}

// MetricTarget defines the target value, average value, or
// average utilization of a specific metric
#MetricTarget: {
	// averageUtilization is the target value of the average of the
	// resource metric across all relevant pods, represented as a
	// percentage of the requested value of the resource for the
	// pods. Currently only valid for Resource metric source type
	"averageUtilization"?: int32 & int

	// averageValue is the target value of the average of the metric
	// across all relevant pods (as a quantity)
	"averageValue"?: resource.#Quantity

	// type represents whether the metric type is Utilization, Value,
	// or AverageValue
	"type"!: string

	// value is the target value of the metric (as a quantity).
	"value"?: resource.#Quantity
}

// MetricValueStatus holds the current value for a metric
#MetricValueStatus: {
	// currentAverageUtilization is the current value of the average
	// of the resource metric across all relevant pods, represented
	// as a percentage of the requested value of the resource for the
	// pods.
	"averageUtilization"?: int32 & int

	// averageValue is the current value of the average of the metric
	// across all relevant pods (as a quantity)
	"averageValue"?: resource.#Quantity

	// value is the current value of the metric (as a quantity).
	"value"?: resource.#Quantity
}

// ObjectMetricSource indicates how to scale on a metric
// describing a kubernetes object (for example, hits-per-second
// on an Ingress object).
#ObjectMetricSource: {
	// describedObject specifies the descriptions of a object,such as
	// kind,name apiVersion
	"describedObject"!: #CrossVersionObjectReference

	// metric identifies the target metric by name and selector
	"metric"!: #MetricIdentifier

	// target specifies the target value for the given metric
	"target"!: #MetricTarget
}

// ObjectMetricStatus indicates the current value of a metric
// describing a kubernetes object (for example, hits-per-second
// on an Ingress object).
#ObjectMetricStatus: {
	// current contains the current value for the given metric
	"current"!: #MetricValueStatus

	// DescribedObject specifies the descriptions of a object,such as
	// kind,name apiVersion
	"describedObject"!: #CrossVersionObjectReference

	// metric identifies the target metric by name and selector
	"metric"!: #MetricIdentifier
}

// PodsMetricSource indicates how to scale on a metric describing
// each pod in the current scale target (for example,
// transactions-processed-per-second). The values will be
// averaged together before being compared to the target value.
#PodsMetricSource: {
	// metric identifies the target metric by name and selector
	"metric"!: #MetricIdentifier

	// target specifies the target value for the given metric
	"target"!: #MetricTarget
}

// PodsMetricStatus indicates the current value of a metric
// describing each pod in the current scale target (for example,
// transactions-processed-per-second).
#PodsMetricStatus: {
	// current contains the current value for the given metric
	"current"!: #MetricValueStatus

	// metric identifies the target metric by name and selector
	"metric"!: #MetricIdentifier
}

// ResourceMetricSource indicates how to scale on a resource
// metric known to Kubernetes, as specified in requests and
// limits, describing each pod in the current scale target (e.g.
// CPU or memory). The values will be averaged together before
// being compared to the target. Such metrics are built in to
// Kubernetes, and have special scaling options on top of those
// available to normal per-pod metrics using the "pods" source.
// Only one "target" type should be set.
#ResourceMetricSource: {
	// name is the name of the resource in question.
	"name"!: string

	// target specifies the target value for the given metric
	"target"!: #MetricTarget
}

// ResourceMetricStatus indicates the current value of a resource
// metric known to Kubernetes, as specified in requests and
// limits, describing each pod in the current scale target (e.g.
// CPU or memory). Such metrics are built in to Kubernetes, and
// have special scaling options on top of those available to
// normal per-pod metrics using the "pods" source.
#ResourceMetricStatus: {
	// current contains the current value for the given metric
	"current"!: #MetricValueStatus

	// name is the name of the resource in question.
	"name"!: string
}