package node

import (
	"fmt"
	"github.com/hpcng/warewulf/internal/pkg/errors"
	"github.com/hpcng/warewulf/internal/pkg/util"
	"github.com/hpcng/warewulf/internal/pkg/wwlog"
	"gopkg.in/yaml.v2"
	"io/ioutil"
	"os"
	"regexp"
	"strings"
)

const ConfigFile = "/etc/warewulf/nodes.conf"
const LocalStateDir = "/var/warewulf"

func init() {
	//TODO: Check to make sure nodes.conf is found

}

type nodeYaml struct {
	NodeGroups map[string]*nodeGroup //`yaml:"nodegroups"`
}

type nodeGroup struct {
	Comment        string
	Vnfs           string `yaml:"vnfs"`
	Ipxe           string `yaml:"ipxe template,omitempty"`
	SystemOverlay  string `yaml:"system overlay,omitempty""`
	RuntimeOverlay string `yaml:"runtime overlay""`
	DomainSuffix   string `yaml:"domain suffix"`
	KernelVersion  string `yaml:"kernel version"`
	KernelArgs     string `yaml:"kernel args"`
	IpmiUserName   string `yaml:"ipmi username,omitempty"`
	IpmiPassword   string `yaml:"ipmi password,omitempty"`
	Nodes          map[string]*nodeEntry
}

type nodeEntry struct {
	Hostname       string `yaml:"hostname,omitempty"`
	Vnfs           string `yaml:"vnfs,omitempty"`
	Ipxe           string `yaml:"ipxe template,omitempty"`
	SystemOverlay  string `yaml:"system overlay,omitempty"`
	RuntimeOverlay string `yaml:"runtime overlay,omitempty"`
	DomainSuffix   string `yaml:"domain suffix,omitempty"`
	KernelVersion  string `yaml:"kernel version,omitempty"`
	KernelArgs     string `yaml:"kernel args,omitempty"`
	IpmiIpaddr     string `yaml:"ipmi ipaddr,omitempty"`
	IpmiUserName   string `yaml:"ipmi username,omitempty"`
	IpmiPassword   string `yaml:"ipmi password,omitempty"`
	NetDevs        map[string]*netDevs
}

type netDevs struct {
	Type    string `yaml:"type,omitempty"`
	Hwaddr  string
	Ipaddr  string
	Netmask string
	Gateway string`yaml:"gateway,omitempty"`
}

type NodeInfo struct {
	Id             string
	Gid 	       string
	Uid 		   string
	GroupName      string
	HostName       string
	DomainName     string
	Fqdn           string
	Vnfs           string
	Ipxe           string
	SystemOverlay  string
	RuntimeOverlay string
	KernelVersion  string
	KernelArgs     string
	IpmiIpaddr     string
	IpmiUserName   string
	IpmiPassword   string
	NetDevs        map[string]*netDevs
}

type GroupInfo struct {
	Id             string
	GroupName      string
	DomainName     string
	Vnfs           string
	Ipxe           string
	SystemOverlay  string
	RuntimeOverlay string
	KernelVersion  string
	KernelArgs     string
	IpmiUserName   string
	IpmiPassword   string
}

func New() (nodeYaml, error) {
	var ret nodeYaml

	wwlog.Printf(wwlog.DEBUG, "Opening node configuration file: %s\n", ConfigFile)
	data, err := ioutil.ReadFile(ConfigFile)
	if err != nil {
		fmt.Printf("error reading node configuration file\n")
		return ret, err
	}

	err = yaml.Unmarshal(data, &ret)
	if err != nil {
		return ret, err
	}

	return ret, nil
}

func (self *nodeYaml) AddGroup(groupID string) error {
	var group nodeGroup

	if _, ok := self.NodeGroups[groupID]; ok {
		return errors.New("Group name already exists: " + groupID)
	}

	self.NodeGroups[groupID] = &group
	self.NodeGroups[groupID].DomainSuffix = groupID

	return nil
}

