// Package host provides utilities and data structures in relation to a libvirt host.
// This includes getting a list of virtual machines running on a host, launching
// a new virtual machine on a host, triggering a virtual machine migration to another
// host, getting hardware and resource usage from a host, and eventually more.
// Most of this is data at the moment, ensuring data can be gathered efficiently without
// slowing down the host from it's main job of running virtual machines.
package host

import (
	"log"
	"sync"

	"git.staur.ca/stobbsm/clustvirt/lib/guest"
	"libvirt.org/go/libvirt"
	"libvirt.org/go/libvirtxml"
)

// Host holds information and acts as a connection handle for a Host
// If a connection is closed prematurely, will re-open the connection and
// try the attempted method again
type Host struct {
	// HostName used to make the connection
	HostName string
	// SystemHostName is the hostname as reported by the system itself
	SystemHostName string
	// LibVersion is the version of Libvirt on the host
	LibVersion uint32
	// SysInfo is the XML representation of the host system information
	SysInfo string
	// Alive indicates if the connection is alive
	Alive bool
	// Encrypted indicates if the connection is encrypted
	Encrypted bool
	// Secure indicates if the connection is secure
	Secure bool
	// HostInfo provides basic HW information about a host
	HostInfo *libvirtxml.CapsHost
	// NodeMemory provides basic memory information about the Host
	NodeMemory *NodeMemoryInfo
	// VMList is the list of virtual machines available to the host
	VMList []*libvirtxml.Domain
	// NetIfList is the list of network interfaces on the host
	NetIfFList []*libvirtxml.Interface
	// NetworkList is the list of defined networks on the host
	NetworkList []*libvirtxml.Network
	// DeviceList is the list of devices on the host
	DeviceList []*libvirtxml.NodeDevice
	// SecretList provides a list of secrets available to the host
	SecretList []*libvirtxml.Secret
	// StoragePoolList provides the list of stoarge ppols available to the host
	StoragePoolList []*libvirtxml.StoragePool
	// VolumeList is the list of volumes available on the host
	VolumeList []*libvirtxml.StorageVolume

	uri      *URI
	conn     *libvirt.Connect
	close    chan struct{}
	closeErr chan error
}

// NodeMemoryInfo provides statistis about node memory usage from libvirt.NodeMemoryStats
type NodeMemoryInfo struct {
	Total   uint64
	Free    uint64
	Buffers uint64
	Cached  uint64
}

// ConnectHost creates a host connection wrapper that can be used regularly
func ConnectHost(uri *URI, host string) (*Host, error) {
	h := &Host{
		HostName: host,
		uri:      uri,
	}

	if err := h.connect(); err != nil {
		return nil, err
	}

	h.close = make(chan struct{})
	h.closeErr = make(chan error)

	h.getInfo()

	go func() {
		defer close(h.closeErr)
		<-h.close
		_, err := h.conn.Close()
		h.closeErr <- err
	}()
	return h, nil
}

// connect creates a host connection
func (h *Host) connect() error {
	var err error
	h.conn, err = libvirt.NewConnect(h.uri.ConnectionString(h.HostName))
	return err
}

// GetGuestByName returns a GuestVM instance that exists on the given host
func (h *Host) GetGuestByName(name string) (*guest.VM, error) {
	g, err := guest.GetGuest(name, h.conn)
	if err == nil {
		return g, nil
	}
	lverr, ok := err.(libvirt.Error)
	if ok && lverr.Code == libvirt.ERR_INVALID_CONN {
		// try again after creating a new connection
		return guest.GetGuest(name, h.conn)
	}
	return nil, err
}

// Close triggers closing the host connection
func (h *Host) Close() error {
	log.Println("Closing Host", h.HostName)
	close(h.close)
	return <-h.closeErr
}

// private methods that load the different informational parts

func (h *Host) getInfo() {
	wg := new(sync.WaitGroup)

	infoFuncs := []func(){
		h.hostInfo,
		h.memoryInfo,
		h.getStoragePools,
		h.getNetsInfo,
		h.getIfaceInfo,
		h.getDevicesInfo,
		h.getDomainInfo,
		h.getSecretsInfo,
	}

	for _, f := range infoFuncs {
		wg.Add(1)
		go func(wg *sync.WaitGroup) {
			defer wg.Done()
			f()
		}(wg)
	}

	wg.Wait()
}

