package pkg

import (
	"fmt"
	"regexp"

	"github.com/sirupsen/logrus"
)

func (f5 *F5) PopulateProfiles(name, profileType, partition string) error {
	f5.log.WithFields(logrus.Fields{
		"name":        name,
		"profileType": profileType,
		"partition":   partition,
	}).Debug("PopulateProfiles() called")
	var profileTypes []string

	// If the caller only wants a specific profile type, use it
	if profileType != "" {
		profileTypes = []string{profileType}
	} else {
		// otherwise use them all
		profileTypes = []string{ // uncommented ones have active parsers
			"analytics",             // Virtual server analytics profile configuration
			"certificate-authority", // Virtual server Certificate Authority profile configuration.
			"classification",        // Virtual server classification profile configuration
			"client-ldap",           // Virtual server Client LDAP traffic profile configuration
			"client-ssl",            // Virtual server client-side proxy SSL profile configuration
			"dhcpv4",                // Dynamic Host Configuration Protocol, DHCPv4, profile to manage DHCPv4 network traffic.
			"dhcpv6",                // Dynamic Host Configuration Protocol, DHCPv6, profile to manage DHCPv6 network traffic.
			"diameter",              // Virtual server Diameter traffic profile configuration
			"dns",                   // Virtual server DNS traffic profile configuration
			"dns-logging",           // High-speed logging settings for the DNS profile.
			"fasthttp",              // Virtual server Fast HTTP traffic profile configuration
			"fastl4",                // Virtual server FastL4 traffic profile configuration
			"fix",                   // Virtual server Financial Information eXchange(FIX) profile configuration
			"ftp",                   // Virtual server FTP traffic profile configuration
			"gtp",                   // Virtual server GTP traffic profile configuration
			"html",                  // Virtual server HTML profile configuration
			"http",                  // Virtual server HTTP traffic profile configuration
			"http-compression",      // Virtual server HTTP compression profile configuration
			"http2",                 // Virtual server HTTP/2 traffic profile configuration
			"icap",                  // Virtual server Internet Content Adaptation Protocol (ICAP) profile configuration
			"iiop",                  // Virtual server IIOP traffic profile configuration
			"ipother",               // Virtual server IPOTHER for non-TCP and non-UDP traffic profile configuration
			"mblb",                  // MBLB profile configuration (experimental)
			"mssql",                 // Virtual server MSSQL profile configuration
			"ntlm",                  // Virtual server NT Lan Manager profile configuration
			"ocsp-stapling-params",  // OCSP Stapling Parameters for clientssl profiles. This object should be associated with a cert-key-chain object in a clientssl profile.
			"one-connect",           // Virtual server OneConnect profile configuration
			"pptp",                  // Virtual server Point to Point Tunneling Protocol (PPTP) profile configuration.
			"qoe",                   // Virtual server Quality of Experience profile configuration
			"radius",                // Virtual server Radius traffic profile configuration
			"request-adapt",         // Virtual server HTTP request adaptation profile configuration
			"request-log",           // Virtual server request logging profile configuration
			"response-adapt",        // Virtual server HTTP response adaptation profile configuration
			"rewrite",               // Virtual server Rewrite profile configuration
			"rtsp",                  // Virtual server RTSP traffic profile configuration
			"sctp",                  // Virtual server SCTP traffic profile configuration
			"server-ldap",           // Virtual server Server LDAP traffic profile configuration
			"server-ssl",            // Virtual server server-side proxy SSL profile configuration
			"sip",                   // Virtual server SIP traffic profile configuration
			"smtps",                 // Virtual server SMTPs traffic profile configuration
			"socks",                 // Virtual server SOCKS traffic profile configuration
			"spdy",                  // Virtual server SPDY traffic profile configuration
			"statistics",            // Virtual server custom statistics configuration
			"stream",                // Virtual server Stream traffic profile configuration
			"tcp",                   // Virtual server TCP traffic profile configuration
			"tcp-analytics",         // Virtual server TCP Analytics profile configuration
			"tftp",                  // Virtual server TFTP traffic profile configuration
			"udp",                   // Virtual server UDP traffic profile configuration
			"web-acceleration",      // Virtual server Web Acceleration profile configuration
			"websocket",             // Virtual server WebSockets traffic profile configuration
			"xml",                   // Virtual server XML configuration
		}
	}

	ProfileList, err := regexp.Compile(`ltm profile \S+ (\S+) {\n(?:\s+(?:.*)\n)*`)
	if err != nil {
		return err
	}

	// Initialize the maps
	f5.Config.Profiles.Init()

	errMsg := "error parsing %s profile: %s"

	for _, profileType := range profileTypes {
		// Step 1) Get list of all profiles
		c := fmt.Sprintf("list ltm profile %s %s", profileType, ltmComponent(name, partition))
		cmd, err := f5.sshClient.PostCommand(c, defaultPrompt, defaultTimeout)
		if err != nil {
			return err
		}
		names := ProfileList.FindAllStringSubmatch(*cmd.Response, -1)

		// Step 2) get details of each profile
		for _, profileName := range names {
			c, err := f5.sshClient.PostCommand(fmt.Sprintf("list ltm profile %s %s all-properties", profileType, ltmComponent(profileName[1], partition)), defaultPrompt, defaultTimeout)
			if err != nil {
				return fmt.Errorf("error running command on f5: %s", err.Error())
			}
			switch profileType {
			case "analytics":
				p, err := ParseAnalyticsProfile(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.Analytics[profileName[1]] = p
			case "certificate-authority":
				p, err := ParseCertificateAuthorityProfile(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.CertificateAuthority[profileName[1]] = p
			case "classification":
				p, err := ParseClassificationProfile(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.Classification[profileName[1]] = p
			case "client-ldap":
				p, err := ParseClientLDAPProfile(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.ClientLDAP[profileName[1]] = p
			case "client-ssl":
				p, err := ParseClientSSLProfile(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.ClientSSL[profileName[1]] = p
			case "dhcpv4":
				p, err := ParseDHCPv4Profile(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.DHCPv4[profileName[1]] = p
			case "dhcpv6":
				p, err := ParseDHCPv6Profile(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.DHCPv6[profileName[1]] = p
			case "diameter":
				p, err := ParseDiameterProfile(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.Diameter[profileName[1]] = p
			case "dns":
				p, err := ParseDNSProfile(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.DNS[profileName[1]] = p
			case "dns-logging":
				p, err := ParseDNSLogging(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.DNSLogging[profileName[1]] = p
			case "fasthttp":
				p, err := ParseFastHTTPProfile(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.FastHTTP[profileName[1]] = p
			case "fastl4":
				p, err := ParseFastL4Profile(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.FastL4[profileName[1]] = p
			case "fix":
				p, err := ParseFixProfile(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.Fix[profileName[1]] = p
			case "ftp":
				p, err := ParseFTPProfile(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.FTP[profileName[1]] = p
			case "gtp":
				p, err := ParseGTP(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.GTP[profileName[1]] = p
			case "html":
				p, err := ParseHTML(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.HTML[profileName[1]] = p
			case "http":
				p, err := ParseHTTPProfile(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.HTTP[profileName[1]] = p
			case "http-compression":
				p, err := ParseHTTPCompression(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.HTTPCompression[profileName[1]] = p
			case "http2":
				p, err := ParseHTTP2(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.HTTP2[profileName[1]] = p
			case "icap":
				p, err := ParseICAP(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.ICAP[profileName[1]] = p
			case "iiop":
				p, err := ParseIIOP(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.IIOP[profileName[1]] = p
			case "ipother":
				p, err := ParseIPOther(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.IPOther[profileName[1]] = p
			case "mblb":
				p, err := ParseMBLB(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.MBLB[profileName[1]] = p
			case "mssql":
				p, err := ParseMSSQL(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.MSSQL[profileName[1]] = p
			case "ntlm":
				p, err := ParseNTLM(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.NTLM[profileName[1]] = p
			case "ocsp-stapling-params":
				p, err := ParseOCSPStaplingParams(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.OCSPStaplingParams[profileName[1]] = p
			case "one-connect":
				p, err := ParseOneConnectProfile(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.OneConnect[profileName[1]] = p
			case "pptp":
				p, err := ParsePPTP(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.PPTP[profileName[1]] = p
			case "qoe":
				p, err := ParseQOE(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.QOE[profileName[1]] = p
			case "radius":
				p, err := ParseRadius(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.Radius[profileName[1]] = p
			case "request-adapt":
				p, err := ParseRequestAdapt(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.RequestAdapt[profileName[1]] = p
			case "request-log":
				p, err := ParseRequestLog(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.RequestLog[profileName[1]] = p
			case "response-adapt":
				p, err := ParseResponseAdapt(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.ResponseAdapt[profileName[1]] = p
			case "rewrite":
				p, err := ParseRewrite(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.Rewrite[profileName[1]] = p
			case "rtsp":
				p, err := ParseRTSP(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.RTSP[profileName[1]] = p
			case "sctp":
				p, err := ParseSCTP(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.SCTP[profileName[1]] = p
			case "server-ldap":
				p, err := ParseServerLDAP(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.ServerLDAP[profileName[1]] = p
			case "server-ssl":
				p, err := ParseServerSSLProfile(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.ServerSSL[profileName[1]] = p
			case "sip":
				p, err := ParseSIPProfile(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.SIP[profileName[1]] = p
			case "smtps":
				p, err := ParseSMTPS(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.SMTPS[profileName[1]] = p
			case "socks":
				p, err := ParseSocksProfile(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.Socks[profileName[1]] = p
			case "spdy":
				p, err := ParseSPDY(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.Spdy[profileName[1]] = p
			case "statistics":
				p, err := ParseStatisticsProfile(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.Statistics[profileName[1]] = p
			case "stream":
				p, err := ParseStream(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.Stream[profileName[1]] = p
			case "tcp":
				p, err := ParseTCPProfile(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.TCP[profileName[1]] = p
			case "tcp-analytics":
				p, err := ParseTCPAnalytics(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.TCPAnalytics[profileName[1]] = p
			case "tftp":
				p, err := ParseTFTP(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.TFTP[profileName[1]] = p
			case "udp":
				p, err := ParseUDPProfile(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.UDP[profileName[1]] = p
			case "web-acceleration":
				p, err := ParseWebAcceleration(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.WebAcceleration[profileName[1]] = p
			case "websocket":
				p, err := ParseWebSocketProfile(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.Websocket[profileName[1]] = p
			case "xml":
				p, err := ParseXMLProfile(*c.Response)
				if err != nil {
					return fmt.Errorf(errMsg, profileType, err.Error())
				}
				f5.Config.Profiles.XML[profileName[1]] = p
			}
		}
	}
	return nil
}