package syncdb

import (
	"encoding/json"
	"fmt"
	"time"

	"github.com/hashicorp/memberlist"
)

var (
	members = make(map[string]NodeInfo,0)
	delay   time.Duration
)

// delegate is the interface that clients must implement if they want to hook into the gossip layer of Memberlist.
type delegate struct{}

// NodeMeta is the delegate method, must implement.
func (d *delegate) NodeMeta(limit int) []byte {
	return []byte{}
}

// LocalState is the delegate method, must implement.
func (d *delegate) LocalState(join bool) []byte {
	return []byte{}
}

// MergeRemoteState is the delegate method, must implement.
func (d *delegate) MergeRemoteState(buf []byte, join bool) {
}

// GetBroadcasts is the delegate method, must implement.
func (d *delegate) GetBroadcasts(overhead, limit int) [][]byte {
	return [][]byte{}
}

// eventDelegate is the interface that clients must implement if they want to hook into the gossip layer of Memberlist.
type eventDelegate struct{}

// NotifyJoin is the eventDelegate method, must implement.
func (ed *eventDelegate) NotifyJoin(node *memberlist.Node) {
}

// NotifyLeave is the eventDelegate method, must implement.
func (ed *eventDelegate) NotifyLeave(node *memberlist.Node) {
}

// NotifyUpdate is the eventDelegate method, must implement.
func (ed *eventDelegate) NotifyUpdate(node *memberlist.Node) {
}

// NotifyMsg is called when a user-data message is received
func (d *delegate) NotifyMsg(b []byte) {
	// logMsg(b)
	n := NodeInfo{}
	if err:= json.Unmarshal(b, &n);err ==nil {
		members[n.NodeID] = n
	} else {
		fmt.Println("NotifyMsg msg unmarshal err")
	}
}

func logMsg(b []byte) {
	type nodeInfo struct {
		NodeName string `json:"name"`
		Address  string `json:"address"`
	}

	node := nodeInfo{}
	if err := json.Unmarshal(b, &node); err != nil {

		fmt.Println("Umarshal failed:", err)
		return
	}

	fmt.Println(node)
}

func CreateSearchNode(key string) (*memberlist.Memberlist, error) {
	conf := memberlist.DefaultLocalConfig()
	conf.Events = &eventDelegate{}
	conf.Delegate = &delegate{}
	conf.BindAddr = BroadcastIP
	conf.BindPort = BroadcastPort
	conf.Name = "Cluster-Searcher"

	keyring, err := memberlist.NewKeyring(nil, []byte(key))
	if err != nil {
		fmt.Printf("Failed to restore keyring: %s", err)
		return nil, err
	}
	conf.Keyring = keyring

	return memberlist.Create(conf)
}

func CreateSearchNodeWhitClose(key string, delay time.Duration) map[string]NodeInfo {
	m, err := CreateSearchNode(key)
	if err == nil {
		// fmt.Printf("Local member %s:%d\n", m.LocalNode().Addr, m.LocalNode().Port)
		time.Sleep(delay)

		m.Shutdown()
	}
	return members
}

func CloseSearchNode(m *memberlist.Memberlist) error {
	return m.Shutdown()
}

func GetSearchNodes() map[string]NodeInfo {
	return members
}