func (self *nodeYaml) AddNode(groupID string, nodeID string) error {
	var node nodeEntry

	wwlog.Printf(wwlog.VERBOSE, "Adding new node: %s/%s\n", groupID, nodeID)

	if _, ok := self.NodeGroups[groupID]; ok {
		if _, ok := self.NodeGroups[groupID].Nodes[nodeID]; ok {
			return errors.New("Nodename already exists in group: " + nodeID)
		}
	} else {
		return errors.New("Group does not exist: "+groupID)
	}

	self.NodeGroups[groupID].Nodes[nodeID] = &node
	self.NodeGroups[groupID].Nodes[nodeID].Hostname = nodeID

	return nil
}

func (self *nodeYaml) DelNode(groupID string, nodeID string) error {

	if _, ok := self.NodeGroups[groupID]; ok {
		if _, ok := self.NodeGroups[groupID].Nodes[nodeID]; ok {
			delete(self.NodeGroups[groupID].Nodes, nodeID)
			wwlog.Printf(wwlog.VERBOSE, "Deleting node: %s/%s\n", groupID, nodeID)
		} else {
			return errors.New("Node '"+nodeID+"' was not found in group '"+groupID+"'")
		}
	} else {
		return errors.New("Group '"+groupID+"' was not found")
	}

	return nil
}

func (self *nodeYaml) DelNodeNet(groupID string, nodeID string, netDev string) error {

	if _, ok := self.NodeGroups[groupID]; ok {
		if _, ok := self.NodeGroups[groupID].Nodes[nodeID]; ok {
			if _, ok := self.NodeGroups[groupID].Nodes[nodeID].NetDevs[netDev]; ok {
				wwlog.Printf(wwlog.VERBOSE, "Deleting node network device: %s/%s:%s\n", groupID, nodeID, netDev)
				delete(self.NodeGroups[groupID].Nodes[nodeID].NetDevs, netDev)
			} else {
				return errors.New("Network device '"+netDev+"' was not found in node '"+groupID+"/"+nodeID+"'")
			}
		} else {
			return errors.New("Node '"+nodeID+"' was not found in group '"+groupID+"'")
		}
	} else {
		return errors.New("Group '"+groupID+"' was not found")
	}

	return nil
}


func (self *nodeYaml) DelGroup(groupname string) error {
	if _, ok := self.NodeGroups[groupname]; ok {
		delete(self.NodeGroups, groupname)
	} else {
		return errors.New("Node group undefined: " + groupname)
	}

	return nil
}

func (self *nodeYaml) SetGroupVal(groupID string, entry string, value string) error {
	if strings.ToUpper(value) == "UNDEF" || strings.ToUpper(value) == "NIL" || strings.ToUpper(value) == "DEL" {
		value = ""
	}

	if _, ok := self.NodeGroups[groupID]; ok {
		wwlog.Printf(wwlog.VERBOSE, "Setting group %s to: %s = '%s'\n", groupID, entry, value )

		switch strings.ToUpper(entry) {
		case "VNFS":
			util.ValidateOrDie("VNFS", entry, "^[a-zA-Z0-9-._]*$")
			self.NodeGroups[groupID].Vnfs = value
		case "KERNEL":
			util.ValidateOrDie("Kernel Version", entry, "^[a-zA-Z0-9-._]*$")
			self.NodeGroups[groupID].KernelVersion = value
		case "DOMAINSUFFIX":
			util.ValidateOrDie("Domain", entry, "^[a-zA-Z0-9-._]*$")
			self.NodeGroups[groupID].DomainSuffix = value
		case "IPXE":
			util.ValidateOrDie("iPXE Template", entry, "^[a-zA-Z0-9-._]*$")
			self.NodeGroups[groupID].Ipxe = value
		case "SYSTEMOVERLAY":
			util.ValidateOrDie("System Overlay", entry, "^[a-zA-Z0-9-._]*$")
			self.NodeGroups[groupID].SystemOverlay = value
		case "RUNTIMEOVERLAY":
			util.ValidateOrDie("Runtime Overlay", entry, "^[a-zA-Z0-9-._]*$")
			self.NodeGroups[groupID].RuntimeOverlay = value
		case "IPMIUSERNAME":
			util.ValidateOrDie("IPMI Username", entry, "^[a-zA-Z0-9-._]*$")
			self.NodeGroups[groupID].IpmiUserName = value
		case "IPMIPASSWORD":
			util.ValidateOrDie("IPMI Password", entry, "^[a-zA-Z0-9-._]*$")
			self.NodeGroups[groupID].IpmiPassword = value

		}
	} else {
		return errors.New("Group does not exist: " +groupID)
	}

	return nil
}

