v1alpha1

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

	Spec   SBDConfigSpec   `json:"spec,omitempty"`
	Status SBDConfigStatus `json:"status,omitempty"`
}

type SBDConfigConditionType string

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

type SBDConfigSpec struct {

	// SbdWatchdogPath is the path to the watchdog device on the host
	// If not specified, defaults to "/dev/watchdog"
	// +kubebuilder:default="/dev/watchdog"
	// +optional
	SbdWatchdogPath string `json:"sbdWatchdogPath,omitempty"`

	// Image is the container image for the SBD agent DaemonSet
	// If not specified, defaults to sbd-agent from the same registry/org/tag as the operator
	// +optional
	Image string `json:"image,omitempty"`

	// ImagePullPolicy defines the pull policy for the SBD agent container image.
	// Valid values are Always, Never, and IfNotPresent.
	// Defaults to IfNotPresent for production stability.
	// +kubebuilder:validation:Enum=Always;Never;IfNotPresent
	// +kubebuilder:default="IfNotPresent"
	// +optional
	ImagePullPolicy string `json:"imagePullPolicy,omitempty"`

	// SharedStorageClass is the name of a StorageClass to use for creating shared storage.
	// When specified, the controller will create a PVC using this StorageClass and mount it
	// in the agent DaemonSet for cross-node coordination, slot assignment, and shared configuration data.
	// The StorageClass must support ReadWriteMany (RWX) access mode.
	// +optional
	SharedStorageClass string `json:"sharedStorageClass,omitempty"`

	// NodeSelector is a selector which must be true for the SBD agent pod to fit on a node.
	// This allows users to control which nodes the SBD agent runs on by specifying node labels.
	// If not specified, defaults to worker nodes only (node-role.kubernetes.io/worker: "").
	// The selector is merged with the default requirement for kubernetes.io/os=linux.
	// +optional
	NodeSelector map[string]string `json:"nodeSelector,omitempty"`

	// StaleNodeTimeout defines how long to wait before considering a node stale and removing it from slot mapping
	// This timeout determines when inactive nodes are cleaned up from the shared SBD device slot assignments.
	// Nodes that haven't updated their heartbeat within this duration will be considered stale and their slots
	// will be freed for reuse by new nodes. The value must be at least 1 minute.
	// +kubebuilder:validation:Type=string
	// +kubebuilder:validation:Pattern="^([0-9]+(\\.[0-9]+)?(s|m|h))+$"
	// +kubebuilder:default="1h"
	// +optional
	StaleNodeTimeout *metav1.Duration `json:"staleNodeTimeout,omitempty"`

	// WatchdogTimeout defines the watchdog timeout duration for the hardware/software watchdog device.
	// This determines how long the system will wait before triggering a reboot if the watchdog is not pet.
	// The pet interval is calculated as watchdog timeout divided by the pet interval multiple.
	// The value must be between 10 seconds and 300 seconds (5 minutes).
	// +kubebuilder:validation:Type=string
	// +kubebuilder:validation:Pattern="^([0-9]+(\\.[0-9]+)?(s|m|h))+$"
	// +kubebuilder:default="60s"
	// +optional
	WatchdogTimeout *metav1.Duration `json:"watchdogTimeout,omitempty"`

	// PetIntervalMultiple defines the multiple used to calculate the pet interval from the watchdog timeout.
	// Pet interval = watchdog timeout / pet interval multiple.
	// This ensures the pet interval is always shorter than the watchdog timeout with a safety margin.
	// The value must be between 3.0 and 20.0, with 4.0 providing a good balance of safety and efficiency.
	// +kubebuilder:validation:Minimum=3
	// +kubebuilder:validation:Maximum=20
	// +kubebuilder:default=4
	// +optional
	PetIntervalMultiple *int32 `json:"petIntervalMultiple,omitempty"`

	// LogLevel defines the logging level for the SBD agent pods.
	// Valid values are debug, info, warn, and error.
	// Debug provides the most verbose logging, while error only logs error messages.
	// +kubebuilder:validation:Enum=debug;info;warn;error
	// +kubebuilder:default="info"
	// +optional
	LogLevel string `json:"logLevel,omitempty"`

	// IOTimeout defines the timeout for SBD I/O operations.
	// This determines how long the system will wait for SBD I/O operations to complete.
	// The value must be between 100 milliseconds and 5 minutes.
	// +kubebuilder:validation:Type=string
	// +kubebuilder:validation:Pattern="^([0-9]+(\\.[0-9]+)?(ms|s|m|h))+$"
	// +kubebuilder:default="2s"
	// +optional
	IOTimeout *metav1.Duration `json:"iotimeout,omitempty"`

	// RebootMethod defines the method to use for self-fencing when a node needs to be rebooted.
	// Valid values are "panic" (immediate kernel panic), "systemctl-reboot" (graceful systemctl reboot),
	// and "none" (disable self-fencing, rely only on watchdog hardware timeout).
	// Panic provides the fastest failover but less graceful shutdown, while systemctl-reboot allows
	// for graceful service shutdown but may be slower. The "none" option disables agent-initiated
	// self-fencing and relies solely on hardware watchdog timeout for node fencing.
	// +kubebuilder:validation:Enum=panic;systemctl-reboot;none
	// +kubebuilder:default="panic"
	// +optional
	RebootMethod string `json:"rebootMethod,omitempty"`

	// SBDTimeoutSeconds defines the SBD timeout in seconds, which determines the heartbeat interval.
	// The heartbeat interval is calculated as SBD timeout divided by 2.
	// This value controls how quickly the cluster can detect and respond to node failures.
	// The value must be between 10 and 300 seconds.
	// +kubebuilder:validation:Minimum=10
	// +kubebuilder:validation:Maximum=300
	// +kubebuilder:default=30
	// +optional
	SBDTimeoutSeconds *int32 `json:"sbdTimeoutSeconds,omitempty"`

	// SBDUpdateInterval defines the interval for updating the SBD device with node status information.
	// This determines how frequently each node writes its status to the shared SBD device.
	// More frequent updates provide faster failure detection but increase I/O load on the shared storage.
	// The value must be between 1 second and 60 seconds.
	// +kubebuilder:validation:Type=string
	// +kubebuilder:validation:Pattern="^([0-9]+(\\.[0-9]+)?(s|m))+$"
	// +kubebuilder:default="5s"
	// +optional
	SBDUpdateInterval *metav1.Duration `json:"sbdUpdateInterval,omitempty"`

	// PeerCheckInterval defines the interval for checking peer node heartbeats in the SBD device.
	// This determines how frequently each node reads and processes heartbeats from other nodes.
	// More frequent checks provide faster peer failure detection but increase I/O load on the shared storage.
	// The value must be between 1 second and 60 seconds.
	// +kubebuilder:validation:Type=string
	// +kubebuilder:validation:Pattern="^([0-9]+(\\.[0-9]+)?(s|m))+$"
	// +kubebuilder:default="5s"
	// +optional
	PeerCheckInterval *metav1.Duration `json:"peerCheckInterval,omitempty"`
}

