package lib

import (
	"errors"
	"strconv"

	"github.com/gofrs/uuid"
	"github.com/josh5276/brocade-adx-client/brocade"
	"github.rackspace.com/gorax/adx/lib/parsers"
	"github.rackspace.com/gorax/clients/coreAPI"
	"github.rackspace.com/gorax/clients/passwordsafe"
	"github.rackspace.com/gorax/clients/sshAPI"
	"github.rackspace.com/gorax/tools/util"
)

type (
	// ADX is the main structure that defines all the elements we
	// collect on a Brocade
	ADX struct {
		Config   Config `json:"configuration_items"`
		Device   int    `json:"device_number"`
		Status   Status `json:"status_items"`
		Failover *int   `json:"failover_device"`

		sshClient  *sshAPI.SSHClient
		soapClient adc.ADCSoapClient
		deviceInfo *coreAPI.DeviceInfo
		coreapi    *coreAPI.Client
	}

	// Config is a sub element that contains configuration related items
	Config struct {
		EthInterfaces       []parsers.AdxRunEthInterface  `json:"interfaces"`
		VEInterfaces        []parsers.AdxRunVEInterface   `json:"ve_interfaces"`
		MgmtInterfaces      []parsers.AdxRunMgmtInterface `json:"mgmt_interfaces"`
		AccessLists         parsers.AccessLists           `json:"access_lists"`
		VRRPE               parsers.AdxVRRPE              `json:"vrrpe"`
		RealServers         parsers.AdxServers            `json:"real_servers"`
		VirtualServers      []parsers.VirtualServer       `json:"virtual_servers"`
		Vlans               []parsers.Vlan                `json:"vlans"`
		Routes              []parsers.RouteConfig         `json:"routes"`
		ConfigSync          parsers.AdxConfigSync         `json:"config_sync"`
		GlobalServer        parsers.AdxGlobalServer       `json:"global_server"`
		SelectBPMask        string                        `json:"select_bp_mask"`
		SslProfiles         parsers.AdxSslProfiles        `json:"ssl_profiles"`
		StrictPWEnforcement bool                          `json:"strict_password_enforcement"`
		VipGroups           parsers.VipGroups             `json:"vip_groups"`
		SNMP                parsers.SNMPConfig            `json:"snmp"`
	}

	// Status is a sub element that contains statistics and status commands
	// on the device.
	Status struct {
		VEInterfaces   parsers.AdxVEInterfaces   `json:"ve_interfaces"`
		SSLKeys        parsers.AdxKeys           `json:"ssl_keys"`
		Interfaces     []parsers.Interface       `json:"interfaces"`
		VrrpE          parsers.AdxVRRPE          `json:"vrrpe"`
		Bind           parsers.AdxBindInfo       `json:"bind"`
		Arp            []parsers.Arp             `json:"arp_table"`
		CertSummary    parsers.AdxCerts          `json:"cert_summary"`
		Dir            parsers.AdxDir            `json:"dir"`
		Flash          parsers.AdxFlash          `json:"flash"`
		Version        parsers.AdxVersion        `json:"version"`
		ScriptProfiles parsers.AdxScriptProfiles `json:"script_profiles"`
		Scripts        parsers.AdxScripts        `json:"scripts"`
		Routes         []parsers.RouteEntry      `json:"routes"`
		Virtuals       parsers.Virtuals          `json:"virtuals"`
	}
)

func NewADX(token string, device int, cred passwordsafe.ProjectCredential) (*ADX, error) {
	c, err := coreAPI.New(token)
	if err != nil {
		return nil, err
	}
	d, err := c.DeviceInfo("adx", device, false)
	if err != nil {
		return nil, err
	}
	return NewCoreDevice(c, d, cred)
}

func NewCoreDevice(c *coreAPI.Client, d *coreAPI.DeviceInfo, cred passwordsafe.ProjectCredential) (*ADX, error) {
	if d == nil {
		return nil, errors.New("empty coreapi device data")
	}
	uid, err := uuid.NewV4()
	if err != nil {
		return nil, err
	}
	sa, err := sshAPI.NewSSHAPIClient(c, d, "adx", false, uid)
	if err != nil {
		return nil, err
	}

	return &ADX{
		sshClient:  sa,
		soapClient: adc.NewSOAPClient(d.DracIP, cred.Username, cred.Password),
		Failover: func() *int {
			if d.FailoverDevice == nil {
				return nil
			}
			if i, err := strconv.Atoi(d.FailoverDevice.FailoverID); err == nil {
				return &i
			}
			return nil
		}(),
		Device:     util.Atoi(d.ID),
		deviceInfo: d,
	}, nil
}

func NewADXToken(c *coreAPI.Client, device int, cred passwordsafe.ProjectCredential) (*ADX, error) {
	d, err := c.DeviceInfo("adx", device, false)
	if err != nil {
		return nil, err
	}
	return NewCoreDevice(c, d, cred)
}

// DataCenter method exports the DC value for a device from the
// coreAPI device info data
func (adx *ADX) DataCenter() string {
	return adx.deviceInfo.DataCenter
}

// DeviceData method exports the coreAPI device info data
func (adx *ADX) DeviceData() *coreAPI.DeviceInfo {
	return adx.deviceInfo
}