v1alpha1

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

	Spec   HarvesterClusterSpec   `json:"spec"`
	Status HarvesterClusterStatus `json:"status,omitempty"`
}

type HarvesterClusterList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`

	Items []HarvesterCluster `json:"items"`
}

type HarvesterClusterSpec struct {
	// Server is the url to connect to Harvester.
	// +optional
	Server string `json:"server,omitempty"`

	// IdentitySecret is the name of the Secret containing HarvesterKubeConfig file.
	IdentitySecret SecretKey `json:"identitySecret"`

	// LoadBalancerConfig describes how the load balancer should be created in Harvester.
	LoadBalancerConfig LoadBalancerConfig `json:"loadBalancerConfig"`

	// ControlPlaneEndpoint represents the endpoint used to communicate with the control plane.
	// +optional
	ControlPlaneEndpoint clusterv1.APIEndpoint `json:"controlPlaneEndpoint,omitempty"`

	// TargetNamespace is the namespace on the Harvester cluster where VMs, Load Balancers, etc. should be created.
	TargetNamespace string `json:"targetNamespace"`

	// UpdateCloudProviderConfig if not empty, will trigger the generation of the cloud provider configuration.
	// It needs a reference to a ConfigMap containing the cloud provider deployment manifests, that are used by a ClusterResourceSet.
	// +optional
	UpdateCloudProviderConfig UpdateCloudProviderConfig `json:"updateCloudProviderConfig,omitempty"`
}

type HarvesterClusterStatus struct {
	// Ready describes if the Harvester Cluster can be considered ready for machine creation.
	// +optional
	Ready bool `json:"ready,omitempty"`

	// FailureReason is the short name for the reason why a failure might be happening that makes the cluster not ready.
	// +optional
	FailureReason string `json:"failureReason,omitempty"`
	// FailureMessage is a full error message dump of the above failureReason.
	// +optional
	FailureMessage string `json:"failureMessage,omitempty"`

	// Conditions defines current service state of the Harvester cluster.
	// +optional
	Conditions clusterv1.Conditions `json:"conditions,omitempty"`
}

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

	// Spec is the specification for the template resource
	Spec HarvesterClusterTemplateSpec `json:"spec,omitempty"`
	// Status is the status of the template HarvesterCluster resource
	Status HarvesterClusterStatus `json:"status,omitempty"`
}

type HarvesterClusterTemplateList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`

	Items []HarvesterClusterTemplate `json:"items"`
}

type HarvesterClusterTemplateResource struct {
	// Standard object's metadata.
	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata.
	// +optional
	ObjectMeta clusterv1.ObjectMeta `json:"metadata,omitempty"`
	Spec       HarvesterClusterSpec `json:"spec"`
}

type HarvesterClusterTemplateSpec struct {
	Template HarvesterClusterTemplateResource `json:"template"`
}

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

	Spec   HarvesterMachineSpec   `json:"spec,omitempty"`
	Status HarvesterMachineStatus `json:"status,omitempty"`
}

type HarvesterMachineList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`

	Items []HarvesterMachine `json:"items"`
}

type HarvesterMachineSpec struct {
	// ProviderID will be the ID of the VM in the provider (Harvester).
	// This is set by the Cloud provider on the Workload cluster node and replicated by CAPI.
	// +optional
	ProviderID string `json:"providerID,omitempty"`

	// FailureDomain defines the zone or failure domain where this VM should be.
	// +optional
	FailureDomain string `json:"failureDomain,omitempty"`

	// CPU is the number of CPU to assign to the VM.
	CPU uint32 `json:"cpu"`

	// Memory is the memory size to assign to the VM (should be similar to pod.spec.containers.resources.limits).
	Memory string `json:"memory"`

	// SSHUser is the user that should be used to connect to the VMs using SSH.
	SSHUser string `json:"sshUser"`

	// SSHKeyPair is the name of the SSH key pair to use for SSH access to the VM (this keyPair should be created in Harvester).
	// The reference can be in the format "namespace/name" or just "name" if the object is in the same namespace as the HarvesterMachine.
	SSHKeyPair string `json:"sshKeyPair"`

	// Volumes is a list of Volumes to attach to the VM
	Volumes []Volume `json:"volumes"`

	// Networks is a list of Networks to attach to the VM.
	// Each item in the list can have the format "namespace/name" or just "name" if the object is in the same namespace as the HarvesterMachine.
	Networks []string `json:"networks"`

	// NodeAffinity gives the possibility to select preferred nodes for VM scheduling on Harvester. This works exactly like Pods.
	// +optional
	NodeAffinity *corev1.NodeAffinity `json:"nodeAffinity,omitempty"`

	// WorkloadAffinity gives the possibility to define affinity rules with other workloads running on Harvester.
	// +optional
	WorkloadAffinity *corev1.PodAffinity `json:"workloadAffinity,omitempty"`
}

type HarvesterMachineStatus struct {
	// Ready is true when the provider resource is ready.
	Ready bool `json:"ready,omitempty"`

	Conditions []clusterv1.Condition `json:"conditions,omitempty"`

	FailureReason  string                     `json:"failureReason,omitempty"`
	FailureMessage string                     `json:"failureMessage,omitempty"`
	Addresses      []clusterv1.MachineAddress `json:"addresses,omitempty"`
	Initialization Initialization             `json:"initialization,omitempty"`
}

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

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

type HarvesterMachineTemplateList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`

	Items []HarvesterMachineTemplate `json:"items"`
}

