package chatgpt

import (
	"context"
	"fmt"
	"log"
	"net/url"

	"github.com/vmware/govmomi"
	"github.com/vmware/govmomi/property"
	"github.com/vmware/govmomi/view"
	"github.com/vmware/govmomi/vim25"
	"github.com/vmware/govmomi/vim25/mo"
)

func connectToVCenter() (*govmomi.Client, error) {
	vcenterURL := "https://vc.lab.local/sdk"
	vcenterUsername := "nathan"
	vcenterPassword := "VMware1!"

	u, err := url.Parse(vcenterURL)
	if err != nil {
		return nil, err
	}

	ctx := context.Background()
	client, err := govmomi.NewClient(ctx, u, true)
	if err != nil {
		return nil, err
	}

	err = client.Login(ctx, vcenterUsername, vcenterPassword)
	if err != nil {
		return nil, err
	}

	return client, nil
}

func getClusterConfigInfoEx(ctx context.Context, clusterRef *vim25.ClusterComputeResource) (*vim25.ClusterConfigInfoEx, error) {
	properties := []string{"configurationEx"}

	pc := property.DefaultCollector(clusterRef.Client())

	var clusterProps vim25.ClusterComputeResource

	err := pc.RetrieveOne(ctx, clusterRef.Reference(), properties, &clusterProps)
	if err != nil {
		return nil, err
	}

	return clusterProps.ConfigurationEx, nil
}

func findClusterByName(ctx context.Context, client *vim25.Client, name string) mo.ClusterComputeResource {
	// Create a container view so that we can search vCenter
	m := view.NewManager(client)
	cv, _ := m.CreateContainerView(ctx, c.ServiceContent.RootFolder, []string{"ClusterComputeResource"}, true)

	var clusters []mo.ClusterComputeResource
	log.Printf("Searching for Cluster '%s'\n", name)
	err := cv.Retrieve(ctx, []string{"ClusterComputeResource"}, []string{"summary", "name"}, &clusters)
	if err != nil {
		log.Printf("Failed searching for Cluster %s : %s\n", name, err)
		return mo.ClusterComputeResource{}
	} else {
		for _, cluster := range clusters {
			if cluster.Name == name {
				log.Printf("Found corresponding Cluster with MoRef '%s'\n", cluster.Reference())
				return cluster
			}
		}
	}

	// If we reached here then we didn't find the Cluster
	return mo.ClusterComputeResource{}
}

func main() {
	client, err := connectToVCenter()
	if err != nil {
		fmt.Println("Error connecting to vCenter:", err)
		return
	}
	defer client.Logout(context.Background())

	// Specify the cluster reference based on your environment
	// For example: clusterRef := &vim25.ClusterComputeResource{}
	clusterRef := findClusterByName(context.Background(), client.Client, "Cluster")

	clusterConfigInfoEx, err := getClusterConfigInfoEx(context.Background(), clusterRef)
	if err != nil {
		fmt.Println("Error retrieving ClusterConfigInfoEx:", err)
		return
	}

	// Access and print various data from clusterConfigInfoEx
	fmt.Printf("Cluster Name: %s\n", clusterConfigInfoEx.Name)
	fmt.Printf("Cluster DRS Enabled: %t\n", clusterConfigInfoEx.DrsConfig.Enabled)
	// ... other properties ...

	fmt.Println("Cluster DRS Automation Level:")
	fmt.Printf("   Default: %s\n", clusterConfigInfoEx.DrsConfig.DefaultVmBehavior)
	fmt.Printf("   Enable: %s\n", clusterConfigInfoEx.DrsConfig.Enabled.Value)
	fmt.Printf("   Override: %s\n", clusterConfigInfoEx.DrsConfig.VmOverrideBehavior)

	fmt.Printf("Cluster Admission Control: %t\n", clusterConfigInfoEx.AdmissionControlInfo.Enabled)
	// ... other properties ...

	// Access and print data about HostGroups
	for _, hostGroup := range clusterConfigInfoEx.HostGroup {
		fmt.Printf("Host Group Name: %s\n", hostGroup.Name)
		fmt.Printf("Host Group Vms: %v\n", hostGroup.Vm)
		// ... other properties ...
	}
}