type SBDConfigStatus struct {

	// Conditions represent the latest available observations of the SBDConfig's current state
	// +patchMergeKey=type
	// +patchStrategy=merge
	// +listType=map
	// +listMapKey=type
	Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type"`

	// ReadyNodes is the number of nodes where the SBD agent is ready
	ReadyNodes int32 `json:"readyNodes,omitempty"`

	// TotalNodes is the total number of nodes where the SBD agent should be deployed
	TotalNodes int32 `json:"totalNodes,omitempty"`
}

type SBDConfigValidator struct{}

type SBDRemediationConditionType string

type SBDRemediationReason string

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

	Spec   StorageBasedRemediationSpec   `json:"spec,omitempty"`
	Status StorageBasedRemediationStatus `json:"status,omitempty"`
}

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

type StorageBasedRemediationSpec struct {
	// Reason specifies why this node needs to be fenced
	// +kubebuilder:validation:Enum=HeartbeatTimeout;NodeUnresponsive;ManualFencing
	// +kubebuilder:default=NodeUnresponsive
	Reason SBDRemediationReason `json:"reason,omitempty"`

	// TimeoutSeconds specifies how long to wait before considering the fencing failed
	// +kubebuilder:validation:Minimum=30
	// +kubebuilder:validation:Maximum=300
	// +kubebuilder:default=60
	TimeoutSeconds int32 `json:"timeoutSeconds,omitempty"`
}

type StorageBasedRemediationStatus struct {
	// Conditions represent the latest available observations of the remediation's current state
	// +patchMergeKey=type
	// +patchStrategy=merge
	// +listType=map
	// +listMapKey=type
	Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type"`

	// LastUpdateTime is the time when this status was last updated
	LastUpdateTime *metav1.Time `json:"lastUpdateTime,omitempty"`

	// NodeID is the numeric ID assigned to the target node for SBD operations
	NodeID *uint16 `json:"nodeID,omitempty"`

	// FenceMessageWritten indicates if the fence message was successfully written to the SBD device
	FenceMessageWritten bool `json:"fenceMessageWritten,omitempty"`

	// OperatorInstance identifies which operator instance is handling this remediation
	OperatorInstance string `json:"operatorInstance,omitempty"`
}

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

	Spec   StorageBasedRemediationTemplateSpec   `json:"spec,omitempty"`
	Status StorageBasedRemediationTemplateStatus `json:"status,omitempty"`
}

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

type StorageBasedRemediationTemplateResource struct {
	Spec StorageBasedRemediationSpec `json:"spec"`
}

type StorageBasedRemediationTemplateSpec struct {

	// Template defines the desired state of StorageBasedRemediationTemplate
	// +operator-sdk:csv:customresourcedefinitions:type=spec
	Template StorageBasedRemediationTemplateResource `json:"template"`
}

type StorageBasedRemediationTemplateStatus struct {
}