package yasrpc

import (
	"net/http"
	"strings"
	"time"

	"git.yasdb.com/go/yasrpc/log"
)

type YasRegistryDiscovery struct {
	*MultiServersDiscovery
	registry   string
	timeout    time.Duration
	lastUpdate time.Time

	logger log.Logger
}

var _ Discovery = (*YasRegistryDiscovery)(nil)

const defaultUpdateTimeout = 10 * time.Second

func NewDawnRegistryDiscovery(registerAddr string, timeout time.Duration, logger log.Logger) *YasRegistryDiscovery {
	if logger == nil {
		logger = log.DefaultLogger
	}
	if timeout == 0 {
		timeout = defaultUpdateTimeout
	}
	return &YasRegistryDiscovery{
		MultiServersDiscovery: NewMultiServerDiscovery(make([]string, 0)),
		registry:              registerAddr,
		timeout:               timeout,
		logger:                logger,
	}
}

func (d *YasRegistryDiscovery) Refresh() error {
	d.mu.Lock()
	defer d.mu.Unlock()
	if d.lastUpdate.Add(d.timeout).After(time.Now()) {
		return nil
	}
	d.logger.Info("rpc registry: refresh servers from registry", d.registry)
	resp, err := http.Get(d.registry)
	if err != nil {
		d.logger.Error("rpc registry refresh err:", err)
		return err
	}
	servers := strings.Split(resp.Header.Get(RegistryHeader), ",")
	d.servers = make([]string, 0, len(servers))
	for _, server := range servers {
		if strings.TrimSpace(server) != "" {
			d.servers = append(d.servers, strings.TrimSpace(server))
		}
	}
	d.lastUpdate = time.Now()
	return nil
}

func (d *YasRegistryDiscovery) Update(servers []string) error {
	d.mu.Lock()
	defer d.mu.Unlock()
	d.servers = servers
	d.lastUpdate = time.Now()
	return nil
}

func (d *YasRegistryDiscovery) Get(mode SelectMode) (string, error) {
	if err := d.Refresh(); err != nil {
		return "", err
	}
	return d.MultiServersDiscovery.Get(mode)
}

func (d *YasRegistryDiscovery) GetAll() ([]string, error) {
	if err := d.Refresh(); err != nil {
		return nil, err
	}
	return d.MultiServersDiscovery.GetAll()
}