v1alpha2

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

	Spec   LXCClusterSpec   `json:"spec,omitempty"`
	Status LXCClusterStatus `json:"status,omitempty"`
}

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

type LXCClusterLoadBalancer struct {
	// LXC will spin up a plain Ubuntu instance with haproxy installed.
	//
	// The controller will automatically update the list of backends on the haproxy configuration as control plane nodes are added or removed from the cluster.
	//
	// No other configuration is required for "lxc" mode. The load balancer instance can be configured through the .instanceSpec field.
	//
	// The load balancer container is a single point of failure to access the workload cluster control plane. Therefore, it should only be used for development or evaluation clusters.
	//
	// +optional
	LXC *LXCLoadBalancerInstance `json:"lxc,omitempty"`

	// OCI will spin up an OCI instance running the kindest/haproxy image.
	//
	// The controller will automatically update the list of backends on the haproxy configuration as control plane nodes are added or removed from the cluster.
	//
	// No other configuration is required for "oci" mode. The load balancer instance can be configured through the .instanceSpec field.
	//
	// The load balancer container is a single point of failure to access the workload cluster control plane. Therefore, it should only be used for development or evaluation clusters.
	//
	// Requires server extensions: "instance_oci"
	//
	// +optional
	OCI *LXCLoadBalancerInstance `json:"oci,omitempty"`

	// OVN will create a network load balancer.
	//
	// The controller will automatically update the list of backends for the network load balancer as control plane nodes are added or removed from the cluster.
	//
	// The cluster administrator is responsible to ensure that the OVN network is configured properly and that the LXCMachineTemplate objects have appropriate profiles to use the OVN network.
	//
	// When using the "ovn" mode, the load balancer address must be set in `.spec.controlPlaneEndpoint.host` on the LXCCluster object.
	//
	// Requires server extensions: "network_load_balancer", "network_load_balancer_health_checks"
	//
	// +optional
	OVN *LXCLoadBalancerOVN `json:"ovn,omitempty"`

	// External will not create a load balancer. It must be used alongside something like kube-vip, otherwise the cluster will fail to provision.
	//
	// When using the "external" mode, the load balancer address must be set in `.spec.controlPlaneEndpoint.host` on the LXCCluster object.
	//
	// +optional
	External *LXCLoadBalancerExternal `json:"external,omitempty"`
}

type LXCClusterSpec struct {
	// ControlPlaneEndpoint represents the endpoint to communicate with the control plane.
	ControlPlaneEndpoint clusterv1.APIEndpoint `json:"controlPlaneEndpoint,omitempty"`

	// SecretRef references a secret with credentials to access the LXC (e.g. Incus, LXD) server.
	SecretRef SecretRef `json:"secretRef,omitempty"`

	// LoadBalancer is configuration for provisioning the load balancer of the cluster.
	LoadBalancer LXCClusterLoadBalancer `json:"loadBalancer"`

	// Unprivileged will launch unprivileged LXC containers for the cluster machines.
	//
	// Known limitations apply for unprivileged LXC containers (e.g. cannot use NFS volumes).
	//
	// +optional
	Unprivileged bool `json:"unprivileged"`

	// Do not apply the default kubeadm profile on container instances.
	//
	// In this case, the cluster administrator is responsible to create the
	// profile manually and set the `.spec.template.spec.profiles` field of all
	// LXCMachineTemplate objects.
	//
	// For more details on the default kubeadm profile that is applied, see
	// https://lxc.github.io/cluster-api-provider-incus/reference/profile/kubeadm.html
	//
	// +optional
	SkipDefaultKubeadmProfile bool `json:"skipDefaultKubeadmProfile"`
}

type LXCClusterStatus struct {
	// Ready denotes that the LXC cluster (infrastructure) is ready.
	//
	// +optional
	Ready bool `json:"ready"`

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

	// V1Beta2 groups all status fields that will be added in LXCCluster's status with the v1beta2 version.
	//
	// +optional
	V1Beta2 *LXCClusterV1Beta2Status `json:"v1beta2,omitempty"`
}

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

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

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

type LXCClusterTemplateResource 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       LXCClusterSpec       `json:"spec"`
}

type LXCClusterTemplateSpec struct {
	Template LXCClusterTemplateResource `json:"template"`
}

type LXCClusterV1Beta2Status struct {
	// conditions represents the observations of a LXCCluster's current state.
	// Known condition types are Ready, LoadBalancerAvailable, Deleting, Paused.
	// +optional
	// +listType=map
	// +listMapKey=type
	// +kubebuilder:validation:MaxItems=32
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

type LXCLoadBalancerExternal struct {
}

type LXCLoadBalancerInstance struct {
	// InstanceSpec can be used to adjust the load balancer instance configuration.
	//
	// +optional
	InstanceSpec LXCLoadBalancerMachineSpec `json:"instanceSpec,omitempty"`
}

type LXCLoadBalancerMachineSpec struct {
	// Flavor is configuration for the instance size (e.g. t3.micro, or c2-m4).
	//
	// Examples:
	//
	//   - `t3.micro` -- match specs of an EC2 t3.micro instance
	//   - `c2-m4` -- 2 cores, 4 GB RAM
	//
	// +optional
	Flavor string `json:"flavor,omitempty"`

	// Profiles is a list of profiles to attach to the instance.
	//
	// +optional
	Profiles []string `json:"profiles,omitempty"`

	// Image to use for provisioning the load balancer machine. If not set,
	// a default image based on the load balancer type will be used.
	//
	//   - "oci": ghcr.io/neoaggelos/cluster-api-provider-lxc/haproxy:v0.0.1
	//   - "lxc": haproxy from the default simplestreams server
	//
	// +optional
	Image LXCMachineImageSource `json:"image"`
}

type LXCLoadBalancerOVN struct {
	// NetworkName is the name of the network to create the load balancer.
	NetworkName string `json:"networkName,omitempty"`
}

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

	Spec   LXCMachineSpec   `json:"spec,omitempty"`
	Status LXCMachineStatus `json:"status,omitempty"`
}

