package lib

import (
	"fmt"
	"regexp"

	log "github.com/sirupsen/logrus"
	"github.rackspace.com/gorax/adx/lib/parsers"
	"github.rackspace.com/gorax/tools/util"
)

var pingNoReplyRe = regexp.MustCompile(`(?i)no\s+reply\s+from\s+remote\s+host`)

func (adx *ADX) GetSNMP() error {
	err := adx.EnablePasswordDisplay(true)
	if err != nil {
		return err
	}
	defer adx.EnablePasswordDisplay(false)
	//NOTE: The \n is because the output was truncating whatever we were | i for.
	cmd, err := adx.sshClient.PostCommand("\nshow run | i snmp-server", "#", 50)
	if err != nil {
		return err
	}
	cmd2, err := adx.sshClient.PostCommand("\nshow snmp engineid", "#", 50)
	if err != nil {
		return err
	}
	snmp := new(parsers.SNMPConfig)
	err = snmp.Parse(*cmd.Response, *cmd2.Response)
	if err != nil {
		return err
	}
	adx.Config.SNMP = *snmp
	return nil
}

func (adx *ADX) GetVrrpE() error {
	cmd, err := adx.sshClient.PostCommand("show ip vrrp-e", "#", 20)
	if err != nil {
		return err
	}
	ints := new(parsers.AdxVRRPE)
	ints.Parse(cmd.Response)
	adx.Status.VrrpE = *ints
	return nil
}

func (adx *ADX) GetConfigSyncData() error {
	cmd, err := adx.sshClient.PostCommand("sh run | i config-", "#", 20)
	if err != nil {
		return err
	}
	ints := new(parsers.AdxConfigSync)
	ints.Parse(cmd.Response)
	adx.Config.ConfigSync = *ints
	return nil
}

func (adx *ADX) GetPasswordEnforcement() error {
	cmd, err := adx.sshClient.PostCommand("show run | i strict-", "#", 20)
	if err != nil {
		return err
	}
	pe := util.RegexpString(regexp.MustCompile(`(?i)(strict-password-enforcement)`), *cmd.Response)
	if pe != "" {
		adx.Config.StrictPWEnforcement = true
	}
	return nil
}

func (adx *ADX) GetInterfaceConfigs(name string) error {
	adxCMD := "show run int"
	if name != "" {
		adxCMD = fmt.Sprintf("show run int ve %v", name)
	}
	cmd, err := adx.sshClient.PostCommand(adxCMD, "#", 20)
	if err != nil {
		return err
	}
	ints := new(parsers.AdxRunningInterfaces)
	ints.Parse(cmd.Response)
	adx.Config.EthInterfaces = ints.EthInterface
	adx.Config.VEInterfaces = ints.VEInterface
	adx.Config.MgmtInterfaces = ints.MgmtInterface
	return nil
}

func (adx *ADX) GetInterfaceStats() error {
	cmd, err := adx.sshClient.PostReCommand("show int", "#(\\s+$|$)", 20)
	if err != nil {
		return err
	}
	ints := new(parsers.Interfaces)
	ints.Parse(cmd.Response)
	adx.Status.Interfaces = ints.Int
	return nil
}

func (adx *ADX) GetAccessLists() error {
	cmd, err := adx.sshClient.PostCommand("show run | begin access-list", "#", 20)
	if err != nil {
		return err
	}
	acls := new(parsers.AccessLists)
	acls.Parse(cmd.Response)
	adx.Config.AccessLists = *acls
	return nil
}

func (adx *ADX) GetARP() error {
	cmd, err := adx.sshClient.PostCommand("sh arp", "#", 20)
	if err != nil {
		return err
	}
	arps := new(parsers.AdxArp)
	arps.Parse(cmd.Response)
	adx.Status.Arp = arps.Arps
	return nil
}

func (adx *ADX) GetBind() error {
	log.Debug("GetBind() Called")
	cmd, err := adx.sshClient.PostCommand("sh server bind", "#", 20)
	if err != nil {
		log.Error(err.Error())
		return err
	}
	bind := new(parsers.AdxBindInfo)
	bind.Parse(cmd.Response)
	adx.Status.Bind = *bind
	return nil
}

func (adx *ADX) GetCertSummary() error {
	cmd, err := adx.sshClient.PostCommand("sh ssl cert *", "#", 20)
	if err != nil {
		return err
	}
	certs := new(parsers.AdxCerts)
	certs.Parse(cmd.Response)
	adx.Status.CertSummary = *certs
	return nil
}

func (adx *ADX) GetDir() error {
	cmd, err := adx.sshClient.PostCommand("dir", "#", 20)
	if err != nil {
		return err
	}
	dir := new(parsers.AdxDir)
	dir.Parse(cmd.Response)
	adx.Status.Dir = *dir
	return nil
}

func (adx *ADX) GetFlash() error {
	cmd, err := adx.sshClient.PostCommand("show flash", "#", 20)
	if err != nil {
		return err
	}
	flash := new(parsers.AdxFlash)
	flash.Parse(cmd.Response)
	adx.Status.Flash = *flash
	return nil
}

func (adx *ADX) RoutesStatus() error {
	return adx.GetRoutes()
}

func (adx *ADX) GetVEInterfaces() error {
	if err := adx.GetInterfaceConfigs(""); err != nil {
		return err
	}
	var combined string

	// Step through the VE interfaces, collecting the stats as we go
	for _, i := range adx.Config.VEInterfaces {
		cmd, err := adx.sshClient.PostCommand(fmt.Sprintf("show int ve %v", i.Interface), "#", 20)
		if err != nil {
			return err
		}
		combined += *cmd.Response
	}
	veInt := new(parsers.AdxVEInterfaces)
	veInt.Parse(&combined)
	adx.Status.VEInterfaces = *veInt
	return nil
}

