v1alpha1

type BucketSource struct {
	// name is the name of the S3-compatible bucket
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:MinLength=1
	Name string `json:"name"`

	// prefix is an optional path prefix within the bucket (e.g., "input-data/")
	// +optional
	Prefix string `json:"prefix,omitempty"`

	// endpoint is the S3-compatible endpoint URL (required for non-AWS S3)
	// Examples:
	//   - MinIO: "http://minio.example.com:9000"
	//   - GCS: "https://storage.googleapis.com"
	//   - Custom S3: "https://s3.custom.example.com"
	// Leave empty for AWS S3 (will use default AWS endpoints)
	// +optional
	Endpoint string `json:"endpoint,omitempty"`

	// region is the bucket region (e.g., "us-east-1")
	// Required for AWS S3, optional for other providers
	// +optional
	Region string `json:"region,omitempty"`

	// credentialsSecret references a Secret containing access credentials
	// Expected keys: "accessKeyId" and "secretAccessKey"
	// +optional
	CredentialsSecret *SecretReference `json:"credentialsSecret,omitempty"`

	// insecureSkipTLSVerify skips TLS certificate verification (useful for dev/test)
	// +optional
	// +kubebuilder:default=false
	InsecureSkipTLSVerify bool `json:"insecureSkipTLSVerify,omitempty"`

	// usePathStyle forces path-style addressing (endpoint.com/bucket vs bucket.endpoint.com)
	// Required for MinIO and some S3-compatible services
	// +optional
	// +kubebuilder:default=false
	UsePathStyle bool `json:"usePathStyle,omitempty"`
}

type ConfigVar struct {
	// name is the configuration key (will be prefixed with FILTER_ and uppercased)
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:MinLength=1
	Name string `json:"name"`

	// value is the configuration value
	// +kubebuilder:validation:Required
	Value string `json:"value"`
}

type ExecutionConfig struct {
	// parallelism defines the maximum number of parallel executions (max concurrent pods)
	// +optional
	// +kubebuilder:validation:Minimum=1
	// +kubebuilder:default=10
	Parallelism *int32 `json:"parallelism,omitempty"`

	// maxAttempts defines the maximum number of retry attempts per file
	// +optional
	// +kubebuilder:validation:Minimum=1
	// +kubebuilder:default=3
	MaxAttempts *int32 `json:"maxAttempts,omitempty"`

	// pendingTimeout defines the time after which pending messages are reclaimed
	// Supports Kubernetes duration format (e.g., "15m", "1h", "30s")
	// +optional
	// +kubebuilder:default="15m"
	PendingTimeout *metav1.Duration `json:"pendingTimeout,omitempty"`
}

type FileCounts struct {
	// totalFiles is the total number of files to process
	// +optional
	TotalFiles int64 `json:"totalFiles,omitempty"`

	// queued is the number of files waiting to be processed
	// +optional
	Queued int64 `json:"queued,omitempty"`

	// running is the number of files currently being processed
	// +optional
	Running int64 `json:"running,omitempty"`

	// succeeded is the number of files successfully processed
	// +optional
	Succeeded int64 `json:"succeeded,omitempty"`

	// failed is the number of files that failed processing
	// +optional
	Failed int64 `json:"failed,omitempty"`
}

type Filter struct {
	// name is a unique identifier for this filter within the pipeline
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:MinLength=1
	// +kubebuilder:validation:Pattern=`^[a-z0-9]([-a-z0-9]*[a-z0-9])?$`
	Name string `json:"name"`

	// image is the container image to run (e.g., "myregistry/filter:v1.0")
	// +kubebuilder:validation:Required
	Image string `json:"image"`

	// config is a list of configuration key-value pairs that will be injected
	// as environment variables with the FILTER_ prefix.
	// For example, a config with name "sources" and value "mysource" will result
	// in the environment variable FILTER_SOURCES=mysource
	// +optional
	Config []ConfigVar `json:"config,omitempty"`

	// env is a list of environment variables to set in the container
	// Uses the standard Kubernetes EnvVar type for full compatibility
	// +optional
	Env []corev1.EnvVar `json:"env,omitempty"`

	// args are the command arguments to pass to the container
	// +optional
	Args []string `json:"args,omitempty"`

	// command overrides the default entrypoint of the container
	// +optional
	Command []string `json:"command,omitempty"`

	// resources defines compute resource requirements for this filter
	// +optional
	Resources *corev1.ResourceRequirements `json:"resources,omitempty"`

	// imagePullPolicy determines when to pull the container image
	// +optional
	// +kubebuilder:validation:Enum=Always;Never;IfNotPresent
	// +kubebuilder:default=IfNotPresent
	ImagePullPolicy corev1.PullPolicy `json:"imagePullPolicy,omitempty"`
}

