package pkg

import (
	"regexp"

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

var (
	checkSumRegex        = regexp.MustCompile(`(?i)checksum\s+(\S+)`)
	createdTimeRegex     = regexp.MustCompile(`(?i)create-time\s+(\S+)`)
	createdByRegex       = regexp.MustCompile(`(?i)created-by\s+(\S+)`)
	lastUpdatedTimeRegex = regexp.MustCompile(`(?i)last-update-time\s+(\S+)`)
	modeRegex            = regexp.MustCompile(`(?i)mode\s+([0-9]+)`)
	revisionRegex        = regexp.MustCompile(`(?i)revision\s+([0-9]+)`)
	sizeRegex            = regexp.MustCompile(`(?i)\s+size\s+([0-9]+)`)
	updatedByRegex       = regexp.MustCompile(`(?i)updated-by\s+(\S+)`)
	//cmDeviceGroupRegex      = regexp.MustCompile(`(?i)cm\s+device-group\s+(\S+)\s+{((.|\n)*?)\n}`)
)

type (
	CmCerts struct {
		CmCerts []*CmCert `json:"cm_certs"`
	}

	CmCert struct {
		Name             string `json:"cm_cert"`
		CertKeySize      int    `json:"certificate_key_size"`
		CheckSum         string `json:"checksum"`
		CreateTime       string `json:"create_time"`
		CreatedBy        string `json:"created_by"`
		ExpirationDate   int    `json:"expiration_date"`
		ExpirationString string `json:"expiration_string"`
		Issuer           string `json:"issuer"`
		LastUpdateTime   string `json:"last_update_time"`
		Mode             int    `json:"mode"`
		Revision         int    `json:"revision"`
		SerialNum        int    `json:"serial_number"`
		Size             int    `json:"size"`
		Subject          string `json:"subject"`
		UpdatedBy        string `json:"updated_by"`
		Version          string `json:"version"`
	}

	CmDevices struct {
		CmDevices []*CmDevice `json:"cm_device"`
	}

	CmDevice struct {
		Name            string          `json:"name"`
		ActiveModules   string          `json:"active_modules"`
		BaseMac         string          `json:"base_mac"`
		Build           string          `json:"build"`
		Cert            string          `json:"cert"`
		ChassisId       string          `json:"chassis_id"`
		ConfigSyncIp    string          `json:"configsync_ip"`
		Edition         string          `json:"edition"`
		FailoverState   string          `json:"failover_state"`
		HostName        string          `json:"hostname"`
		InactiveModule  string          `json:"inactive_module"`
		Key             string          `json:"key"`
		ManagementIp    string          `json:"management_ip"`
		MarketingName   string          `json:"marketing_name"`
		MirrorIp        string          `json:"mirror_ip"`
		OptionalModules string          `json:"optional_modules"`
		PlatformId      string          `json:"platform_id"`
		Product         string          `json:"product"`
		SelfDevice      bool            `json:"self_device"`
		TimeZone        string          `json:"time_zone"`
		UnicastAddress  *UnicastAddress `json:"unicast_address"`
		Version         string          `json:"version"`
	}

	UnicastAddress struct {
		EffectiveIp   string `json:"effective_ip"`
		EffectivePort string `json:"effective_port"`
		Ip            string `json:"ip"`
	}

	CmDeviceGroups struct {
		CmDeviceGroups []*CmDeviceGroup `json:"device_groups"`
	}

	CmDeviceGroup struct {
		Name            string   `json:"name"`
		AutoSync        string   `json:"auto_sync"`
		Devices         []string `json:"devices"`
		FullLoadOnSync  bool     `json:"full_load_on_sync"`
		SaveOnAutoSync  bool     `json:"safe_on_auto_sync"`
		Type            string   `json:"type"`
		NetworkFailover string   `json:"network_failover"`
	}

	CmKeys struct {
		CmKeys []*CmKey `json:"cm_keys"`
	}

	CmKey struct {
		Name           string `json:"name"`
		CheckSum       string `json:"checksum"`
		CreateTime     string `json:"create_time"`
		CreatedBy      string `json:"created_by"`
		KeySize        int    `json:"key_size"`
		LastUpdateTime string `json:"last_update_time"`
		Mode           int    `json:"mode"`
		Revision       int    `json:"revision"`
		Size           int    `json:"size"`
		UpdatedBy      string `json:"updated_by"`
	}

	CmTrafficGroups struct {
		CmTrafficGroups []*CmTrafficGroup `json:"traffic_groups"`
	}

	CmTrafficGroup struct {
		Name                string `json:"name"`
		AppService          string `json:"app_service"`
		AutoFailbackEnabled bool   `json:"auto_failback_enabled"`
		AutoFailBackTime    int    `json:"auto_failback_time"`
		DefaultDevice       string `json:"default_device"`
		Description         string `json:"description"`
		HaGroup             string `json:"ha_group"`
		HaLoadFactor        int    `json:"ha_load_factor"`
		HaOrder             string `json:"ha_order"`
		IsFloating          bool   `json:"is_floating"`
		Mac                 string `json:"mac"`
		Partition           string `json:"partition"`
		UnitId              int    `json:"unit_id"`
	}

	CmTrustDomains struct {
		CmTrustDomains []*CmTrustDomain `json:"trust_domains"`
	}

	CmTrustDomain struct {
		Name         string   `json:"name"`
		CaCert       string   `json:"ca_cert"`
		CaCertBundle string   `json:"ca_cert_bundle"`
		CaDevices    []string `json:"devices"`
		CaKey        string   `json:"ca_key"`
		Status       string   `json:"status"`
		TrustGroup   string   `json:"trust_group"`
	}
)

func (c *CmDevices) Parse(s string) {
	for _, r := range regexp.MustCompile(`(?i)cm\s+device\s+(\S+)\s+{((.|\n)*?)\n}`).FindAllStringSubmatch(s, -1) {
		c.CmDevices = append(c.CmDevices, &CmDevice{
			Name:            r[1],
			ActiveModules:   util.RegexpString(regexp.MustCompile(`(?i)active-modules\s+{\s+"(.*?)"\s+}`), r[2]),
			BaseMac:         util.RegexpString(regexp.MustCompile(`(?i)base-mac\s+(\S+)`), r[2]),
			Build:           util.RegexpString(regexp.MustCompile(`(?i)build\s+(\S+)`), r[2]),
			Cert:            util.RegexpString(regexp.MustCompile(`(?i)cert\s+(\S+)`), r[2]),
			ChassisId:       util.RegexpString(regexp.MustCompile(`(?i)chassis-id\s+(\S+)`), r[2]),
			ConfigSyncIp:    util.RegexpString(regexp.MustCompile(`(?i)configsync-ip\s+(\S+)`), r[2]),
			Edition:         util.RegexpString(regexp.MustCompile(`(?i)edition\s+"(.*?)"`), r[2]),
			FailoverState:   util.RegexpString(regexp.MustCompile(`(?i)failover-state\s+(\S+)`), r[2]),
			HostName:        util.RegexpString(HOSTNAMERE, r[2]),
			InactiveModule:  util.RegexpString(regexp.MustCompile(`(?i)inactive-modules\s+{\s+"(.*?)"\s}`), r[2]),
			Key:             util.RegexpString(regexp.MustCompile(`(?i)key\s+(\S+)`), r[2]),
			ManagementIp:    util.RegexpString(regexp.MustCompile(`(?i)management-ip\s+(\S+)`), r[2]),
			MarketingName:   util.RegexpString(regexp.MustCompile(`(?i)marketing-name\s+(\S+)`), r[2]),
			MirrorIp:        util.RegexpString(regexp.MustCompile(`(?i)mirror-ip\s+(\S+)`), r[2]),
			OptionalModules: util.RegexpString(regexp.MustCompile(`(?i)optional-modules\s+{\s+"(.*?)"\s+}`), r[2]),
			PlatformId:      util.RegexpString(regexp.MustCompile(`(?i)platform-id\s+(\S+)`), r[2]),
			Product:         util.RegexpString(regexp.MustCompile(`(?i)product\s+(\S+)`), r[2]),
			SelfDevice:      regexp.MustCompile(`(?i)self-device\s+(true)`).MatchString(r[2]),
			TimeZone:        util.RegexpString(regexp.MustCompile(`(?i)time-zone\s+(\S+)`), r[2]),
			UnicastAddress: func() *UnicastAddress {
				ua := regexp.MustCompile(`(?i)unicast-address\s+{((.|\n)*?)}`).FindStringSubmatch(r[2])
				if len(ua) == 0 {
					return nil
				}
				return &UnicastAddress{
					EffectiveIp:   util.RegexpString(regexp.MustCompile(`(?i)effective-ip\s+(\S+)`), ua[1]),
					EffectivePort: util.RegexpString(regexp.MustCompile(`(?i)effective-port\s+(\S+)`), ua[1]),
					Ip:            util.RegexpString(regexp.MustCompile(`(?i)\s+ip\s+(\S+)`), ua[1]),
				}
			}(),
			Version: util.RegexpString(versRegex, r[2]),
		})
	}
}

func (c *CmTrustDomains) Parse(s string) {
	for _, r := range regexp.MustCompile(`(?i)cm\s+trust-domain\s+(\S+)\s+{((.|\n)*?)\n}`).FindAllStringSubmatch(s, -1) {
		c.CmTrustDomains = append(c.CmTrustDomains, &CmTrustDomain{
			Name:         r[1],
			CaCert:       util.RegexpString(regexp.MustCompile(`(?i)ca-cert\s+(\S+)`), r[2]),
			CaCertBundle: util.RegexpString(regexp.MustCompile(`(?i)ca-cert-bundle\s+(\S+)`), r[2]),
			CaDevices: func() (devlist []string) {
				dev := regexp.MustCompile(`(?i)ca-devices\s+{((.|\n)*?)}`).FindStringSubmatch(s)
				if len(dev) != 0 {
					for _, d := range regexp.MustCompile(`(\S+)`).FindStringSubmatch(dev[1]) {
						devlist = append(devlist, d)
					}
				}
				return
			}(),
			CaKey:      util.RegexpString(regexp.MustCompile(`(?i)ca-key\s+(\S+)`), r[2]),
			Status:     util.RegexpString(regexp.MustCompile(`(?i)status\s+(\S+)`), r[2]),
			TrustGroup: util.RegexpString(regexp.MustCompile(`(?i)trust-group\s+(\S+)`), r[2]),
		})
	}
}

func ParseTrafficGroupConfig(s string) *CmTrafficGroups {
	c := new(CmTrafficGroups)
	c.Parse(s)
	return c
}

func (c *CmTrafficGroups) Parse(s string) {
	for _, r := range regexp.MustCompile(`(?i)cm\s+traffic-group\s+(\S+)\s+{((.|\n)*?)\n}`).FindAllStringSubmatch(s, -1) {
		c.CmTrafficGroups = append(c.CmTrafficGroups, &CmTrafficGroup{
			Name:                r[1],
			AppService:          util.RegexpString(regexp.MustCompile(`(?i)app-service\s+(\S+)`), r[2]),
			AutoFailbackEnabled: regexp.MustCompile(`(?i)auto-failback-enabled\s+(true)`).MatchString(r[2]),
			AutoFailBackTime:    util.Atoi(util.RegexpString(regexp.MustCompile(`(?i)auto-failback-time\s+([0-9]+)`), r[2])),
			DefaultDevice:       util.RegexpString(regexp.MustCompile(`(?i)default-device\s+(\S+)`), r[2]),
			Description:         util.RegexpString(descriptionRegex, r[2]),
			HaGroup:             util.RegexpString(regexp.MustCompile(`(?i)ha-group\s+(\S+)`), r[2]),
			HaOrder:             util.RegexpString(regexp.MustCompile(`(?i)ha-order\s+((.|\n)*?)`), r[2]),
			HaLoadFactor:        util.Atoi(util.RegexpString(regexp.MustCompile(`(?i)ha-load-factor\s+([0-9]+)`), r[2])),
			IsFloating:          regexp.MustCompile(`(?i)is-floating\s+(true)`).MatchString(r[2]),
			Mac:                 util.RegexpString(regexp.MustCompile(`(?i)mac\s+(\S+)`), r[2]),
			Partition:           util.RegexpString(partitionRegex, r[2]),
			UnitId:              util.Atoi(util.RegexpString(regexp.MustCompile(`(?i)unit-id\s+([0-9]+)`), r[2])),
		})
	}

}

func (c *CmCerts) Parse(s string) {
	for _, r := range regexp.MustCompile(`(?i)cm\s+cert\s+(\S+)\s+{((.|\n)*?)}`).FindAllStringSubmatch(s, -1) {
		c.CmCerts = append(c.CmCerts, &CmCert{
			Name:             r[1],
			CertKeySize:      util.Atoi(util.RegexpString(regexp.MustCompile(`(?i)certificate-key-size\s+([0-9]+)`), r[2])),
			CheckSum:         util.RegexpString(checkSumRegex, r[2]),
			CreateTime:       util.RegexpString(createdTimeRegex, r[2]),
			CreatedBy:        util.RegexpString(createdByRegex, r[2]),
			ExpirationDate:   util.Atoi(util.RegexpString(regexp.MustCompile(`(?i)expiration-date\s+([0-9]+)`), r[2])),
			ExpirationString: util.RegexpString(regexp.MustCompile(`(?i)expiration-string\s+(\S+)`), r[2]),
			Issuer:           util.RegexpString(regexp.MustCompile(`(?i)issuer\s+(\S+)`), r[2]),
			LastUpdateTime:   util.RegexpString(lastUpdatedTimeRegex, r[2]),
			Mode:             util.Atoi(util.RegexpString(modeRegex, r[2])),
			Revision:         util.Atoi(util.RegexpString(revisionRegex, r[2])),
			SerialNum:        util.Atoi(util.RegexpString(regexp.MustCompile(`(?i)serial-number\s+([0-9]+)`), r[2])),
			Size:             util.Atoi(util.RegexpString(sizeRegex, r[2])),
			Subject:          util.RegexpString(regexp.MustCompile(`(?i)subject\s+(\S+)`), r[2]),
			UpdatedBy:        util.RegexpString(updatedByRegex, r[2]),
			Version:          util.RegexpString(versRegex, r[2]),
		})
	}
}

func (c *CmDeviceGroups) Parse(s string) {
	for _, r := range regexp.MustCompile(`(?i)cm\s+device-group\s+(\S+)\s+{((.|\n)*?)\n}`).FindAllStringSubmatch(s, -1) {
		c.CmDeviceGroups = append(c.CmDeviceGroups, &CmDeviceGroup{
			Name:            r[1],
			AutoSync:        util.RegexpString(regexp.MustCompile(`(?i)auto-sync\s+(\S+)`), r[2]),
			FullLoadOnSync:  regexp.MustCompile(`(?i)full-load-on-sync\s+(true)`).MatchString(r[2]),
			SaveOnAutoSync:  regexp.MustCompile(`(?i)save-on-auto-sync\s+(true)`).MatchString(r[2]),
			Type:            util.RegexpString(regexp.MustCompile(`(?i)type\s+(\S+)`), r[2]),
			NetworkFailover: util.RegexpString(regexp.MustCompile(`(?i)network-failover\s+(\S+)`), r[2]),
			Devices: func() (devList []string) {
				d := regexp.MustCompile(`(?i)devices\s+{((.|\n)*?)\n\s+}`).FindStringSubmatch(r[2])
				if len(d) == 0 {
					return
				}
				for _, r := range regexp.MustCompile(`(\S+)\s+{\s+}`).FindAllStringSubmatch(d[1], -1) {
					devList = append(devList, r[1])
				}
				return
			}(),
		})
	}
}

func (c *CmKeys) Parse(s string) {
	for _, r := range regexp.MustCompile(`(?i)cm\s+key\s+(\S+)\s+{((.|\n)*?)\n}`).FindAllStringSubmatch(s, -1) {
		c.CmKeys = append(c.CmKeys, &CmKey{
			Name:           r[1],
			CheckSum:       util.RegexpString(checkSumRegex, r[2]),
			CreateTime:     util.RegexpString(createdTimeRegex, r[2]),
			CreatedBy:      util.RegexpString(createdByRegex, r[2]),
			KeySize:        util.Atoi(util.RegexpString(regexp.MustCompile(`(?i)key-size\s+([0-9]+)`), r[2])),
			LastUpdateTime: util.RegexpString(lastUpdatedTimeRegex, r[2]),
			Mode:           util.Atoi(util.RegexpString(modeRegex, r[2])),
			Revision:       util.Atoi(util.RegexpString(revisionRegex, r[2])),
			Size:           util.Atoi(util.RegexpString(sizeRegex, r[2])),
			UpdatedBy:      util.RegexpString(updatedByRegex, r[2]),
		})
	}
}

func (c *CmTrafficGroups) TrafficGroupMAC(g string) *string {
	return TrafficGroupMAC(g, c.CmTrafficGroups)
}

func TrafficGroupMAC(g string, tg []*CmTrafficGroup) *string {
	for _, t := range tg {
		if t.Name == g {
			return &t.Mac
		}
	}
	return nil
}