func (adx *ADX) GetSSLKeys() error {
	cmd, err := adx.sshClient.PostCommand("show ssl key *", "#", 20)
	if err != nil {
		return err
	}
	keys := new(parsers.AdxKeys)
	keys.Parse(cmd.Response)
	adx.Status.SSLKeys = *keys
	return nil
}

func (adx *ADX) GetScriptProfiles() error {
	cmd, err := adx.sshClient.PostCommand("show script-profile", "#", 20)
	if err != nil {
		return err
	}
	prof := new(parsers.AdxScriptProfiles)
	prof.Parse(*cmd.Response)
	adx.Status.ScriptProfiles = *prof
	return nil
}

func (adx *ADX) GetVersion() error {
	cmd, err := adx.sshClient.PostCommand("show version", "#", 20)
	if err != nil {
		return err
	}
	ver := new(parsers.AdxVersion)
	ver.Parse(*cmd.Response)
	adx.Status.Version = *ver
	return nil
}

func (adx *ADX) GetVRRPE() error {
	cmd, err := adx.sshClient.PostCommand("show ip vrrp-extended", "#", 20)
	if err != nil {
		return err
	}
	vrrpe := new(parsers.AdxVRRPE)
	vrrpe.Parse(cmd.Response)
	adx.Config.VRRPE = *vrrpe
	return nil
}

func (adx *ADX) GetScriptSummary() error {
	cmd, err := adx.sshClient.PostCommand("show script all", "#", 20)
	if err != nil {
		return err
	}
	scripts := new(parsers.AdxScripts)
	scripts.Parse(*cmd.Response)
	adx.Status.Scripts = *scripts
	return nil
}

func (adx *ADX) GetRealServers() error {
	cmd, err := adx.sshClient.PostCommand("show run real all", "#", 20)
	if err != nil {
		return err
	}
	servers := new(parsers.AdxServers)
	servers.Parse(cmd.Response)
	adx.Config.RealServers = *servers
	return nil
}

func (adx *ADX) GetVirtualServers() error {
	cmd, err := adx.sshClient.PostCommand("show run virt all", "#", 20)
	if err != nil {
		return err
	}
	vs := new(parsers.VirtualServers)
	vs.Parse(cmd.Response)
	adx.Config.VirtualServers = vs.VirtualServers
	return nil
}

func (adx *ADX) GetVirtualStatus() error {
	cmd, err := adx.sshClient.PostCommand("show server virtual", "#", 20)
	if err != nil {
		return err
	}
	virtuals := new(parsers.Virtuals)
	virtuals.Parse(cmd.Response)
	adx.Status.Virtuals = *virtuals
	return nil
}

func (adx *ADX) GetVlans() error {
	cmd, err := adx.sshClient.PostCommand("show run vlan", "#", 20)
	if err != nil {
		return err
	}
	v := new(parsers.Vlans)
	v.Parse(*cmd.Response)
	adx.Config.Vlans = v.Vlans
	return nil
}

func (adx *ADX) GetRoutes() error {
	cmd, err := adx.sshClient.PostCommand("show ip route", "#", 20)
	if err != nil {
		return err
	}
	v := new(parsers.RouteTable)
	v.Parse(cmd.Response)
	adx.Status.Routes = v.Routes
	return nil
}

func (adx *ADX) GetRouteConfig() error {
	cmd, err := adx.sshClient.PostCommand("show running-config  | in ip route\n", "#", 20)
	if err != nil {
		return err
	}
	v := new(parsers.RoutesConfig)
	v.Parse(cmd.Response)
	adx.Config.Routes = v.Routes
	return nil
}

func (adx *ADX) Ping(ip string) (bool, string, error) {
	cmd, err := adx.sshClient.PostCommand(fmt.Sprintf("ping %s count 2 timeout 2000", ip), "#", 20)
	if err != nil {
		return false, "", err
	}
	if pingNoReplyRe.MatchString(*cmd.Response) {
		return false, *cmd.Response, nil
	}
	return true, *cmd.Response, nil
}

func (adx *ADX) GetGlobalServerConfig() error {
	cmd, err := adx.sshClient.PostCommand("show running-config", "#", 50)
	if err != nil {
		return err
	}
	gs := new(parsers.AdxGlobalServer)
	gs.Parse(cmd.Response)
	adx.Config.GlobalServer = *gs
	return nil
}

func (adx *ADX) GetServerBPMask() error {
	cmd, err := adx.sshClient.PostCommand("sh run | i select-bp-mask", "#", 10)
	if err != nil {
		return err
	}
	r := util.RegexpFindStringPtr(regexp.MustCompile(`select-bp-mask\s+(\S+)\n`), *cmd.Response)
	adx.Config.SelectBPMask = *r
	return nil
}

func (adx *ADX) GetSslProfiles() error {
	cmd, err := adx.sshClient.PostCommand("show running-config", "#", 50)
	if err != nil {
		return err
	}
	sslprofiles := new(parsers.AdxSslProfiles)
	sslprofiles.Parse(cmd.Response)
	adx.Config.SslProfiles = *sslprofiles
	return nil
}

func (adx *ADX) GetVipGroups() error {
	cmd, err := adx.sshClient.PostCommand("show running-config", "#", 50)
	if err != nil {
		return err
	}
	vipgroups := new(parsers.VipGroups)
	vipgroups.Parse(cmd.Response)
	adx.Config.VipGroups = *vipgroups
	return nil
}