type Pipeline struct {
	metav1.TypeMeta `json:",inline"`

	// metadata is a standard object metadata
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// spec defines the desired state of Pipeline
	// +required
	Spec PipelineSpec `json:"spec"`

	// status defines the observed state of Pipeline
	// +optional
	Status PipelineStatus `json:"status,omitempty"`
}

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

type PipelineMode string

type PipelineReference struct {
	// name is the name of the Pipeline resource
	// +required
	Name string `json:"name"`

	// namespace is the namespace of the Pipeline resource
	// If not specified, the PipelineRun's namespace is used
	// +optional
	Namespace *string `json:"namespace,omitempty"`
}

type PipelineRun struct {
	metav1.TypeMeta `json:",inline"`

	// metadata is a standard object metadata
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// spec defines the desired state of PipelineRun
	// +required
	Spec PipelineRunSpec `json:"spec"`

	// status defines the observed state of PipelineRun
	// +optional
	Status PipelineRunStatus `json:"status,omitempty"`
}

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

type PipelineRunSpec struct {

	// pipelineRef references the Pipeline resource to execute
	// +required
	PipelineRef PipelineReference `json:"pipelineRef"`

	// execution defines how the pipeline should be executed
	// +optional
	Execution *ExecutionConfig `json:"execution,omitempty"`
}

