package switchy

import (
	"fmt"
	"sync"

	"github.rackspace.com/gorax/libs/switchlib/swModels"
	"github.rackspace.com/gorax/tools/util"
)

func (s *SwitchClient) UnipedeConfigParse(age int) error {
	conf, err := s.u.GetSwitchConfig(s.SwitchName, nil)
	if err != nil {
		return err
	}
	if err = s.AppendPortConfig(conf); err != nil {
		return err
	}
	s.VlanConfigParse(conf)
	s.MonitorConfigParse(conf)
	return nil
}

func (s *SwitchClient) VlanConfigParse(conf *string) {
	s.vlans = swModels.ParseVlanConfig(conf)
	for _, v := range s.vlans.Vlans {
		s.Vlans = append(s.Vlans, &SwitchVlan{
			Vlan:     v.Vlan,
			Name:     v.Name,
			Shutdown: v.Shut,
		})
	}
}

func (s *SwitchClient) MonitorConfigParse(conf *string) {
	m := swModels.ParseMonitorSessions(conf)
	s.Monitors = m.Monitors
	for _, port := range s.SwitchPorts {
		mon := m.IsDestination(port.PortName)
		if mon != nil {
			port.Monitor = mon
		}
	}
}

func (s *SwitchClient) PortConfigDirect() error {
	return nil
}

func (s *SwitchClient) AppendPortConfig(conf *string) error {
	var err error
	s.ic, err = swModels.ParseIntConfig(conf)
	if err != nil {
		return err
	}
	var vlans []int
	for _, port := range s.SwitchPorts {
		pc := s.ic.PortByName(port.PortName)
		if pc == nil {
			port.Warnings = append(port.Warnings, fmt.Errorf("unable to find config for %s", port.PortName))
			continue
		}
		port.PortConfig = pc
		vlans = append(vlans, pc.PortVlans()...)
	}
	s.vlanInUse = util.UniqueInts(vlans)
	return nil
}

func MapPortUnipedeConfig(clients map[string]*SwitchClient, age int) {
	swChan := make(chan *SwitchClient)
	wg := new(sync.WaitGroup)
	workerStart(swChan, func(sw *SwitchClient) {
		if err := sw.UnipedeConfigParse(age); err != nil {
			sw.Errors = append(sw.Errors, err)
		}
	}, wg)

	for _, sw := range clients {
		wg.Add(1)
		swChan <- sw
	}

	wg.Wait()
	close(swChan)
}