import

main.go

package main

import (
	"context"
	"net/url"
	"time"

	"github.com/davecgh/go-spew/spew"

	_ "github.com/pkg/errors"
	_ "github.com/sirupsen/logrus"
	"github.com/vmware/govmomi"
	"github.com/vmware/govmomi/find"
	"github.com/vmware/govmomi/nfc"
	"github.com/vmware/govmomi/object"
	_ "github.com/vmware/govmomi/object"
	_ "github.com/vmware/govmomi/ovf"
	"github.com/vmware/govmomi/vapi/rest"
	"github.com/vmware/govmomi/vim25"
	"github.com/vmware/govmomi/vim25/mo"

	"github.com/vmware/govmomi/vim25/soap"
	_ "github.com/vmware/govmomi/vim25/types"
)

func CreateVSphereClients(ctx context.Context, vcenter, username, password string) (*vim25.Client, *rest.Client, error) {
	ctx, cancel := context.WithTimeout(ctx, 60*time.Second)
	defer cancel()

	u, err := soap.ParseURL(vcenter)
	if err != nil {
		return nil, nil, err
	}
	u.User = url.UserPassword(username, password)
	c, err := govmomi.NewClient(ctx, u, true)

	if err != nil {
		return nil, nil, err
	}

	restClient := rest.NewClient(c.Client)
	err = restClient.Login(ctx, u.User)
	if err != nil {
		return nil, nil, err
	}

	return c.Client, restClient, nil
}

func main() {
	//datacenter := "dc1"
	//defaultDatastore := "NVMe"
	//ctx := context.TODO()
	client, _, err := CreateVSphereClients(
		context.TODO(),
		

	if err != nil {
		spew.Dump(err)
		return
	}

	/*
		cachedImage := "rhcos-latest.ova"
		ovaTapeArchive := &TapeArchive{Path: cachedImage}
		ovaTapeArchive.Client = client

		archiveFlag := &ArchiveFlag{}
		archiveFlag.Archive = ovaTapeArchive

		ovfDescriptor, err := archiveFlag.ReadOvf("desc.ovf")
		if err != nil {
			spew.Dump(err)
		}

		ovfEnvelope, err := archiveFlag.ReadEnvelope(ovfDescriptor)
		if err != nil {
			spew.Dump(errors.Errorf("failed to parse ovf: %s", err))
		}
		if err != nil {
			spew.Dump(err)
			return
		}

		name := "rhcos-test-image"
	*/

	finder := find.NewFinder(client)

	clusterComputeResource, _ := finder.ClusterComputeResource(context.TODO(), "cluster1")
	spew.Dump(clusterComputeResource)

	//clusterComputeResource.Datastores()
	//clusterComputeResource.Hosts()
	var obj mo.ClusterComputeResource
	clusterComputeResource.Properties(context.TODO(), clusterComputeResource.Reference(), []string{"network"}, &obj)

	spew.Dump(obj)
	networkName := "VM Network"

	for _, network := range obj.Network {
		networkObj := object.NewNetwork(client, network)
		if networkName == networkObj.Name() {
			spew.Dump(networkObj.Name())
			break
		}
	}

	/*
		defaultNetwork, err := finder.Network(context.TODO(), "VM Network")
		spew.Dump(defaultNetwork)
		if err != nil {
			spew.Dump(defaultNetwork)
			spew.Dump("default network")
			spew.Dump(err)
			return
		}

		datastore, err := finder.Datastore(ctx, defaultDatastore)
		if err != nil {
			spew.Dump(err)
			return
		}

		host, err := finder.DefaultHostSystem(ctx)
		if err != nil {
			spew.Dump(err)
			return
		}

		resourcePool, err := host.ResourcePool(ctx)

		if err != nil {
			spew.Dump(err)
			return
		}

		networkMappings := []types.OvfNetworkMapping{{
			Name:    ovfEnvelope.Network.Networks[0].Name,
			Network: defaultNetwork.Reference(),
		}}
		cisp := types.OvfCreateImportSpecParams{
			EntityName:     name,
			NetworkMapping: networkMappings,
		}
		spew.Dump(cisp)

		m := ovf.NewManager(client)
		spec, err := m.CreateImportSpec(ctx, string(ovfDescriptor),
			resourcePool.Reference(),
			datastore.Reference(), cisp)

		if err != nil {
			spew.Dump("CreateImportSpec")
			spew.Dump(err)
			return
		}
		if spec.Error != nil {
			spew.Dump(errors.New(spec.Error[0].LocalizedMessage))
			return
		}
		if spec.Warning != nil {
			for _, w := range spec.Warning {
				logrus.Warn(w.LocalizedMessage)
			}
		}

		folder, err := finder.DefaultFolder(context.TODO())
		if err != nil {
			spew.Dump("folder")
			spew.Dump(err)
		}

		lease, err := resourcePool.ImportVApp(ctx, spec.ImportSpec, folder, host)
		if err != nil {
			spew.Dump("ImportVApp")
			spew.Dump(err)
			return
		}
		spew.Dump(lease)
		spew.Dump(spec.FileItem)

		info, err := lease.Wait(ctx, spec.FileItem)
		if err != nil {
			spew.Dump("wait")
			spew.Dump(err)
			return
		}

		//return errors.Errorf("folder: %s", folder)
		u := lease.StartUpdater(ctx, info)
		defer u.Done()

		for _, i := range info.Items {
			err = Upload(ctx, archiveFlag, lease, i)
			if err != nil {
				spew.Dump("upload")
				spew.Dump(err)
				return
			}
		}
		err = lease.Complete(ctx)
		if err != nil {
			spew.Dump("lease complete")
			spew.Dump(err)
			return
		}

		vm := object.NewVirtualMachine(client, info.Entity)

		spew.Dump(vm.Name)
	*/

	return
}

func Upload(ctx context.Context, archive *ArchiveFlag, lease *nfc.Lease, item nfc.FileItem) error {
	file := item.Path

	f, size, err := archive.Open(file)
	if err != nil {
		return err
	}
	defer f.Close()

	//	logger := cmd.ProgressLogger(fmt.Sprintf("Uploading %s... ", path.Base(file)))
	//	defer logger.Wait()

	opts := soap.Upload{
		ContentLength: size,
		//		Progress:      logger,

	}

	return lease.Upload(ctx, item, f, opts)

}