package pkg

import (
	"regexp"
	"strings"

	"github.rackspace.com/gorax/tools/util"
)

type (
	VLAN struct {
		Name            string       `json:"name"`
		IntConf         []*IntConfig `json:"interfaces"`
		Tag             int          `json:"tag"`
		IfIndex         int          `json:"if-index"`
		FailSafe        bool         `json:"failsafe"`
		FailSafeAction  string       `json:"failsafe-action"`
		FailSafeTimeout int          `json:"failsafe-timeout"`
		MACMasquerade   string       `json:"mac_masquerade"`
	}

	IntConfig struct {
		IntNum string `json:"interface"`
		Tagged bool   `json:"tagged"`
	}

	NetVlansStatus struct {
		Vlans []*VlanStatus `json:"vlans"`
	}

	VlanStatus struct {
		Name   string `json:"name"`
		Member string `json:"member"`
		Mac    string `json:"mac"`
		IsTag  bool   `json:"is_tagged"`
		Tag    int    `json:"tag"`
		MTU    int    `json:"mtu"`
	}
)

func ParseVLANs(s string) ([]*VLAN, error) {
	NETVLANRE := regexp.MustCompile(`net\s+vlan\s+(\S+)\s+{((.|\n)*?\n)}`)
	VLANTAGERE := regexp.MustCompile(`tag\s+([0-9]+)`)
	VLANFAILSAFERE := regexp.MustCompile(`failsafe\s+(enabled)`)
	VLANFSACTIONRE := regexp.MustCompile(`failsafe-action\s+(\S+)`)
	VLANFSTIMEOUTRE := regexp.MustCompile(`failsafe-timeout\s+([0-9]+)`)
	MACMASQRE := regexp.MustCompile(`mac-masquerade\s+(\S+)`)
	INTERFACERE := regexp.MustCompile(`interfaces\s+{((.|\n)*?)$`)
	INTERFACESUBRE := regexp.MustCompile(`(\S+)\s+{((.|\n)*?)}`)
	TAGGEDRE := regexp.MustCompile(`(?i)(tagged)`)

	var n []*VLAN
	for _, r := range NETVLANRE.FindAllStringSubmatch(s, -1) {
		n = append(n, &VLAN{
			Name:            r[1],
			Tag:             util.RegexpAtoInt(VLANTAGERE, r[2]),
			IfIndex:         util.RegexpAtoInt(IFINDXRE, r[2]),
			FailSafe:        VLANFAILSAFERE.MatchString(r[2]),
			FailSafeAction:  util.RegexpFindString(VLANFSACTIONRE, r[2]),
			FailSafeTimeout: util.RegexpAtoInt(VLANFSTIMEOUTRE, r[2]),
			MACMasquerade:   util.RegexpFindString(MACMASQRE, r[2]),
			IntConf: func() (ic []*IntConfig) {
				for _, k := range INTERFACESUBRE.FindAllStringSubmatch(util.RegexpString(INTERFACERE, r[2]), -1) {
					ic = append(ic, &IntConfig{
						IntNum: k[1],
						Tagged: TAGGEDRE.MatchString(k[2]),
					})
				}
				return ic
			}(),
		})
	}

	return n, nil
}

func (v *VLAN) Interfaces() *string {
	var il []string
	for _, ic := range v.IntConf {
		il = append(il, ic.IntNum)
	}
	r := strings.Join(il, ",")
	return &r
}

func ParseVlanStatus(s string) *NetVlansStatus {
	v := new(NetVlansStatus)
	v.Parse(s)
	return v
}

func (n *NetVlansStatus) Parse(s string) {
	reVlanStatusAll := regexp.MustCompile(`(?i)Net::VLAN:\s+(\S+)((.|\n)*?)Net::Interface`)
	//reVlanStatusName   := regexp.MustCompile(`(?i)Net::VLAN:\s+(\S+)`)
	reVlanStatusMember := regexp.MustCompile(`(?i)Net::VLAN-Member:\s+(\S+)`)
	reVlanStatusTag := regexp.MustCompile(`(?i)tag\s+(\S+)`)
	reVlanStatusMac := regexp.MustCompile(`(?i)mac\s+address\s+\(\w+\)\s+(\S+)`)
	reVlanStatusIsTag := regexp.MustCompile(`(?i)tagged\s+(\S+)`)
	reVlanStatusMTU := regexp.MustCompile(`(?i)mtu\s+(\S+)`)

	for _, r := range reVlanStatusAll.FindAllStringSubmatch(s, -1) {
		vs := VlanStatus{
			Name:   r[1],
			Mac:    util.RegexpFindString(reVlanStatusMac, r[2]),
			IsTag:  strings.Contains(util.RegexpFindString(reVlanStatusIsTag, r[1]), "yes"),
			Member: util.RegexpFindString(reVlanStatusMember, r[2]),
		}
		if tag, err := util.RegexpAtoi(reVlanStatusTag, r[2]); err == nil {
			vs.Tag = tag
		}
		if mtu, err := util.RegexpAtoi(reVlanStatusMTU, r[2]); err == nil {
			vs.MTU = mtu
		}
		n.Vlans = append(n.Vlans, &vs)
	}
}