type LXCMachineImageSource struct {
	// Name is the image name or alias.
	//
	// Note that Incus and Canonical LXD use incompatible image servers
	// for Ubuntu images. To address this issue, setting image name to
	// `ubuntu:VERSION` is a shortcut for:
	//
	//   - Incus: "images:ubuntu/VERSION/cloud" (from https://images.linuxcontainers.org)
	//   - LXD: "ubuntu:VERSION" (from https://cloud-images.ubuntu.com/releases)
	//
	// +optional
	Name string `json:"name"`

	// Fingerprint is the image fingerprint.
	//
	// +optional
	Fingerprint string `json:"fingerprint"`

	// Server is the remote server, e.g. "https://images.linuxcontainers.org"
	//
	// +optional
	Server string `json:"server,omitempty"`

	// Protocol is the protocol to use for fetching the image, e.g. "simplestreams".
	//
	// +optional
	Protocol string `json:"protocol,omitempty"`
}

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

type LXCMachineSpec struct {
	// ProviderID is the container name in ProviderID format (lxc:///<containername>).
	//
	// +optional
	ProviderID *string `json:"providerID,omitempty"`

	// InstanceType is "container" or "virtual-machine". Empty defaults to "container".
	//
	// +kubebuilder:validation:Enum:=container;virtual-machine;""
	// +optional
	InstanceType string `json:"instanceType,omitempty"`

	// Flavor is configuration for the instance size (e.g. t3.micro, or c2-m4).
	//
	// Examples:
	//
	//   - `t3.micro` -- match specs of an EC2 t3.micro instance
	//   - `c2-m4` -- 2 cores, 4 GB RAM
	//
	// +optional
	Flavor string `json:"flavor,omitempty"`

	// Profiles is a list of profiles to attach to the instance.
	//
	// +optional
	Profiles []string `json:"profiles,omitempty"`

	// Devices allows overriding the configuration of the instance disk or network.
	//
	// Device configuration must be formatted using the syntax "<device>,<key>=<value>".
	//
	// For example, to specify a different network for an instance, you can use:
	//
	// “`yaml
	//   # override device "eth0", to be of type "nic" and use network "my-network"
	//   devices:
	//   - eth0,type=nic,network=my-network
	// “`
	//
	// +optional
	Devices []string `json:"devices,omitempty"`

	// Config allows overriding instance configuration keys.
	//
	// Note that the provider will always set the following configuration keys:
	//
	// - "cloud-init.user-data": cloud-init config data
	// - "user.cluster-name": name of owning cluster
	// - "user.cluster-namespace": namespace of owning cluster
	// - "user.cluster-role": instance role (e.g. control-plane, worker)
	// - "user.machine-name": name of machine (should match instance hostname)
	//
	// See https://linuxcontainers.org/incus/docs/main/reference/instance_options/#instance-options
	// for details.
	//
	// +optional
	Config map[string]string `json:"config,omitempty"`

	// Image to use for provisioning the machine. If not set, a kubeadm image
	// from the default upstream simplestreams source will be used, based on
	// the version of the machine.
	//
	// Note that the default source does not support images for all Kubernetes
	// versions, refer to the documentation for more details on which versions
	// are supported and how to build a base image for any version.
	//
	// +optional
	Image LXCMachineImageSource `json:"image"`
}

type LXCMachineStatus struct {
	// Ready denotes that the LXC machine is ready.
	//
	// +optional
	Ready bool `json:"ready,omitempty"`

	// LoadBalancerConfigured will be set to true once for each control plane node, after the load balancer instance is reconfigured.
	//
	// +optional
	LoadBalancerConfigured bool `json:"loadBalancerConfigured,omitempty"`

	// Addresses is the list of addresses of the LXC machine.
	//
	// +optional
	Addresses []clusterv1.MachineAddress `json:"addresses"`

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

	// V1Beta2 groups all status fields that will be added in LXCMachine's status with the v1beta2 version.
	//
	// +optional
	V1Beta2 *LXCMachineV1Beta2Status `json:"v1beta2,omitempty"`
}

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

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

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

type LXCMachineTemplateResource 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 is the specification of the desired behavior of the machine.
	Spec LXCMachineSpec `json:"spec"`
}

type LXCMachineTemplateSpec struct {
	Template LXCMachineTemplateResource `json:"template"`
}

type LXCMachineV1Beta2Status struct {
	// conditions represents the observations of a LXCMachine's current state.
	// Known condition types are Ready, InstanceProvisioned, Deleting, Paused.
	// +optional
	// +listType=map
	// +listMapKey=type
	// +kubebuilder:validation:MaxItems=32
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

type SecretRef struct {
	// Name is the name of the secret to use. The secret must already exist in the same namespace as the parent object.
	Name string `json:"name"`
}