package parsers

import (
	"regexp"

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

// used with "sh ip vrrp-e"
var (
	vrrpIntRE          = regexp.MustCompile(`Interface\s+ethernet\s+(\S+)\s*\n((.|\n)*?\.[a-zA-Z0-9]{4}\s*\n)`)
	vrrpeEnabled       = regexp.MustCompile(`(?i)(vrrp-extended\s+is\s+not\s+enabled\n)`)
	authTypeRE         = regexp.MustCompile(`auth-type\s+(.*?)\n`)
	vridRE             = regexp.MustCompile(`VRID\s+(\d+)`)
	stateRE            = regexp.MustCompile(`\s+state\s+(\S+)`)
	adminStatusRE      = regexp.MustCompile(`\s+administrative-status\s+(\S+)`)
	priorityRE         = regexp.MustCompile(`\n\s+priority\s+(\d+)`)
	currPriorityRE     = regexp.MustCompile(`\s+current\s+priority\s+(\d+)`)
	trackPriorityRE    = regexp.MustCompile(`\s+track-priority\s+(\d+)`)
	helloIntervalRE    = regexp.MustCompile(`hello-interval\s+(\d+)\s+sec`)
	deadIntervalRE     = regexp.MustCompile(`\n\s+dead-interval\s+(\d+)\s+sec`)
	CurrDeadIntervalRE = regexp.MustCompile(`current\s+dead-interval\s+(\S+)`)
	preemptModeRE      = regexp.MustCompile(`preempt-mode\s+(\S+)`)
	vrrpVIPRE          = regexp.MustCompile(`virtual\s+ip\s+address\s+(\S+)`)
	backupRouterRE     = regexp.MustCompile(`backup\s+router\s+(\S+)`)
	tpRE               = regexp.MustCompile(`(\d+)\((\S+)\)`)
	vrrpMACRE          = regexp.MustCompile(`VRRP-e\s+MAC\s+address:\s+(\S+)`)
)

type (
	// AdxVRRPE is the parent type to list all vrrp-e interface statistics
	AdxVRRPE struct {
		Int     []AdxVRRPInt `json:"vrrp-extended interfaces"`
		Enabled bool         `json:"enabled"`
	}

	// AdxVRRPInt describes all the attributes in a vrrp-e show command
	AdxVRRPInt struct {
		Interface        string             `json:"interface"`
		AuthType         string             `json:"auth-type"`
		VRID             *int               `json:"vrid"`
		State            string             `json:"state"`
		AdminStatus      string             `json:"administrative-status"`
		Priority         string             `json:"priority"`
		CurrPriority     string             `json:"current priority"`
		TrackPriority    string             `json:"track-priority"`
		HelloInterval    string             `json:"hello-interval"`
		DeadInterval     string             `json:"dead-interval"`
		CurrDeadInterval string             `json:"current dead-interval"`
		PreemptMode      string             `json:"preempt-mode"`
		VirtualIP        string             `json:"virtual ip address"`
		BackupRouter     string             `json:"backup router"`
		TrackPort        []AdxVRRPTrackPort `json:"track-ports"`
		VRRPMACAddr      string             `json:"vrrp-e_mac_address"`
	}

	// AdxVRRPTrackPort breaks down the details of track-port information in a vrrp-e config
	AdxVRRPTrackPort struct {
		IntNum string `json:"interface"`
		State  string `json:"state"`
	}
)

func (a *AdxVRRPE) Parse(s *string) {
	en := util.RegexpString(vrrpeEnabled, *s)
	if en != "" {
		a.Enabled = false
		return
	}
	a.Enabled = true
	for _, v := range vrrpIntRE.FindAllStringSubmatch(*s, -1) {
		var vrrpInt AdxVRRPInt
		vrrpInt.Interface = v[1]
		vrrpInt.parse(v[2])
		a.Int = append(a.Int, vrrpInt)
	}

}

// Parse method is used to implement type population of a given string
// using parsers to populate the method receiver.
func (v *AdxVRRPInt) parse(s string) {
	v.AuthType = util.RegexpString(authTypeRE, s)
	v.VRID = util.RegexpAtoiPtr(vridRE, s)
	v.State = util.RegexpString(stateRE, s)
	v.AdminStatus = util.RegexpString(adminStatusRE, s)
	v.Priority = util.RegexpString(priorityRE, s)
	v.CurrPriority = util.RegexpString(currPriorityRE, s)
	v.TrackPriority = util.RegexpString(trackPriorityRE, s)
	v.HelloInterval = util.RegexpString(helloIntervalRE, s)
	v.DeadInterval = util.RegexpString(deadIntervalRE, s)
	v.CurrDeadInterval = util.RegexpString(CurrDeadIntervalRE, s)
	v.PreemptMode = util.RegexpString(preemptModeRE, s)
	v.VirtualIP = util.RegexpString(vrrpVIPRE, s)
	v.BackupRouter = util.RegexpString(backupRouterRE, s)
	for _, tp := range tpRE.FindAllStringSubmatch(s, -1) {
		v.TrackPort = append(v.TrackPort, AdxVRRPTrackPort{IntNum: tp[1], State: tp[2]})
	}
	v.VRRPMACAddr = util.RegexpString(vrrpMACRE, s)
}

func VrrpEMAC(i int, vl []AdxVRRPInt) *string {
	for _, ve := range vl {
		if ve.VRID != nil {
			if *ve.VRID == i {
				return &ve.VRRPMACAddr
			}
		}
	}
	return nil
}