func (self *nodeYaml) SetNodeVal(groupID string, nodeID string, entry string, value string) error {
	if strings.ToUpper(value) == "UNDEF" || strings.ToUpper(value) == "NIL" || strings.ToUpper(value) == "DEL" {
		value = ""
	}
	if _, ok := self.NodeGroups[groupID]; ok {
		if _, ok := self.NodeGroups[groupID].Nodes[nodeID]; ok {
			wwlog.Printf(wwlog.VERBOSE, "Setting node %s/%s to: %s = '%s'\n", groupID, nodeID, entry, value )

			switch strings.ToUpper(entry) {
			case "VNFS":
				util.ValidateOrDie("VNFS", entry, "^[a-zA-Z0-9-._]*$")
				self.NodeGroups[groupID].Nodes[nodeID].Vnfs = value
			case "KERNEL":
				util.ValidateOrDie("Kernel Version", entry, "^[a-zA-Z0-9-._]*$")
				self.NodeGroups[groupID].Nodes[nodeID].KernelVersion = value
			case "DOMAINSUFFIX":
				util.ValidateOrDie("Domain", entry, "^[a-zA-Z0-9-._]*$")
				self.NodeGroups[groupID].Nodes[nodeID].DomainSuffix = value
			case "IPXE":
				util.ValidateOrDie("iPXE Template", entry, "^[a-zA-Z0-9-._]*$")
				self.NodeGroups[groupID].Nodes[nodeID].Ipxe = value
			case "SYSTEMOVERLAY":
				util.ValidateOrDie("System Overlay", entry, "^[a-zA-Z0-9-._]*$")
				self.NodeGroups[groupID].Nodes[nodeID].SystemOverlay = value
			case "RUNTIMEOVERLAY":
				util.ValidateOrDie("Runtime Overlay", entry, "^[a-zA-Z0-9-._]*$")
				self.NodeGroups[groupID].Nodes[nodeID].RuntimeOverlay = value
			case "HOSTNAME":
				util.ValidateOrDie("Hostname", entry, "^[a-zA-Z0-9-._]*$")
				self.NodeGroups[groupID].Nodes[nodeID].Hostname = value
			case "IPMIIPADDR":
				util.ValidateOrDie("IPMI IP Address", entry, "^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}$")
				self.NodeGroups[groupID].Nodes[nodeID].IpmiIpaddr = value
			case "IPMIUSERNAME":
				util.ValidateOrDie("IPMI Username", entry, "^[a-zA-Z0-9-._]*$")
				self.NodeGroups[groupID].Nodes[nodeID].IpmiUserName = value
			case "IPMIPASSWORD":
				util.ValidateOrDie("IPMI Password", entry, "^[a-zA-Z0-9-._]*$")
				self.NodeGroups[groupID].Nodes[nodeID].IpmiPassword = value

			}
		} else {
			return errors.New("Node does not exist: " +groupID+ "/" +nodeID)
		}
	} else {
		return errors.New("Group does not exist: " +groupID)
	}

	return nil
}

