package discovery

import (
	"errors"
	"math"
	"math/rand"
	"sync"
	"time"
)

// MultiServersDiscovery is a discovery for multi servers without a registry center
// user provides the server addresses explicitly instead
type MultiServersDiscovery struct {
	randNum *rand.Rand //generate random num
	mu      sync.Mutex
	servers []string
	index   int // record position for robin algorithm
}

// NewMultiServerDiscovery creates a MultiServersDiscovery instance
func NewMultiServerDiscovery(servers []string) *MultiServersDiscovery {
	d := &MultiServersDiscovery{
		servers: servers,
		randNum: rand.New(rand.NewSource(time.Now().UnixNano())), //random seed is time
	}
	//init robin position by rand
	d.index = d.randNum.Intn(math.MaxInt32 - 1)
	return d
}

/*there implement Discovery interface*/

//no sense for MultiServersDiscovery
func (d *MultiServersDiscovery) Refresh() error {
	return nil
}

// Update the servers of discovery dynamically if needed
func (d *MultiServersDiscovery) Update(servers []string) error {
	d.mu.Lock()
	defer d.mu.Unlock()
	d.servers = servers
	return nil
}

// get a server according to mode
func (d *MultiServersDiscovery) Get(mode SelectMode) (string, error) {
	d.mu.Lock()
	defer d.mu.Unlock()
	cnt := len(d.servers)
	if cnt == 0 {
		return "", errors.New("rpc discovery: no available servers")
	}
	switch mode {
	case RandomSelect:
		//return server randomly
		return d.servers[d.randNum.Intn(cnt)], nil
	case RoundRobinSelect:
		//according to index in RoundRobinSelect Mode
		s := d.servers[d.index%cnt]
		d.index = (d.index + 1) % cnt
		return s, nil
	default:
		return "", errors.New("rpc discovery: not support this mode")
	}
}

func (d *MultiServersDiscovery) GetAll() ([]string, error) {
	d.mu.Lock()
	defer d.mu.Unlock()
	//return a copy about d.servers
	servers := make([]string, len(d.servers))
	copy(servers, d.servers)
	return servers, nil
}