func (h *Host) hostInfo() {
	var err error

	rawxml, err := h.conn.GetCapabilities()
	if err != nil {
		log.Printf("error getting host capabilities XML: %s", err)
	}
	xmldoc := &libvirtxml.Caps{}
	if err = xmldoc.Unmarshal(rawxml); err != nil {
		log.Printf("error parsing host capabilities XML: %s", err)
	}
	h.HostInfo = &xmldoc.Host
	h.SystemHostName, err = h.conn.GetHostname()
	if err != nil {
		log.Println("error getting system host name: %s", err)
	} else {
		h.SystemHostName = h.HostName
	}
	h.LibVersion, err = h.conn.GetLibVersion()
	if err != nil {
		log.Println(err)
	}
}

func (h *Host) memoryInfo() {
	mi, err := h.conn.GetMemoryStats(libvirt.NODE_MEMORY_STATS_ALL_CELLS, 0)
	if err != nil {
		log.Println(err)
	}
	h.NodeMemory = &NodeMemoryInfo{
		Total: mi.Total,
		Free: mi.Free,
		Buffers: mi.Buffers,
		Cached: mi.Cached,
	}

	h.SysInfo, err = h.conn.GetSysinfo(0)
	if err != nil {
		log.Println(err)
	}

	h.Alive, err = h.conn.IsAlive()
	if err != nil {
		log.Println(err)
	}
	h.Encrypted, err = h.conn.IsEncrypted()
	if err != nil {
		log.Println(err)
	}
	h.Secure, err = h.conn.IsSecure()
	if err != nil {
		log.Println(err)
	}
}

func (h *Host) getStoragePools() {
	// Get list of all storage pools on the host
	spools, err := h.conn.ListAllStoragePools(0)
	if err != nil {
		log.Println(err)
	}
	if len(spools) > 0 {
		h.StoragePoolList = make([]*libvirtxml.StoragePool, len(spools))
		for i, s := range spools {
			// run in a function to allow defer s.Free()
			func() {
				defer s.Free()
				// Get the XML represenation of each storage pool, parse it with libvirtxml
				rawxml, err := s.GetXMLDesc(0)
				if err != nil {
					log.Println("error getting storage pool xml: %s", err)
					return
				}
				xmldoc := &libvirtxml.StoragePool{}
				err = xmldoc.Unmarshal(rawxml)
				if err != nil {
					log.Println("error parsing storage pool XML: %s", err)
					return
				}
				h.StoragePoolList[i] = xmldoc

				// Get list of all storage volumes in the current storage pool
				svols, err := s.ListAllStorageVolumes(0)
				if err != nil {
					log.Println(err)
				}
				if len(svols) > 0 {
					// define temporary variable to hold slice of StorageVolume, that can
					// either be appended to the existing slice, or used in place of the newly
					// defined slice
					tvl := make([]*libvirtxml.StorageVolume, len(svols))
					for j, sv := range svols {
						// run in a function so I can defer the sv.Free() call
						func() {
							defer sv.Free()
							rawxml, err = sv.GetXMLDesc(0)
							if err != nil {
								log.Printf("error getting XML from storage volume: %s", err)
								return
							}
							xmldoc := &libvirtxml.StorageVolume{}
							err = xmldoc.Unmarshal(rawxml)
							if err != nil {
								log.Printf("error parsing storage volume XML: %s", err)
								return
							}

							tvl[j] = xmldoc
						}()
					}
					// Append the contents of tvl to h.VolumeList
					if h.VolumeList == nil {
						h.VolumeList = []*libvirtxml.StorageVolume{}
					}
					// Only append if the temporary storage volume isn't nil
					for _, tsv := range tvl {
						if tsv != nil {
							h.VolumeList = append(h.VolumeList, tsv)
						}
					}
				}
			}()
		}
	}
}

