package asaModels

import (
	"fmt"
	"regexp"
	"strings"

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

type (
	GroupPolicies struct {
		GroupPolicies []*GroupPolicy `json:"group_policies"`
	}

	GroupPolicy struct {
		Name       *string          `json:"name"`
		Type       *string          `json:"type"`
		Attributes *GroupAttributes `json:"attributes"`
	}

	GroupAttributes struct {
		VPNTunnelProto     []string `json:"vpn_tunnel_protocol"`
		SplitTunnelPolicy  *string  `json:"split_tunnel_policy"`
		SplitTunnelNetwork *string  `json:"split_tunnel_network_list"`
		VpnFilter          *string  `json:"vpn_filter"`
		DefaultDomain      *string  `json:"default_domain"`
		Nem                bool     `json:"nem"`
		AddressPools       *string  `json:"address_pools"`
		PasswordStore      bool     `json:"password_storage"`
		WebVPN             webVPN   `json:"webvpn"`
	}

	webVPN struct {
		AnyconnectModules  []string `json:"anyconnect_modules"`
		AnyconnectProfiles []string `json:"anyconnect_profiles"`
	}
)

func (g *GroupPolicies) Parse(s string) {
	groupPolicies := regexp.MustCompile(`(?i)group-policy\s+(\S+)\s+(internal|external)`).FindAllStringSubmatch(s, -1)
	// 1 = name
	// 2 = internal/external
	for _, groupPolicy := range groupPolicies {
		groupAttributes := regexp.MustCompile(fmt.Sprintf(`(?i)group-policy\s+%s\s+attributes\n((.|\n)*?)(\n[a-z]|$)`, groupPolicy[1])).FindStringSubmatch(s)
		// 0 = whole attributes
		if len(groupAttributes) == 0 {
			g.GroupPolicies = append(g.GroupPolicies, &GroupPolicy{
				Name: &groupPolicy[1],
				Type: &groupPolicy[2],
			})
			continue
		}

		wv := webVPN{}

		res := regexp.MustCompile(`(?i)anyconnect modules value (.*)\n`).FindAllStringSubmatch(groupAttributes[0], -1)
		for _, moduleLine := range res {
			wv.AnyconnectModules = append(wv.AnyconnectModules, moduleLine[1])
		}

		res = regexp.MustCompile(`(?i)anyconnect profiles value (.*)\n`).FindAllStringSubmatch(groupAttributes[0], -1)
		for _, profileLine := range res {
			wv.AnyconnectProfiles = append(wv.AnyconnectProfiles, profileLine[1])
		}

		g.GroupPolicies = append(g.GroupPolicies, &GroupPolicy{
			Name: &groupPolicy[1],
			Type: &groupPolicy[2],
			Attributes: &GroupAttributes{
				VPNTunnelProto: func() (tp []string) {
					proto := util.RegexpFindStringPtr(regexp.MustCompile(`(?i)vpn-tunnel-protocol\s+(\S+)`), groupAttributes[1])
					if proto == nil {
						return
					}
					return strings.Split(*proto, " ")
				}(),
				SplitTunnelPolicy:  util.RegexpFindStringPtr(regexp.MustCompile(`(?i)split-tunnel-policy\s+(\S+)`), groupAttributes[0]),
				SplitTunnelNetwork: util.RegexpFindStringPtr(regexp.MustCompile(`(?i)split-tunnel-network-list\s+value\s+(\S+)`), groupAttributes[0]),
				VpnFilter:          util.RegexpFindStringPtr(regexp.MustCompile(`(?i)vpn-filter\s+(\S+)`), groupAttributes[0]),
				DefaultDomain:      util.RegexpFindStringPtr(regexp.MustCompile(`(?i)default-domain\s+value\s+(\S+)`), groupAttributes[0]),
				Nem:                regexp.MustCompile(`(?i)nem\s+(enable)`).MatchString(groupAttributes[0]),
				AddressPools:       util.RegexpFindStringPtr(regexp.MustCompile(`(?i)address-pools\s+value\s+(\S+)`), groupAttributes[0]),
				PasswordStore:      regexp.MustCompile(`(?i)password-storage\s+(enable)`).MatchString(groupAttributes[0]),
				WebVPN:             wv,
			},
		})
	}
}

func (g *GroupPolicies) FindPolicy(name string) *GroupPolicy {
	return FindPolicy(name, g.GroupPolicies)
}

func FindPolicy(name string, gp []*GroupPolicy) *GroupPolicy {
	for _, g := range gp {
		if g.Name != nil {
			if *g.Name == name {
				return g
			}
		}
	}
	return nil
}