package asaModels

import (
	"fmt"
	"regexp"

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

var (
	TUNNELTYPEGRPRE = regexp.MustCompile(`(?i)tunnel-group\s+(\S+)\s+type\s+(remote-access|ipsec-l2l|ipsec-ra|webvpn)`)
	PRESHARERE      = regexp.MustCompile(`(?i)ikev1 pre-shared-key\s+(.*?)(\n|$)`)
	PRESHAREREV2LOCAL   = regexp.MustCompile(`(?i)ikev2 local-authentication pre-shared-key\s+(.*?)(\n|$)`)
	PRESHAREREV2REMOTE  = regexp.MustCompile(`(?i)ikev2 remote-authentication pre-shared-key\s+(.*?)(\n|$)`)
	AUTHSRVRE       = regexp.MustCompile(`(?i)authentication-server-group\s+(\S+)`)
	DFLTGRPRE       = regexp.MustCompile(`(?i)default-group-policy\s+(\S+)`)
	RATUNNELTYPESRE = regexp.MustCompile(`(?i)(remote-access|ipsec-ra|webvpn)`)
)

type (
	TunnelGroups struct {
		TunnelGroups []*TunnelGroup `json:"tunnel_groups"`
	}

	TunnelGroup struct {
		Name              string             `json:"name"`
		Type              string             `json:"type"`
		IpsecAttributes   *IpsecAttributes   `json:"ipsec_attributes"`
		GeneralAttributes *GeneralAttributes `json:"general_attributes"`
	}

	IpsecAttributes struct {
		PreShared *string `json:"pre_shared_key"`
		PreSharedIkeV2Local *string `json:"ikvev2_local_pre_shared_key"`
		PreSharedIkeV2Remote *string `json:"ikvev2_remote_pre_shared_key"`
	}

	GeneralAttributes struct {
		AuthServer   *string `json:"authentication_server_group"`
		DefaultGroup *string `json:"default_group_policy"`
	}
)

func (t *TunnelGroups) Parse(s string) {
	match := TUNNELTYPEGRPRE.FindAllStringSubmatch(s, -1)
	if len(match) == 0 {
		return
	}

	for _, tunnel := range match {
		ipsecRe := regexp.MustCompile(fmt.Sprintf(`(?i)tunnel-group\s+%s\s+ipsec-attributes\n(((.|\n)*?))(\n[a-z]|$)`, tunnel[1]))
		generalRe := regexp.MustCompile(fmt.Sprintf(`(?i)tunnel-group\s+%s\s+general-attributes\n(((.|\n)*?))(\n[a-z]|$)`, tunnel[1]))
		ipsecm := ipsecRe.FindStringSubmatch(s)
		generalm := generalRe.FindStringSubmatch(s)
		t.TunnelGroups = append(t.TunnelGroups, &TunnelGroup{
			Name: tunnel[1],
			Type: tunnel[2],
			IpsecAttributes: &IpsecAttributes{
				PreShared: func() *string {
					if len(ipsecm) == 0 {
						return nil
					}
					return util.RegexpFindStringPtr(PRESHARERE, ipsecm[1])
				}(),
				PreSharedIkeV2Local: func() *string {
					if len(ipsecm) == 0 {
						return nil
					}
					return util.RegexpFindStringPtr(PRESHAREREV2LOCAL, ipsecm[1])
				}(),
				PreSharedIkeV2Remote: func() *string {
					if len(ipsecm) == 0 {
						return nil
					}
					return util.RegexpFindStringPtr(PRESHAREREV2REMOTE, ipsecm[1])
				}(),
			},
			GeneralAttributes: &GeneralAttributes{
				AuthServer: func() *string {
					if len(generalm) == 0 {
						return nil
					}
					return util.RegexpFindStringPtr(AUTHSRVRE, generalm[1])
				}(),
				DefaultGroup: func() *string {
					if len(generalm) == 0 {
						return nil
					}
					return util.RegexpFindStringPtr(DFLTGRPRE, generalm[1])
				}(),
			},
		})
	}
}

func (t *TunnelGroups) RemoteTunnelNames() []string {
	return RemoteTunnelNames(t.TunnelGroups)
}

func RemoteTunnelNames(t []*TunnelGroup) (tn []string) {
	for _, t := range RemoteTunnels(t) {
		tn = append(tn, t.Name)
	}
	return
}

func (t *TunnelGroups) RemoteTunnels() []*TunnelGroup {
	return RemoteTunnels(t.TunnelGroups)
}

func (t *TunnelGroups) L2LTunnels() []*TunnelGroup {
	return L2LTunnels(t.TunnelGroups)

}

func RemoteTunnels(tg []*TunnelGroup) (rt []*TunnelGroup) {
	for _, t := range tg {
		if RATUNNELTYPESRE.MatchString(t.Type) {
			rt = append(rt, t)
		}
	}
	return
}

func L2LTunnels(tg []*TunnelGroup) (rt []*TunnelGroup) {
	for _, t := range tg {
		if t.Type == "ipsec-l2l" {
			rt = append(rt, t)
		}
	}
	return
}