package pkg

import (
	"regexp"
	"strings"

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

type (
	ShCmDevices struct {
		ShCmDevices []*ShCmDevice `json:"devices"`
	}

	ShCmDevice struct {
		Name                 *string `json:"name"`
		MgmtIp               *string `json:"mgmt_ip"`
		ConfigSyncIp         *string `json:"configsync_ip"`
		Hostname             *string `json:"hostname"`
		MirrorIp             *string `json:"mirror_ip"`
		MirrorSecIp          *string `json:"mirror_secondary_ip"`
		MulticastIp          *string `json:"multicast_ip"`
		UnicastIp            *string `json:"unicast_ip"`
		HAState              *string `json:"ha_state"`
		HALoadCapacity       int     `json:"ha_load_capacity"`
		CurrentLoadFactor    int     `json:"current_load_factor"`
		NextActiveLoadFactor int     `json:"next_active_load_factor"`
	}

	ShCmDeviceGroups struct {
		ShCmDeviceGroups []*ShCmDeviceGroup `json:"device_groups"`
	}

	ShCmDeviceGroup struct {
		GroupName        *string `json:"group_name"`
		MemberName       *string `json:"member_name"`
		TimeSincLastSync *string `json:"time_since_last_sync"`
		LastSyncType     *string `json:"last_sync_type"`
		CIDOriginator    *string `json:"cid_originator"`
		CIDTime          *string `json:"cid_time"`
		LssOrginator     *string `json:"lss_originator"`
		LssTime          *string `json:"lss_time"`
	}

	ShCmFailover struct {
		ShCmFailoverStatus *ShCmFailoverStatus `json:"failover_status"`
	}

	ShCmFailoverStatus struct {
		Color   *string `json:"color"`
		Status  *string `json:"status"`
		Summary *string `json:"summary"`
		Details *string `json:"details"`
	}

	ShCmSync struct {
		ShCmSyncStatus *ShCmSyncStatus `json:"sync_status"`
	}

	ShCmSyncStatus struct {
		Color   *string   `json:"color"`
		Status  *string   `json:"status"`
		Summary *string   `json:"summary"`
		Details []*string `json:"details"`
	}

	ShCmTraffic struct {
		ShCmTraffic []*ShCmTrafficGroup `json:"traffic_group"`
	}

	ShCmTrafficGroup struct {
		Name       *string `json:"name"`
		Device     *string `json:"device"`
		Status     *string `json:"status"`
		NextActive *string `json:"next_active"`
	}

	ListCmDevice struct {
		Name               *string `json:"name"`
		MgmtIp             *string `json:"mgmt_ip"`
		ConfigSyncIp       *string `json:"configsync_ip"`
		Hostname           *string `json:"hostname"`
		BaseMac            *string `json:"base_mac"`
		MirrorIp           *string `json:"mirror_ip"`
		MirrorSecIp        *string `json:"mirror_secondary_ip"`
		MulticastInterface *string `json:"multicast_interface"`
		MulticastIp        *string `json:"multicast_ip"`
		MutlicastPort      *string `json:"multicast_port"`
		Version            *string `json:"version"`
		Product            *string `json:"product"`
		Edition            *string `json:"edition"`
		Build              *string `json:"build"`
		MarketingName      *string `json:"marketing_name"`
		PlatformId         *string `json:"platform_id"`
		ChassisId          *string `json:"chassis_id"`
		ActiveModules      *string `json:"active_modules"`
		InactiveModules    *string `json:"inactive_modules"`
		OptionalModules    *string `json:"optional_modules"`
		TimeLimitedMOduels *string `json:"time_limited_modules"`
		Location           *string `json:"location"`
		Contact            *string `json:"contact"`
		Description        *string `json:"description"`
		Comment            *string `json:"comment"`
		TimeZone           *string `json:"time_zone"`
		SelfDevice         *int    `json:"self_device"`
		FailoverState      *string `json:"failover_state"`
	}
)

func (c *ShCmTraffic) Parse(s string) {
	for _, l := range regexp.MustCompile(`(\S+)[ ]+(\S+)[ ]+(\S+)[ ]+(\S+)`).FindAllStringSubmatch(s, -1) {
		if l[1] != "Name" {
			c.ShCmTraffic = append(c.ShCmTraffic, &ShCmTrafficGroup{
				Name:       &l[1],
				Device:     &l[2],
				Status:     &l[3],
				NextActive: &l[4],
			})
		}
	}
}

func (c *ShCmSync) Parse(s string) {
	fo := regexp.MustCompile(`(?i)cm::sync\s+status((.|\n)*?)$`).FindStringSubmatch(s)
	if len(fo) > 0 {

		Color := util.RegexpFindString(regexp.MustCompile(`(?i)color\s+(\S+)`), fo[1])
		Status := util.RegexpFindString(regexp.MustCompile(`(?i)status\s+(\S+)`), fo[1])
		Summary := util.RegexpFindString(regexp.MustCompile(`(?i)summary\s+(\S+.*?)\n`), fo[1])

		c.ShCmSyncStatus = &ShCmSyncStatus{
			Color:   &Color,
			Status:  &Status,
			Summary: &Summary,
			Details: func(s string) []*string {
				var detailList []*string
				if s != "" {
					for _, l := range strings.Split(s, "\n") {
						l := util.RegexpFindString(regexp.MustCompile(`(\S+.*?)$`), l)
						detailList = append(detailList, &l)
					}
				}
				return detailList
			}(util.RegexpFindString(regexp.MustCompile(`(?i)details\s+((.|\n)*?)$`), fo[1])),
		}
	}
}

func (c *ShCmFailover) Parse(s string) {
	fo := regexp.MustCompile(`(?i)cm::failover\s+status((.|\n)*?)$`).FindStringSubmatch(s)
	if len(fo) > 0 {
		Color := util.RegexpFindString(regexp.MustCompile(`(?i)color\s+(\S+)`), fo[1])
		Status := util.RegexpFindString(regexp.MustCompile(`(?i)status\s+(\S+)`), fo[1])
		Summary := util.RegexpFindString(regexp.MustCompile(`(?i)summary\s+(\S+.*?)\n`), fo[1])
		Details := util.RegexpFindString(regexp.MustCompile(`(?i)details\s+(\S+.*?)$`), fo[1])
		c.ShCmFailoverStatus = &ShCmFailoverStatus{
			Color:   &Color,
			Status:  &Status,
			Summary: &Summary,
			Details: &Details,
		}
	}
}

func (c *ShCmDeviceGroups) Parse(s string) {
	for _, r := range regexp.MustCompile(`(?i)(|cm::)device-group((.|\n)*?)(cm::|$)`).FindAllStringSubmatch(s, -1) {
		GroupName := util.RegexpFindString(regexp.MustCompile(`(?i)group\s+name\s+(\S+)`), r[2])
		MemberName := util.RegexpFindString(regexp.MustCompile(`(?i)member\s+name\s+(\S+)`), r[2])
		TimeSincLastSync := util.RegexpFindString(regexp.MustCompile(`(?i)time\s+since\s+last\s+sync\s+\(.*?\)\s+(\S+)`), r[2])
		LastSyncType := util.RegexpFindString(regexp.MustCompile(`(?i)last\s+sync\s+type\s+(\S+)`), r[2])
		CIDOriginator := util.RegexpFindString(regexp.MustCompile(`(?i)cid\s+originator\s+(\S+)`), r[2])
		CIDTime := util.RegexpFindString(regexp.MustCompile(`(?i)cid\s+time\s+(\S+.*?)\n`), r[2])
		LssOrginator := util.RegexpFindString(regexp.MustCompile(`(?i)lss\s+originator\s+(\S+)`), r[2])
		LssTime := util.RegexpFindString(regexp.MustCompile(`(?i)lss\s+time\s+(\S+.*?)($|\n)`), r[2])

		c.ShCmDeviceGroups = append(c.ShCmDeviceGroups, &ShCmDeviceGroup{
			GroupName:        &GroupName,
			MemberName:       &MemberName,
			TimeSincLastSync: &TimeSincLastSync,
			LastSyncType:     &LastSyncType,
			CIDOriginator:    &CIDOriginator,
			CIDTime:          &CIDTime,
			LssOrginator:     &LssOrginator,
			LssTime:          &LssTime,
		})
	}
}

func ParseCmDevice(s string, version string) *ShCmDevices {
	r := new(ShCmDevices)
	if strings.HasPrefix(version, "11") {
		r.Parse11(s)
	} else {
		r.Parse12(s)
	}
	return r
}

func (c *ShCmDevices) Parse11(s string) {
	MgmtIPRE := regexp.MustCompile(`(?i)mgmt ip\s+(\S+)`)
	ConfigSyncIpRE := regexp.MustCompile(`(?i)configsync ip\s+(\S+)`)
	HostnameRE := regexp.MustCompile(`(?i)hostname\s+(\S+)`)
	MirrorIPRE := regexp.MustCompile(`(?i)Mirror Ip\s+(\S+)`)
	MirrorSecIpRE := regexp.MustCompile(`(?i)Mirror Secondary Ip\s+(\S+)`)
	MulticastIpRE := regexp.MustCompile(`(?i)Multicast IP\s+(\S+)`)

	HAStateRE := regexp.MustCompile(`(?i)Failover State\s+(\S+)`)

	for _, r := range regexp.MustCompile(`(?i)(|centmgmt)::device:\s+(\S+)((.|\n)*?)(centmgmt|$)`).FindAllStringSubmatch(s, -1) {
		ShCmDev := &ShCmDevice{
			Name: &r[2],
		}

		if MgmtIP := MgmtIPRE.FindStringSubmatch(r[3]); len(MgmtIP) > 0 {
			ShCmDev.MgmtIp = &MgmtIP[1]
		} else {
			log.WithField("raw", MgmtIP).Debug("MgmtIP not found")
		}

		if ConfigSyncIp := ConfigSyncIpRE.FindStringSubmatch(r[3]); len(ConfigSyncIp) > 0 {
			ShCmDev.ConfigSyncIp = &ConfigSyncIp[1]
		} else {
			log.WithField("raw", ConfigSyncIp).Debug("ConfigSyncIp not found")
		}

		if Hostname := HostnameRE.FindStringSubmatch(r[3]); len(Hostname) > 0 {
			ShCmDev.Hostname = &Hostname[1]
		} else {
			log.WithField("raw", Hostname).Debug("Hostname not found")
		}

		if MirrorIP := MirrorIPRE.FindStringSubmatch(r[3]); len(MirrorIP) > 0 {
			ShCmDev.MirrorIp = &MirrorIP[1]
		} else {
			log.WithField("raw", MirrorIP).Debug("MirrorIP not found")
		}

		if MirrorSecIP := MirrorSecIpRE.FindStringSubmatch(r[3]); len(MirrorSecIP) > 0 {
			ShCmDev.MirrorSecIp = &MirrorSecIP[1]
		} else {
			log.WithField("raw", MirrorSecIP).Debug("MirrorSecIP not found")
		}

		if MulticastIP := MulticastIpRE.FindStringSubmatch(r[3]); len(MulticastIP) > 0 {
			ShCmDev.MulticastIp = &MulticastIP[1]
		} else {
			log.WithField("raw", MulticastIP).Debug("MulticastIP not found")
		}

		if HAState := HAStateRE.FindStringSubmatch(r[3]); len(HAState) > 0 {
			ShCmDev.HAState = &HAState[1]
		} else {
			log.WithField("raw", HAState).Debug("HAState not found")
		}

		c.ShCmDevices = append(c.ShCmDevices, ShCmDev)
	}
}

func (c *ShCmDevices) Parse12(s string) {
	MgmtIPRE := regexp.MustCompile(`(?i)mgmt ip\s+(\S+)`)
	ConfigSyncIpRE := regexp.MustCompile(`(?i)configsync ip\s+(\S+)`)
	HostnameRE := regexp.MustCompile(`(?i)hostname\s+(\S+)`)
	MirrorIPRE := regexp.MustCompile(`(?i)mirroring ip\s+(\S+)`)
	MirrorSecIpRE := regexp.MustCompile(`(?i)mirroring secondary ip\s+(\S+)`)
	MulticastIpRE := regexp.MustCompile(`(?i)failover multicast ip\s+(\S+)`)
	UnicastIPRE := regexp.MustCompile(`(?i)Failover Unicast IP\(s\)\s+(\S+)`)
	HAStateRE := regexp.MustCompile(`(?i)device ha state\s+(\S+)`)
	HALoadCapacityRE := regexp.MustCompile(`(?i)device ha load capacity\s+(\S+)`)
	CurrentLoadFactorRE := regexp.MustCompile(`(?i)device current load factor\s+(\S+)`)
	NextActiveLoadFactorRE := regexp.MustCompile(`(?i)device next active load factor\s+(\S+)`)

	for _, r := range regexp.MustCompile(`(?i)(|centmgmt)::device:\s+(\S+)((.|\n)*?)(centmgmt|$)`).FindAllStringSubmatch(s, -1) {
		ShCmDev := new(ShCmDevice)
		if debug || trace {
			log.SetLevel(logrus.DebugLevel)
		}

		log.Debug("R[3]:", r[3])

		if MgmtIP := MgmtIPRE.FindStringSubmatch(r[3]); len(MgmtIP) > 0 {
			ShCmDev.MgmtIp = &MgmtIP[1]
		} else {
			log.WithField("raw", MgmtIP).Debug("MgmtIP not found")
		}

		if ConfigSyncIp := ConfigSyncIpRE.FindStringSubmatch(r[3]); len(ConfigSyncIp) > 0 {
			ShCmDev.ConfigSyncIp = &ConfigSyncIp[1]
		} else {
			log.WithField("raw", ConfigSyncIp).Debug("ConfigSyncIp not found")
		}

		if Hostname := HostnameRE.FindStringSubmatch(r[3]); len(Hostname) > 0 {
			ShCmDev.Hostname = &Hostname[1]
		} else {
			log.WithField("raw", Hostname).Debug("Hostname not found")
		}

		if MirrorIP := MirrorIPRE.FindStringSubmatch(r[3]); len(MirrorIP) > 0 {
			ShCmDev.MirrorIp = &MirrorIP[1]
		} else {
			log.WithField("raw", MirrorIP).Debug("MirrorIP not found")
		}

		if MirrorSecIP := MirrorSecIpRE.FindStringSubmatch(r[3]); len(MirrorSecIP) > 0 {
			ShCmDev.MirrorSecIp = &MirrorSecIP[1]
		} else {
			log.WithField("raw", MirrorSecIP).Debug("MirrorSecIP not found")
		}

		if MulticastIP := MulticastIpRE.FindStringSubmatch(r[3]); len(MulticastIP) > 0 {
			ShCmDev.MulticastIp = &MulticastIP[1]
		} else {
			log.WithField("raw", MulticastIP).Debug("MulticastIP not found")
		}

		if UnicastIP := UnicastIPRE.FindStringSubmatch(r[3]); len(UnicastIP) > 0 {
			ShCmDev.UnicastIp = &UnicastIP[1]
		} else {
			log.WithField("raw", UnicastIP).Debug("UnicastIP IP not found")
		}

		if HAState := HAStateRE.FindStringSubmatch(r[3]); len(HAState) > 0 {
			ShCmDev.HAState = &HAState[1]
		} else {
			log.WithField("raw", HAState).Debug("HAState not found")
		}

		if HALoadCap := HALoadCapacityRE.FindStringSubmatch(r[3]); len(HALoadCap) > 0 {
			ShCmDev.HALoadCapacity = util.Atoi(HALoadCap[1])
		} else {
			log.WithField("raw", HALoadCap).Debug("HALoadCap not found")
		}

		if CurrentLoad := CurrentLoadFactorRE.FindStringSubmatch(r[3]); len(CurrentLoad) > 0 {
			ShCmDev.CurrentLoadFactor = util.Atoi(CurrentLoad[1])
		} else {
			log.WithField("raw", CurrentLoad).Debug("CurrentLoad not found")
		}

		if NextActiveLoad := NextActiveLoadFactorRE.FindStringSubmatch(r[3]); len(NextActiveLoad) > 0 {
			ShCmDev.NextActiveLoadFactor = util.Atoi(NextActiveLoad[1])
		} else {
			log.WithField("raw", NextActiveLoad).Debug("NextActiveLoad not found")
		}

		c.ShCmDevices = append(c.ShCmDevices, ShCmDev)
	}
}