package parsers

import (
	"regexp"
	"strconv"

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

var (
	bpMaskRe         = regexp.MustCompile(`(?i)server\s+select-bp-mask\s+(\S+)`)
	forceDeleteRe    = regexp.MustCompile(`(?i)(server\s+force-delete)`)
	noFastBringUpRe  = regexp.MustCompile(`(?i)(server\s+no-fast-bringup)`)
	simpleSSLRe      = regexp.MustCompile(`(?i)(no\s+server\s+use-simple-ssl-health-check)`)
	spRe             = regexp.MustCompile(`(?i)server\s+symmetric-port\s+ethernet\s+([0-9]+)\s+vlan-id\s+([0-9]+)`)
	csRe             = regexp.MustCompile(`(?i)config-sync\s+sender\s+ethernet\s+([0-9]+)\s+mac\s+(.*?)\s+vlan-id\s+([0-9+])`)
	serverPortsRe    = regexp.MustCompile(`(?i)(|s)erver\s+port\s+(\S+)((.|\n)*?)(\n\S|!)`)
	sessionSyncRe    = regexp.MustCompile(`(?i)(session-sync)`)
	bringUpRetriesRe = regexp.MustCompile(`(?i)bringup-retries\s+([0-9]+)`)
	l4BringUpRe      = regexp.MustCompile(`(?i)l4-bringup-interva\s+([0-9]+)`)
	l7BringUpRe      = regexp.MustCompile(`(?i)l7-bringup-interval\s+([0-9]+)`)
	tcpRe            = regexp.MustCompile(`(?i)(tcp)`)
	udpRe            = regexp.MustCompile(`(?i)(udp)`)
)

type (
	// Server type is the parsed struct data for an ADX real-server
	Server struct {
		ServerPorts      []ServerPort     `json:"server_ports"`
		BpMask           string           `json:"bp_mask"`
		ForceDelete      bool             `json:"force_delete"`
		NoFastBringUp    bool             `json:"no_fast_bringup"`
		SimpleSSLHealth  bool             `json:"use_simple_ssl_health_check"`
		SymmetricPort    SymmetricPort    `json:"symmetric_port"`
		ConfigSyncSender ConfigSyncSender `json:"config_sync_sender"`
	}

	// ServerPort is a listing of port assignment data for a real-server
	ServerPort struct {
		Port           string `json:"port"`
		SessionSync    bool   `json:"session_sync"`
		BringUpRetries *int   `json:"bringup_retries"`
		L4BringUp      *int   `json:"l4_bringup_interval"`
		L7BringUp      *int   `json:"l7_bringup_interval"`
		Tcp            bool   `json:"tcp"`
		Udp            bool   `json:"udp"`
	}

	// SymmetricPort ethernet configuration data
	SymmetricPort struct {
		Ethernet *int `json:"ethernet"`
		VlanId   *int `json:"vlan_id"`
	}

	// ConfigSyncSender parses details about the ADX config-sync config
	ConfigSyncSender struct {
		Ethernet *int   `json:"ethernet"`
		Mac      string `json:"mac"`
		VlanId   *int   `json:"vlan_id"`
	}
)

// Parse method is used to implement type population of a given string
// using parsers to populate the method receiver.
func (S *Server) Parse(s string) {
	S.ServerPorts = parseServerPort(s)
	S.BpMask = util.RegexpFindString(bpMaskRe, s)
	S.ForceDelete = forceDeleteRe.MatchString(s)
	S.NoFastBringUp = noFastBringUpRe.MatchString(s)
	S.SimpleSSLHealth = !simpleSSLRe.MatchString(s)
	S.SymmetricPort = parseSymPort(s)
	S.ConfigSyncSender = parseConfigSyncSender(s)

}

func parseSymPort(s string) SymmetricPort {
	sp := spRe.FindStringSubmatch(s)
	if sp != nil {
		e, _ := strconv.Atoi(sp[1])
		v, _ := strconv.Atoi(sp[2])
		return SymmetricPort{
			Ethernet: &e,
			VlanId:   &v,
		}
	}
	return SymmetricPort{}
}

func parseConfigSyncSender(s string) ConfigSyncSender {
	cs := csRe.FindStringSubmatch(s)
	if cs != nil {
		return ConfigSyncSender{
			Ethernet: func(s string) *int {
				i, err := strconv.Atoi(s)
				if err != nil {
					return nil
				}
				return &i
			}((cs)[1]),
			Mac: (cs)[2],
			VlanId: func(s string) *int {
				i, err := strconv.Atoi(s)
				if err != nil {
					return nil
				}
				return &i
			}((cs)[3]),
		}
	}
	return ConfigSyncSender{}
}

func parseServerPort(s string) (sp []ServerPort) {
	for _, p := range serverPortsRe.FindAllStringSubmatch(s, -1) {
		sp = append(sp, ServerPort{
			Port:           p[2],
			SessionSync:    sessionSyncRe.MatchString(p[3]),
			BringUpRetries: regexpAtoi(*bringUpRetriesRe, p[3]),
			L4BringUp:      regexpAtoi(*l4BringUpRe, p[3]),
			L7BringUp:      regexpAtoi(*l7BringUpRe, p[3]),
			Tcp:            tcpRe.MatchString(p[3]),
			Udp:            udpRe.MatchString(p[3]),
		})
	}
	return
}
