package tests

import (
	"lux/crypto"
	"lux/host"
	"lux/node"
	"lux/proto"
	"testing"
)

type DummyWANProvider2 struct{}

func (*DummyWANProvider2) Provide() (host.LuxOption, error) {
	wan := host.NewLuxOptionWAN()
	wan.Addr4 = proto.LuxProtoIPToAddr([]byte{1, 2, 3, 4})

	return &wan, nil
}

func TestNodeHeartbeat(t *testing.T) {
	ks := crypto.NewLuxKeyStore("/tmp/keystore.dat")

	keyNode, _ := crypto.NewLuxKey(proto.LuxTypeNode)
	ks.Put(keyNode)
	keyHost, _ := crypto.NewLuxKey(proto.LuxTypeHost)
	ks.Put(keyHost)

	node := node.NewLuxNode(keyNode, ks)
	node.AddExterior("127.0.0.1:9979")
	node.Start()
	defer node.Stop()

	host := host.NewLuxHost("test-host", keyHost, ks)
	host.AddNode(keyNode.Id, "127.0.0.1:9979")
	host.AddOptionProvider(&DummyWANProvider2{})
	host.Start()
	defer host.Stop()

	for i := 0; i < 2; i++ {
		if err := host.Heartbeat(); err != nil {
			t.Fatal(err)
		}

		hostState := <-node.GetHostStateChannel()
		t.Log(hostState)
	}
}

func TestNodeSync(t *testing.T) {
	/*
		NODE A has neighbor NODE B

			NODE A <-- interior 127.0.0.2:9980 --> NODE B
			  ^
			  |
			  | <- exterior 127.0.0.1:9979
			  |
			HOST heartbeats to NODE A

	*/

	ks := crypto.NewLuxKeyStore("/tmp/keystore.dat")

	keyNodeA, _ := crypto.NewLuxKey(proto.LuxTypeNode)
	ks.Put(keyNodeA)
	keyNodeB, _ := crypto.NewLuxKey(proto.LuxTypeNode)
	ks.Put(keyNodeB)
	keyHost, _ := crypto.NewLuxKey(proto.LuxTypeHost)
	ks.Put(keyHost)

	nodeA := node.NewLuxNode(keyNodeA, ks)
	nodeA.AddExterior("127.0.0.1:9979")
	nodeA.AddNeighbor(keyNodeB.Id, "127.0.0.2:9980")
	nodeA.Start()
	defer nodeA.Stop()

	nodeB := node.NewLuxNode(keyNodeB, ks)
	nodeB.AddInterior("127.0.0.2:9980")
	nodeB.Start()
	defer nodeB.Stop()

	host := host.NewLuxHost("test-host", keyHost, ks)
	host.AddNode(keyNodeA.Id, "127.0.0.1:9979")
	host.AddOptionProvider(&DummyWANProvider2{})
	host.Start()
	defer host.Stop()

	// register some host state into node
	if err := host.Heartbeat(); err != nil {
		t.Fatal(err)
	}

	// block until node A registers heartbeat
	hostState := <-nodeA.GetHostStateChannel()
	t.Log(hostState)

	// issue node sync
	if err := nodeA.MulticastSync(); err != nil {
		t.Fatal(err)
	}

	// now we wait and catch option update from node B,
	// that should be merged from node A sync multicast
	hostState = <-nodeB.GetHostStateChannel()
	t.Log(hostState)
}