package consul

import (
	"errors"
	"fmt"
	"math/rand"

	"github.com/hashicorp/consul/api"
)

// 从consul中获取服务address port
func GetService(url, token, serviceName, tag string) []*api.ServiceEntry {
	var lastIndex uint64
	config := api.DefaultConfig()
	config.Address = url
	config.Token = token

	client, err := api.NewClient(config)
	if err != nil {
		panic(err)
	}
	services, metainfo, err := client.Health().Service(serviceName, tag, true, &api.QueryOptions{
		WaitIndex: lastIndex, // 同步点，这个调用将一直阻塞，直到有新的更新
	})
	if err != nil {
		panic(fmt.Sprintf("error retrieving instances from Consul:%v", err))
	}
	lastIndex = metainfo.LastIndex

	return services

}

// 从consul中获取服务address port
func GetService2(client *api.Client, serviceName, tag string) []*api.ServiceEntry {
	var lastIndex uint64
	services, metainfo, err := client.Health().Service(serviceName, tag, true, &api.QueryOptions{
		WaitIndex: lastIndex, // 同步点，这个调用将一直阻塞，直到有新的更新
	})
	if err != nil {

	}
	lastIndex = metainfo.LastIndex

	return services

}

type serviceInfo struct {
	serviceEntry []*api.ServiceEntry
	indexs       []int
	index        int
}

func newServiceInfo(serviceEntry []*api.ServiceEntry) *serviceInfo {
	serviceInfo := &serviceInfo{
		serviceEntry: serviceEntry,
		index:        -1,
		indexs:       make([]int, 0, len(serviceEntry)),
	}
	serviceInfo.initIndexs()
	serviceInfo.initIndex()
	return serviceInfo
}

func (s *serviceInfo) IsExist() bool {
	if s == nil {
		return false
	}

	if len(s.indexs) > 0 {
		return true
	} else {
		return false
	}
}

func (s *serviceInfo) initIndexs() {
	for i := 0; i < len(s.serviceEntry); i++ {
		if s.serviceEntry[i] != nil {
			s.indexs = append(s.indexs, i)
		}
	}
}

func (s *serviceInfo) initIndex() {
	if s.index >= 0 {
		return
	}
	if s.IsExist() {
		if len(s.indexs) == 1 {
			s.index = s.indexs[0]
			return
		}
		s.index = s.indexs[rand.Intn(len(s.indexs))]
	}
}

func (s *serviceInfo) GetAddress() string {
	return s.serviceEntry[s.index].Service.Address
}

func (s *serviceInfo) GetPort() int {
	return s.serviceEntry[s.index].Service.Port
}

type ConsulObj struct {
	client *api.Client
}

func NewConsulObj(url, token string) (*ConsulObj, error) {
	config := api.DefaultConfig()
	config.Address = url
	config.Token = token
	client, err := api.NewClient(config)
	if err != nil {
		return nil, err
	}

	return &ConsulObj{client: client}, nil
}

func (s *ConsulObj) GetClient() *api.Client {
	if s == nil {
		return nil
	}
	return s.client
}

func (s *ConsulObj) GetService(serviceName, tag string) (*serviceInfo, error) {
	services, _, err := s.client.Health().Service(serviceName, tag, true, nil)
	if err != nil {
		return nil, err
	}
	// fmt.Println(len(services))
	if len(services) == 0 {
		return nil, errors.New("services is not exist.")
	}
	return newServiceInfo(services), nil
}