package controller

import (
	"testing"
	"time"

	"github.com/gravitl/netmaker/database"
	"github.com/gravitl/netmaker/models"
	"github.com/stretchr/testify/assert"
)

func TestGetPeerList(t *testing.T) {
	database.InitializeDatabase()
	database.InitializeDatabase()
	//deleteNet(t)
	//createNet()
	_ = createTestNode(t)
	//createnode := models.Node{PublicKey: "RM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34=", Endpoint: "10.0.0.2", MacAddress: "02:02:03:04:05:06", Password: "password", Network: "skynet"}
	//_, _ = CreateNode(createnode, "skynet")
	t.Run("PeerExist", func(t *testing.T) {
		peers, err := GetPeersList("skynet")
		assert.Nil(t, err)
		assert.NotEqual(t, []models.PeersResponse(nil), peers)
		t.Log(peers)
	})
	t.Run("NoNodes", func(t *testing.T) {
		//	_ = DeleteNode("01:02:03:04:05:06", "skynet")
		peers, err := GetPeersList("skynet")
		assert.Nil(t, err)
		assert.Equal(t, []models.PeersResponse(nil), peers)
		t.Log(peers)
	})
}

type NodeValidationTC struct {
	testname     string
	node         models.Node
	errorMessage string
}

type NodeValidationUpdateTC struct {
	testname     string
	node         models.Node
	errorMessage string
}

func TestDeleteNode(t *testing.T) {
	database.InitializeDatabase()
	//deleteNet(t)
	//createNet()
	//node := createTestNode(t)
	t.Run("NodeExists", func(t *testing.T) {
		//err := DeleteNode(node.MacAddress, node.Network)
		//assert.Nil(t, err)
	})
	t.Run("NonExistantNode", func(t *testing.T) {
		//err := DeleteNode(node.MacAddress, node.Network)
		//assert.Nil(t, err)
	})
}
func TestGetNode(t *testing.T) {
	database.InitializeDatabase()
	//deleteNet(t)
	//createNet()
	node := createTestNode(t)
	t.Run("NodeExists", func(t *testing.T) {
		response, err := GetNode(node.MacAddress, node.Network)
		assert.Nil(t, err)
		assert.Equal(t, "10.0.0.1", response.Endpoint)
		assert.Equal(t, "DM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34=", response.PublicKey)
		assert.Equal(t, "01:02:03:04:05:06", response.MacAddress)
		assert.Equal(t, int32(51821), response.ListenPort)
		assert.NotNil(t, response.Name)
		assert.Equal(t, "skynet", response.Network)
		assert.Equal(t, "nm-skynet", response.Interface)
	})
	t.Run("BadMac", func(t *testing.T) {
		response, err := GetNode("01:02:03:04:05:07", node.Network)
		assert.NotNil(t, err)
		assert.Equal(t, models.Node{}, response)
		assert.Equal(t, "mongo: no documents in result", err.Error())
	})
	t.Run("BadNetwork", func(t *testing.T) {
		response, err := GetNode(node.MacAddress, "badnet")
		assert.NotNil(t, err)
		assert.Equal(t, models.Node{}, response)
		assert.Equal(t, "mongo: no documents in result", err.Error())
	})
	t.Run("NoNode", func(t *testing.T) {
		//_ = DeleteNode("01:02:03:04:05:06", "skynet")
		response, err := GetNode(node.MacAddress, node.Network)
		assert.NotNil(t, err)
		assert.Equal(t, models.Node{}, response)
		//assert.Equal(t, "mongo: no documents in result", err.Error())
	})

}
func TestCreateNode(t *testing.T) {
	database.InitializeDatabase()
	//deleteNet(t)
	//createNet()
	createnode := models.Node{PublicKey: "DM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34=", Endpoint: "10.0.0.1", MacAddress: "01:02:03:04:05:06", Password: "password", Network: "skynet"}
	//err := ValidateNodeCreate("skynet", createnode)
	//assert.Nil(t, err)
	node, err := CreateNode(createnode, "skynet")
	assert.Nil(t, err)
	assert.Equal(t, "10.0.0.1", node.Endpoint)
	assert.Equal(t, "DM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34=", node.PublicKey)
	assert.Equal(t, "01:02:03:04:05:06", node.MacAddress)
	assert.Equal(t, int32(51821), node.ListenPort)
	assert.NotNil(t, node.Name)
	assert.Equal(t, "skynet", node.Network)
	assert.Equal(t, "nm-skynet", node.Interface)
}
func TestSetNetworkNodesLastModified(t *testing.T) {
	database.InitializeDatabase()
	//deleteNet(t)
	//createNet()
	t.Run("InvalidNetwork", func(t *testing.T) {
		err := SetNetworkNodesLastModified("badnet")
		assert.NotNil(t, err)
		assert.Equal(t, "mongo: no documents in result", err.Error())
	})
	t.Run("NetworkExists", func(t *testing.T) {
		err := SetNetworkNodesLastModified("skynet")
		assert.Nil(t, err)
	})
}
func TestTimestampNode(t *testing.T) {
	database.InitializeDatabase()
	//deleteNet(t)
	//createNet()
	node := createTestNode(t)
	time.Sleep(time.Second * 1)
	before, err := GetNode(node.MacAddress, node.Network)
	assert.Nil(t, err)
	t.Run("UpdateCheckIn", func(t *testing.T) {
		err = TimestampNode(node, true, false, false)
		assert.Nil(t, err)
		after, err := GetNode(node.MacAddress, node.Network)
		assert.Nil(t, err)
		assert.Greater(t, after.LastCheckIn, before.LastCheckIn)
	})
	t.Run("UpdatePeers", func(t *testing.T) {
		err = TimestampNode(node, false, true, false)
		assert.Nil(t, err)
		after, err := GetNode(node.MacAddress, node.Network)
		assert.Nil(t, err)
		assert.Greater(t, after.LastPeerUpdate, before.LastPeerUpdate)
	})
	t.Run("UpdateLastModified", func(t *testing.T) {
		err = TimestampNode(node, false, false, true)
		assert.Nil(t, err)
		after, err := GetNode(node.MacAddress, node.Network)
		assert.Nil(t, err)
		assert.Greater(t, after.LastModified, before.LastModified)
	})
	t.Run("InvalidNode", func(t *testing.T) {
		node.MacAddress = "01:02:03:04:05:08"
		err = TimestampNode(node, true, true, true)
		assert.NotNil(t, err)
		//assert.Equal(t, "mongo: no documents in result", err.Error())
	})

}
func createTestNode(t *testing.T) models.Node {
	createnode := models.Node{PublicKey: "DM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34=", Endpoint: "10.0.0.1", MacAddress: "01:02:03:04:05:06", Password: "password", Network: "skynet"}
	node, err := CreateNode(createnode, "skynet")
	assert.Nil(t, err)
	t.Log(err)
	return node
}