func (self *nodeYaml) SetNodeNet(groupID string, nodeID string, netDev string, entry string, value string) error {
	if strings.ToUpper(value) == "UNDEF" || strings.ToUpper(value) == "NIL" || strings.ToUpper(value) == "DEL" {
		value = ""
	}

	if _, ok := self.NodeGroups[groupID]; ok {
		if _, ok := self.NodeGroups[groupID].Nodes[nodeID]; ok {
			if _, ok := self.NodeGroups[groupID].Nodes[nodeID].NetDevs[netDev]; ok {
				wwlog.Printf(wwlog.VERBOSE, "Editing existing node NetDev entry for node: %s/%s\n", groupID, nodeID)
			} else {
				var nd netDevs
				self.NodeGroups[groupID].Nodes[nodeID].NetDevs[netDev] = &nd
			}
		} else {
			return errors.New("Node does not exist: "+groupID+"/"+nodeID)
		}
	} else {
		return errors.New("Group does not exist: "+groupID)
	}

	switch strings.ToUpper(entry) {
	case "IPADDR":
		util.ValidateOrDie("IP address", value, "^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}$")
		self.NodeGroups[groupID].Nodes[nodeID].NetDevs[netDev].Ipaddr = value
	case "NETMASK":
		util.ValidateOrDie("Netmask", value, "^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}$")
		self.NodeGroups[groupID].Nodes[nodeID].NetDevs[netDev].Netmask = value
	case "GATEWAY":
		util.ValidateOrDie("Gateway", value, "^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}$")
		self.NodeGroups[groupID].Nodes[nodeID].NetDevs[netDev].Gateway = value
	case "TYPE":
		util.ValidateOrDie("Network device type", value, "^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}$")
		self.NodeGroups[groupID].Nodes[nodeID].NetDevs[netDev].Type = value
	case "HWADDR":
		util.ValidateOrDie("HW address", value, "^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$")
		self.NodeGroups[groupID].Nodes[nodeID].NetDevs[netDev].Hwaddr = value

	}

	return nil
}