type HarvesterMachineTemplateResource struct {
	// Spec is the specification of the desired behavior of the machine.
	Spec HarvesterMachineSpec `json:"spec"`
}

type HarvesterMachineTemplateSpec struct {
	// Template is the HarvesterMachineTemplate template
	Template HarvesterMachineTemplateResource `json:"template,omitempty"`
}

type IPAMType string

type Initialization struct {
	// Provisioned shows if the VM has been provisioned.
	Provisioned bool `json:"provisioned,omitempty"`
}

type IpPool struct {
	// VMNetwork is the name of an existing VM Network in Harvester where the IPPool should exist.
	// The reference can have the format "namespace/name" or just "name" if the object is in the same namespace as the HarvesterCluster.
	VMNetwork string `json:"vmNetwork"`

	// Subnet is a string describing the subnet that should be used by the IP Pool, it should have the CIDR Format of an IPv4 Address.
	// e.g. 172.17.1.0/24.
	Subnet string `json:"subnet"`

	// Gateway is the IP Address that should be used by the Gateway on the Subnet. It should be a valid address inside the subnet.
	// e.g. 172.17.1.1.
	Gateway string `json:"gateway"`

	// RangeStart is the first IP Address that should be used by the IP Pool.
	// + optional
	RangeStart string `json:"rangeStart,omitempty"`

	// RangeEnd is the last IP Address that should be used by the IP Pool.
	// + optional
	RangeEnd string `json:"rangeEnd,omitempty"`
}

type Listener struct {
	// Name is the name of the listener.
	Name string `json:"name"`

	// Port is the port that the listener should listen on.
	Port int32 `json:"port"`

	// Protocol is the protocol that the listener should use, either TCP or UDP.
	// +kubebuilder:validation:Enum:=TCP;UDP
	Protocol corev1.Protocol `json:"protocol"`

	// TargetPort is the port that the listener should forward traffic to.
	BackendPort int32 `json:"backendPort"`
}

type LoadBalancerConfig struct {
	// IPAMType is the configuration of IP addressing for the control plane load balancer.
	// This can take two values, either "dhcp" or "ippool".
	IPAMType IPAMType `json:"ipamType"`

	// IpPoolRef is a reference to an existing IpPool object in Harvester's cluster.
	// This field is mutually exclusive with "ipPool".
	IpPoolRef string `json:"ipPoolRef,omitempty"`

	// IpPool defines a new IpPool that will be added to Harvester.
	// This field is mutually exclusive with "IpPoolRef".
	IpPool IpPool `json:"ipPool,omitempty"`

	// Listeners is a list of listeners that should be created on the load balancer.
	// +optional
	Listeners []Listener `json:"listeners,omitempty"`

	// Description is a description of the load balancer that should be created.
	// +optional
	Description string `json:"description,omitempty"`
}

type SecretKey struct {
	// Namespace is the namespace in which the required Identity Secret should be found.
	Namespace string `json:"namespace"`

	// Name is the name of the required Identity Secret.
	Name string `json:"name"`
}

type UpdateCloudProviderConfig struct {
	// ManifestsConfigMapNamespace is the namespace in which the required ConfigMap should be found.
	ManifestsConfigMapNamespace string `json:"manifestsConfigMapNamespace"`

	// ManifestsConfigMapName is the name of the required ConfigMap.
	ManifestsConfigMapName string `json:"manifestsConfigMapName"`

	// ManifestsConfigMapKey is the key in the ConfigMap that contains the cloud provider deployment manifests.
	ManifestsConfigMapKey string `json:"manifestsConfigMapKey"`

	// CloudConfigCredentialsSecretName is the name of the secret containing the cloud provider credentials.
	CloudConfigCredentialsSecretName string `json:"cloudConfigCredentialsSecretName"`

	// CloudConfigCredentialsSecretKey is the key in the secret that contains the cloud provider credentials.
	CloudConfigCredentialsSecretKey string `json:"cloudConfigCredentialsSecretKey"`
}

type Volume struct {
	// VolumeType is the type of volume to attach.
	// Choose between: "storageClass" or "image"
	VolumeType VolumeType `json:"volumeType"`

	// ImageName is the name of the image to use if the volumeType is "image"
	// ImageName can be in the format "namespace/name" or just "name" if the object is in the same namespace as the HarvesterMachine.
	// +optional
	ImageName string `json:"imageName,omitempty"`

	// StorageClass is the name of the storage class to be used if the volumeType is "storageClass"
	StorageClass string `json:"storageClass,omitempty"`

	// VolumeSize is the desired size of the volume. This satisfies to standard Kubernetes *resource.Quantity syntax.
	// Examples: 40.5Gi, 30M, etc. are valid
	// +optional
	VolumeSize *resource.Quantity `json:"volumeSize,omitempty"`

	// BootOrder is an integer that determines the order of priority of volumes for booting the VM.
	// If absent, the sequence with which volumes appear in the manifest will be used.
	// +optional
	BootOrder int `json:"bootOrder,omitempty"`
}

type VolumeType string