v1alpha1

type DailyUsageReport struct {
	Date    metav1.Time `json:"date"`
	Status  string      `json:"status,omitempty"`
	Message string      `json:"message,omitempty"`
}

type GarbageCollectionConfig struct {
	// KeepDuration specifies how long a ResourceUsage record should be kept after its tracking period has ended.
	// If not specified, no completed ResourceUsage records will be deleted based on their age.
	// +optional
	KeepDuration *metav1.Duration `json:"keepDuration,omitempty"`

	// KeepCount specifies how many completed ResourceUsage records (per resource) should be kept, regardless of their age.
	// If 0, no completed ResourceUsage records will be deleted based on their count.
	// +optional
	KeepCount int `json:"keepCount,omitempty"`

	// AndConditions specifies whether a completed ResourceUsage record should be deleted only if both the KeepDuration and KeepCount conditions are met (true), or if either of them is met (false).
	// If not specified, the default is false (delete if either condition is met).
	// Has no effect if only one of the conditions is specified.
	// +optional
	AndConditions bool `json:"andConditions,omitempty"`

	// Interval specifies the interval at which the garbage collector runs.
	// Defaults to 24 hours if not specified.
	// +kubebuilder:default="24h"
	// +optional
	Interval *metav1.Duration `json:"interval,omitempty"`
}

type NamespaceSelector struct {
	// Names is a list of namespace names to select. Only resources in these namespaces will be tracked.
	// If this is specified, the LabelSelector in Selector will be ignored.
	// Note that there is a difference between a null and an empty list: a null value means that all namespaces are selected, while an empty list means that no namespaces are selected.
	// +nullable
	// +optional
	Names []string `json:"names,omitempty"`

	// Selector is a label selector for the namespace. Only resources in namespaces matching this selector will be tracked.
	// Will be ignored if specified together with Names.
	// +optional
	Selector *metav1.LabelSelector `json:"selector,omitempty"`
}

type ResourceReference struct {
	metav1.GroupVersionKind   `json:",inline"`
	commonapi.ObjectReference `json:",inline"`
}

type ResourceToTrack struct {
	metav1.GroupVersionKind `json:",inline"`

	// Selector allows to filter the tracked resources.
	// +optional
	Selector *Selector `json:"selector,omitempty"`

	// ResourceUsagePeriod specifies the duration which should be tracked in a single ResourceUsage record for this resource type.
	// If the duration is exceeded, a new ResourceUsage record will be created for the resource.
	// Defaults to 30 days if not specified.
	// +kubebuilder:default="720h"
	// +optional
	ResourceUsagePeriod *metav1.Duration `json:"resourceUsagePeriod,omitempty"`

	// TrackUntil specifies when usage tracking is stopped.
	// This can either happen when the resource gets a deletion timestamp, or when it is actually removed.
	// Valid values are 'Deletion' and 'DeletionTimestamp', defaulting to the former one if not specified.
	// +kubebuilder:validation:Enum=Deletion;DeletionTimestamp
	// +optional
	TrackUntil TrackUntilMode `json:"trackUntil,omitempty"`

	// Traits specifies traits which should be tracked for the resource.
	// Each trait has an identifier (the key) and specifies the path to the field within the resource's manifest which should be tracked.
	// A trait's path can either refer to the resource itself (path starts with 'resource.') or to its namespace (if it is namespaced, path starts with 'namespace.').
	// Tracking a trait causes the trait's value to be stored the ResourceUsage record for the resource.
	// If the trait changes, all of its values and the time of the change will be stored in the ResourceUsage record.
	// Note that this can make the ResourceUsage record grow large, so it should only be used for fields which change rarely.
	// +optional
	Traits map[string]Trait `json:"traits,omitempty"`
}

type ResourceUsage struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   ResourceUsageSpec   `json:"spec,omitempty"`
	Status ResourceUsageStatus `json:"status,omitempty"`
}