func (self *nodeYaml) Persist() error {

	out, err := yaml.Marshal(self)
	if err != nil {
		return err
	}

	file, err := os.OpenFile(ConfigFile, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
	if err != nil {
		wwlog.Printf(wwlog.ERROR, "%s\n", err)
		os.Exit(1)
	}

	defer file.Close()

	_, err = file.WriteString(string(out))
	if err != nil {
		return err
	}

	return nil
}


func (self *nodeYaml) FindAllGroups() ([]GroupInfo, error) {
	var ret []GroupInfo

	for groupname, group := range self.NodeGroups {
		var g GroupInfo

		g.Id = groupname
		g.GroupName = groupname
		g.RuntimeOverlay = group.RuntimeOverlay
		g.SystemOverlay = group.SystemOverlay
		g.Ipxe = group.Ipxe
		g.KernelVersion = group.KernelVersion
		g.KernelArgs = group.KernelArgs
		g.Vnfs = group.Vnfs
		g.IpmiUserName = group.IpmiUserName
		g.IpmiPassword = group.IpmiPassword
		g.DomainName = group.DomainSuffix

		// TODO: Validate or die on all inputs

		ret = append(ret, g)
	}
	return ret, nil
}


func (self *nodeYaml) FindAllNodes() ([]NodeInfo, error) {
	var ret []NodeInfo

	for groupname, group := range self.NodeGroups {
		for nodename, node := range group.Nodes {
			var n NodeInfo

			n.Id = nodename
			n.Gid = groupname
//			n.Uid = groupname + ":" + nodename
			n.GroupName = groupname
			n.HostName = node.Hostname
			n.IpmiIpaddr = node.IpmiIpaddr

			n.Vnfs = group.Vnfs
			n.SystemOverlay = group.SystemOverlay
			n.RuntimeOverlay = group.RuntimeOverlay
			n.KernelVersion = group.KernelVersion
			n.KernelArgs = group.KernelArgs
			n.DomainName = group.DomainSuffix
			n.Ipxe = group.Ipxe
			n.IpmiUserName = group.IpmiUserName
			n.IpmiPassword = group.IpmiPassword

			n.NetDevs = node.NetDevs

			if node.IpmiUserName != "" {
				n.IpmiUserName = node.IpmiUserName
			}
			if node.IpmiPassword != "" {
				n.IpmiPassword = node.IpmiPassword
			}
			if node.KernelVersion != "" {
				n.KernelVersion = node.KernelVersion
			}
			if node.Vnfs != "" {
				n.Vnfs = node.Vnfs
			}
			if node.SystemOverlay != "" {
				n.SystemOverlay = node.SystemOverlay
			}
			if node.RuntimeOverlay != "" {
				n.RuntimeOverlay = node.RuntimeOverlay
			}
			if node.DomainSuffix != "" {
				n.DomainName = node.DomainSuffix
			}
			if node.Ipxe != "" {
				n.Ipxe = node.Ipxe
			}
			if node.KernelArgs != "" {
				n.KernelArgs = node.KernelArgs
			}

			if n.RuntimeOverlay == "" {
				n.RuntimeOverlay = "default"
			}
			if n.SystemOverlay == "" {
				n.SystemOverlay = "default"
			}
			if n.Ipxe == "" {
				n.Ipxe = "default"
			}
			if n.HostName == "" {
				n.HostName = nodename
			}

			if n.DomainName != "" {
				n.Fqdn = node.Hostname + "." + n.DomainName
			} else {
				n.Fqdn = node.Hostname
			}

			util.ValidateOrDie(n.Fqdn +":group name", n.GroupName, "^[a-zA-Z0-9-._]*$")
			util.ValidateOrDie(n.Fqdn +":vnfs", n.Vnfs, "^[a-zA-Z0-9-._:/]*$")
			util.ValidateOrDie(n.Fqdn +":system overlay", n.SystemOverlay, "^[a-zA-Z0-9-._]*$")
			util.ValidateOrDie(n.Fqdn +":runtime overlay", n.RuntimeOverlay, "^[a-zA-Z0-9-._]*$")
			util.ValidateOrDie(n.Fqdn +":domain suffix", n.DomainName, "^[a-zA-Z0-9-._]*$")
			util.ValidateOrDie(n.Fqdn +":hostname", n.HostName, "^[a-zA-Z0-9-_]*$")
			util.ValidateOrDie(n.Fqdn +":kernel version", n.KernelVersion, "^[a-zA-Z0-9-._]*$")

			ret = append(ret, n)
		}
	}

	return ret, nil
}

func (nodes *nodeYaml) FindByHwaddr(hwa string) (NodeInfo, error) {
	var ret NodeInfo

	n, _ := nodes.FindAllNodes()

	for _, node := range n {
		for _, dev := range node.NetDevs {
			if dev.Hwaddr == hwa {
				return node, nil
			}
		}
	}

	return ret, errors.New("No nodes found with HW Addr: " + hwa)
}

func (nodes *nodeYaml) FindByIpaddr(ipaddr string) (NodeInfo, error) {
	var ret NodeInfo

	n, _ := nodes.FindAllNodes()

	for _, node := range n {
		for _, dev := range node.NetDevs {
			if dev.Ipaddr == ipaddr {
				return node, nil
			}
		}
	}

	return ret, errors.New("No nodes found with IP Addr: " + ipaddr)
}

func (nodes *nodeYaml) SearchByName(search string) ([]NodeInfo, error) {
	var ret []NodeInfo

	n, _ := nodes.FindAllNodes()

	for _, node := range n {
		b, _ := regexp.MatchString(search, node.Fqdn)
		if b == true {
			ret = append(ret, node)
		}
	}

	return ret, nil
}

func (nodes *nodeYaml) SearchByNameList(searchList []string) ([]NodeInfo, error) {
	var ret []NodeInfo

	n, _ := nodes.FindAllNodes()

	for _, search := range searchList {
		for _, node := range n {
			b, _ := regexp.MatchString(search, node.Fqdn)
			if b == true {
				ret = append(ret, node)
			}
		}
	}

	return ret, nil
}