// CommonOps are the options common across all the providers.
type CommonOps struct {
	Talosconfig               string
	KubernetesVersion         string
        ...
}
// qemuOps are the qemu provider specific options
type qemuOps struct {
	nodeInstallImage             string
	nodeVmlinuzPath              string
        ...
}
// dockerOps are the options specific to the docker provider
type dockerOps struct {
	dockerHostIP      string
        ...
}

// Same for flags

// Result:
type createOps struct {
	common *CommonOps
	docker *dockerOps
	qemu   *qemuOps
}

type createFlags struct {
	common *pflag.FlagSet
	docker *pflag.FlagSet
	qemu   *pflag.FlagSet
}

// partialClusterRequest is the provision.ClusterRequest with only common provider options applied.
// partialClusterRequest can be modified and then has to be handed to CreateCluster.
type partialClusterRequest = provision.ClusterRequest

type clusterMaker struct {
	options      CommonOps
	provisioner  provision.Provisioner
	talosVersion string

	request           provision.ClusterRequest
	provisionOpts     []provision.Option
	cfgBundleOpts     []bundle.Option
	genOpts           []generate.Option
	cidr4             netip.Prefix
	ips               [][]netip.Addr
	verionContract    *config.VersionContract
	inClusterEndpoint string
}

func NewClusterMaker(ops CommonOps, provisioner provision.Provisioner, talosVersion string) (
	clusterMaker, error,
) {
	cm := clusterMaker{}

	// Initialize clusterMaker and create the inital request based on the common options

	return cm, nil
}

func (cm *clusterMaker) GetPartialClusterRequest() partialClusterRequest {
	return cm.request
}

func (cm *clusterMaker) AddGenOps(genOpts ...generate.Option) {
}

func (cm *clusterMaker) AddProvisionOps(provisionOpts ...provision.Option) {
}

func (cm *clusterMaker) AddCfgBundleOpts(provisionOpts ...bundle.Option) {
}

// SetInClusterEndpoint allows to optionally change the inClusterEndpoint.
func (cm *clusterMaker) SetInClusterEndpoint(endpoint string) {
}

// CreateCluster finalizes the clusterRequest by rendering and applying configs.
// Then it creates the cluster and runs post create logic.
func (cm *clusterMaker) CreateCluster(request partialClusterRequest) error {
	// Apply config to the nodes in the partialClusterRequest
	// Create the cluster via the Provisioner
	// Run postcreate
	return nil
}

func getDockerClusterMaker(ctx context.Context, cOps CommonOps, dOps dockerOps, provisioner provision.Provisioner) (
	clusterMaker, error,
) {
	talosversion := cOps.TalosVersion
	if talosversion == "" {
		parts := strings.Split(dOps.nodeImage, ":")
		talosversion = parts[len(parts)-1]
	}

	return NewClusterMaker(cOps, provisioner, talosversion)
}

func createDockerCluster(dOps dockerOps, cm clusterMaker) error {
	clusterReq := cm.GetPartialClusterRequest()
	cm.AddProvisionOps(provision.WithDockerPortsHostIP(dOps.dockerHostIP))

	portList := []string{}
	if dOps.ports != "" {
		portList = strings.Split(dOps.ports, ",")
		cm.AddProvisionOps(provision.WithDockerPorts(portList))
	}

	clusterReq.Image = dOps.nodeImage
	clusterReq.Network.DockerDisableIPv6 = dOps.dockerDisableIPv6

	for _, n := range clusterReq.Nodes {
		n.Mounts = dOps.mountOpts.Value()
		n.Ports = portList
	}

	return cm.CreateCluster(clusterReq)
}