type PipelineRunStatus struct {

	// counts tracks the number of files in each state (Batch mode only)
	// +optional
	Counts *FileCounts `json:"counts,omitempty"`

	// jobName is the name of the Kubernetes Job created for this run (Batch mode only)
	// +optional
	JobName string `json:"jobName,omitempty"`

	// streaming provides observability into streaming pipeline runs (Stream mode only)
	// +optional
	Streaming *StreamingStatus `json:"streaming,omitempty"`

	// startTime is when the pipeline run was started
	// +optional
	StartTime *metav1.Time `json:"startTime,omitempty"`

	// completionTime is when the pipeline run completed
	// +optional
	CompletionTime *metav1.Time `json:"completionTime,omitempty"`

	// conditions represent the current state of the PipelineRun resource.
	// Each condition has a unique type and reflects the status of a specific aspect of the resource.
	//
	// Standard condition types include:
	// - "Available": the resource is fully functional
	// - "Progressing": the resource is being created or updated
	// - "Degraded": the resource failed to reach or maintain its desired state
	//
	// The status of each condition is one of True, False, or Unknown.
	// +listType=map
	// +listMapKey=type
	// +optional
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

type PipelineSpec struct {

	// mode defines the execution mode for this pipeline (batch or stream)
	// batch mode processes files from S3 using Kubernetes Jobs
	// stream mode processes RTSP streams using Kubernetes Deployments
	// +optional
	// +kubebuilder:default=batch
	Mode PipelineMode `json:"mode,omitempty"`

	// source defines the input source for the pipeline
	// For Batch mode: source.bucket is required, source.rtsp is forbidden
	// For Stream mode: source.rtsp is required, source.bucket is forbidden
	// +kubebuilder:validation:Required
	Source Source `json:"source"`

	// filters is an ordered list of processing steps to apply to the input data
	// Filters are executed sequentially in the order they are defined
	// +optional
	// +kubebuilder:validation:MinItems=1
	Filters []Filter `json:"filters,omitempty"`

	// services defines Kubernetes Services to expose filter ports
	// Only applies to Stream mode. Multiple services can expose different ports for the same filter.
	// Service naming: <pipelinerun-name>-<filter-name>-<index>
	// +optional
	Services []ServicePort `json:"services,omitempty"`

	// videoInputPath defines where the controller stores downloaded source files.
	// Downstream filters can reference this path to read the input artifact.
	// Defaults to /ws/input.mp4.
	// Only applies to Batch mode.
	// +kubebuilder:validation:Optional
	// +kubebuilder:validation:MinLength=1
	// +kubebuilder:default=/ws/input.mp4
	VideoInputPath string `json:"videoInputPath,omitempty"`
}

type PipelineStatus struct {

	// conditions represent the current state of the Pipeline resource.
	// Each condition has a unique type and reflects the status of a specific aspect of the resource.
	//
	// Standard condition types include:
	// - "Available": the resource is fully functional
	// - "Progressing": the resource is being created or updated
	// - "Degraded": the resource failed to reach or maintain its desired state
	//
	// The status of each condition is one of True, False, or Unknown.
	// +listType=map
	// +listMapKey=type
	// +optional
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

type RTSPSource struct {
	// host is the RTSP server hostname or IP address
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:MinLength=1
	Host string `json:"host"`

	// port is the RTSP server port
	// +optional
	// +kubebuilder:default=554
	// +kubebuilder:validation:Minimum=1
	// +kubebuilder:validation:Maximum=65535
	Port int32 `json:"port,omitempty"`

	// path is the RTSP stream path (e.g., "/stream1", "/live/camera1")
	// +optional
	Path string `json:"path,omitempty"`

	// credentialsSecret references a Secret containing RTSP credentials
	// Expected keys: "username" and "password"
	// +optional
	CredentialsSecret *SecretReference `json:"credentialsSecret,omitempty"`

	// idleTimeout defines the duration after which a continuously unready stream
	// will cause the PipelineRun to complete and the Deployment to be deleted.
	// If not set, the stream will run indefinitely.
	// +optional
	IdleTimeout *metav1.Duration `json:"idleTimeout,omitempty"`
}

type SecretReference struct {
	// name is the name of the secret
	// +kubebuilder:validation:Required
	Name string `json:"name"`

	// namespace is the namespace of the secret
	// If empty, uses the same namespace as the Pipeline resource
	// +optional
	Namespace string `json:"namespace,omitempty"`
}

type ServicePort struct {
	// name is the name of the filter to expose
	// Must match one of the filter names in the pipeline
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:MinLength=1
	Name string `json:"name"`

	// port is the port number to expose
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:Minimum=1
	// +kubebuilder:validation:Maximum=65535
	Port int32 `json:"port"`

	// targetPort is the port on the container to forward to
	// If not specified, defaults to the same value as port
	// +optional
	// +kubebuilder:validation:Minimum=1
	// +kubebuilder:validation:Maximum=65535
	TargetPort *int32 `json:"targetPort,omitempty"`

	// protocol is the network protocol for this port (TCP or UDP)
	// +optional
	// +kubebuilder:default=TCP
	// +kubebuilder:validation:Enum=TCP;UDP
	Protocol corev1.Protocol `json:"protocol,omitempty"`
}

type Source struct {
	// bucket defines an S3-compatible object storage source
	// Required when mode is Batch, forbidden when mode is Stream
	// +optional
	Bucket *BucketSource `json:"bucket,omitempty"`

	// rtsp defines an RTSP stream source
	// Required when mode is Stream, forbidden when mode is Batch
	// +optional
	RTSP *RTSPSource `json:"rtsp,omitempty"`
}

type StreamingStatus struct {
	// readyReplicas is the number of ready replicas in the streaming deployment
	// +optional
	ReadyReplicas int32 `json:"readyReplicas,omitempty"`

	// updatedReplicas is the number of updated replicas in the streaming deployment
	// +optional
	UpdatedReplicas int32 `json:"updatedReplicas,omitempty"`

	// availableReplicas is the number of available replicas in the streaming deployment
	// +optional
	AvailableReplicas int32 `json:"availableReplicas,omitempty"`

	// containerRestarts is the aggregate count of container restarts across all pods
	// +optional
	ContainerRestarts int32 `json:"containerRestarts,omitempty"`

	// lastReadyTime is the last time the deployment became ready
	// +optional
	LastReadyTime *metav1.Time `json:"lastReadyTime,omitempty"`

	// lastFrameAt is the timestamp of the last processed frame (best-effort)
	// +optional
	LastFrameAt *metav1.Time `json:"lastFrameAt,omitempty"`

	// deploymentName is the name of the Kubernetes Deployment created for this streaming run
	// +optional
	DeploymentName string `json:"deploymentName,omitempty"`
}