type ResourceUsageList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []ResourceUsage `json:"items"`
}

type ResourceUsageSpec struct {
	// Resource specifies the resource for which usage is being tracked.
	Resource ResourceReference `json:"resource"`

	// TrackingPeriod specifies the time frame for which this usage record is tracking usage.
	// The start time is inclusive, while the end time is exclusive.
	// The duration should be a multiple of 24 hours.
	// +optional
	TrackingPeriod Timespan `json:"trackingPeriod"`

	// Usage is a list of time periods for which the referenced resource was actually tracked.
	// In most cases, this will just be a single entry spanning the whole TrackingPeriod, but if the resource
	// is deleted (and potentially recreated) or modified to (not) match a selector during the tracking period, there may be multiple entries.
	// This can be expected to be sorted so that the latest - possibly ongoing - tracking period is first.
	// +optional
	Usage Timespans `json:"usage,omitempty"`

	// Traits maps each trait identifier to all values the trait's field has had during the tracking period, along with the duration for which each value was present.
	// +optional
	Traits map[string]TraitUsages `json:"traits,omitempty"`
}

type ResourceUsageStatus struct {
	// Phase specifies whether this usage record is still being tracked or if it has been completed.
	// Must be either 'Ongoing' or 'Completed'.
	// +kubebuilder:validation:Enum=Ongoing;Completed
	Phase string `json:"phase,omitempty"`

	// TotalTrackedDuration specifies the total duration for which the resource was actually tracked during the tracking period.
	// This is the sum of the durations of all entries in Usage.
	// +optional
	TotalTrackedDuration *metav1.Duration `json:"totalTrackedDuration,omitempty"`
}

type Selector struct {
	// ResourceSelector is a label selector for the resource itself. Only resources matching this selector will be tracked.
	// +optional
	ResourceSelector *metav1.LabelSelector `json:"resource,omitempty"`

	// NamespaceSelector allows to restrict the tracked resources to certain namespaces.
	// Namespaces can be selected by their labels, or by their names. Only the names are evaluated if both are specified.
	// DO NOT specify this in case of cluster-scoped resources, as it will cause errors when trying to fetch the namespace of the resource.
	// +optional
	NamespaceSelector *NamespaceSelector `json:"namespace,omitempty"`
}

type Timespan struct {
	// Start specifies the beginning of the time period.
	Start *metav1.Time `json:"start,omitempty"`
	// End specifies the end of the time period.
	End *metav1.Time `json:"end,omitempty"`
}

type Timespans []Timespan

type TrackUntilMode string

type Trait struct {
	// Path is the path to the trait's field within the resource's manifest.
	// It must follow the JSONPath syntax, e.g. "resource.status.ready" or "resource.metadata.labels['foo']",
	// see http://goessner.net/articles/JsonPath/ for more information.
	// Note that the path will automatically be wrapped in curly braces, so it should not include them.
	// +kubebuilder:validation:MinLength=1
	Path string `json:"path"`
}

type TraitUsage struct {
	// Value is the value of the trait at the time of usage.
	// +nullable
	Value apiextensionsv1.JSON `json:"value"`
	// Usage specifies the time periods for which the trait had this value.
	// This can be expected to be sorted so that the latest - possibly ongoing - tracking period is first.
	// +optional
	Usage Timespans `json:"usage,omitempty"`
}

type TraitUsages []TraitUsage

type UsageServiceConfig struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec UsageServiceConfigSpec `json:"spec,omitempty"`
}

type UsageServiceConfigList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []UsageServiceConfig `json:"items"`
}

type UsageServiceConfigSpec struct {
	// GarbageCollection specifies how usage records should be garbage collected.
	// +optional
	GarbageCollection *GarbageCollectionConfig `json:"garbageCollection,omitempty"`

	// ResourcesToTrack specifies for which resources usage should be tracked.
	ResourcesToTrack []ResourceToTrack `json:"resourcesToTrack,omitempty"`
}