func (h *Host) getSecretsInfo() {
	nsecrets, err := h.conn.ListAllSecrets(0)
	if err != nil {
		log.Printf("error loading secrets from host: %s", err)
	}
	if len(nsecrets) > 0 {
		h.SecretList = make([]*libvirtxml.Secret, len(nsecrets))
		for i, s := range nsecrets {
			func() {
				defer s.Free()
				rawxml, err := s.GetXMLDesc(0)
				if err != nil {
					log.Printf("error getting secret XML", err)
				}
				xmldoc := &libvirtxml.Secret{}
				if err = xmldoc.Unmarshal(rawxml); err != nil {
					log.Printf("error parsing secret XML: %s", err)
				}
				h.SecretList[i] = xmldoc
			}()
		}
	}
}

func (h *Host) getDomainInfo() {
	// getDomainInfo
	doms, err := h.conn.ListAllDomains(0)
	if err != nil {
		log.Println(err)
	}
	if len(doms) > 0 {
		h.VMList = make([]VMInfo, len(doms))
		for i, d := range doms {
			// Just going to log errors here, and free the dom after getting what we can
			if h.VMList[i].Name, err = d.GetName(); err != nil {
				log.Println(err)
			}
			if h.VMList[i].UUID, err = d.GetUUID(); err != nil {
				log.Println(err)
			}
			if h.VMList[i].ID, err = d.GetID(); err != nil {
				log.Println(err)
			}
			if h.VMList[i].XML, err = d.GetXMLDesc(0); err != nil {
				log.Println(err)
			}
			vmXML := &libvirtxml.Domain{}
			if err = vmXML.Unmarshal(h.VMList[i].XML); err != nil {
				log.Println(err)
			}
			h.VMList[i].VCPUs = vmXML.VCPU.Value
			h.VMList[i].Memory = vmXML.CurrentMemory.Value
			if h.VMList[i].Active, err = d.IsActive(); err != nil {
				log.Println(err)
			}

			d.Free()
		}
	}
}

func (h *Host) getIfaceInfo() {
	// getIfaceInfo
	ifaces, err := h.conn.ListInterfaces()
	if err != nil {
		log.Println(err)
	}
	if len(ifaces) > 0 {
		h.NetIfFList = make([]NetIfInfo, len(ifaces))
		for i, ni := range ifaces {
			h.NetIfFList[i].Name = ni
			iface, err := h.conn.LookupInterfaceByName(ni)
			if err != nil {
				log.Println(err)
			}
			if h.NetIfFList[i].MacAddr, err = iface.GetMACString(); err != nil {
				log.Println(err)
			}
			if h.NetIfFList[i].XML, err = iface.GetXMLDesc(0); err != nil {
				log.Println(err)
			}

			iface.Free()
		}
	}
}

func (h *Host) getNetsInfo() {
	// getNetsInfo
	nets, err := h.conn.ListNetworks()
	if err != nil {
		log.Println(err)
	}
	if len(nets) > 0 {
		h.NetworkList = make([]NetworkInfo, len(nets))
		for i, netName := range nets {
			net, err := h.conn.LookupNetworkByName(netName)
			if err != nil {
				log.Println(err)
			}
			if h.NetworkList[i].Name, err = net.GetName(); err != nil {
				log.Println(err)
			}
			if h.NetworkList[i].UUID, err = net.GetUUID(); err != nil {
				log.Println(err)
			}
			if h.NetworkList[i].XML, err = net.GetXMLDesc(0); err != nil {
				log.Println(err)
			}
			if h.NetworkList[i].Active, err = net.IsActive(); err != nil {
				log.Println(err)
			}

			net.Free()
		}
	}
}

func (h *Host) getDevicesInfo() {
	ndevs, err := h.conn.ListAllNodeDevices(0)
	if err != nil {
		log.Println(err)
	}
	if len(ndevs) > 0 {
		h.DeviceList = make([]DeviceInfo, len(ndevs))
		for i, dev := range ndevs {
			if h.DeviceList[i].Name, err = dev.GetName(); err != nil {
				log.Println(err)
			}
			if h.DeviceList[i].Capabilities, err = dev.ListCaps(); err != nil {
				log.Println(err)
			}
			if h.DeviceList[i].XML, err = dev.GetXMLDesc(0); err != nil {
				log.Println(err)
			}
			dx := &libvirtxml.NodeDevice{}
			if err != dx.Unmarshal(h.DeviceList[i].XML); err != nil {
				log.Println(err)
			}
			h.DeviceList[i].Driver = dx.Driver.Name
			dx.Capability.PCI.Class

			dev.Free()
		}
	}
}