package client

import (
	"testing"

	"github.com/google/uuid"
	"github.com/stretchr/testify/assert"
)

func TestNewChariotMessage(t *testing.T) {
	actual := &ChariotMessage{}
	expected := NewChariotMessage()
	assert.Equal(t, expected, actual)
}

func TestSetBanner(t *testing.T) {
	expectedBannerGUID := uuid.NewString()
	expectedChariotMessage := &ChariotMessage{
		Banner: expectedBannerGUID,
	}
	actualBannerGUID := uuid.NewString()
	expectedChariotMessage.SetBanner(actualBannerGUID)
	assert.Equal(t, expectedChariotMessage.Banner, actualBannerGUID)
}

func TestSetCluster(t *testing.T) {
	expectedClusterGUID := uuid.NewString()
	expectedChariotMessage := &ChariotMessage{
		Cluster: expectedClusterGUID,
	}
	actualClusterGUID := uuid.NewString()
	expectedChariotMessage.SetCluster(actualClusterGUID)
	assert.Equal(t, expectedChariotMessage.Cluster, actualClusterGUID)
}

func TestSetOperation(t *testing.T) {
	expectedChariotMessage := &ChariotMessage{
		Operation: Create.String(),
	}
	expectedChariotMessage.SetOperation(Delete)
	assert.Equal(t, expectedChariotMessage.Operation, Delete.String())
}

func TestSetOwner(t *testing.T) {
	expectedChariotMessage := &ChariotMessage{
		Owner: "BFFUser",
	}
	expectedChariotMessage.SetOwner("EdgeUser")
	assert.Equal(t, expectedChariotMessage.Owner, "EdgeUser")
}

func TestSetObjects(t *testing.T) {
	expectedObjects := []string{"Sm9l", "QWxhZ29h"}
	expectedChariotMessage := &ChariotMessage{
		Objects: expectedObjects,
	}
	actualObjects := []string{"aGVsbG8=", "V29ybGQ="}
	expectedChariotMessage.SetObjects(actualObjects)
	assert.Equal(t, expectedChariotMessage.Objects, actualObjects)
}

func TestAddObject(t *testing.T) {
	expectedObjects := []string{"Sm9l"}
	expectedChariotMessage := &ChariotMessage{
		Objects: expectedObjects,
	}
	newObject := "QWxhZ29h"
	expectedChariotMessage.AddObject(newObject)
	assert.Contains(t, expectedChariotMessage.Objects, newObject)
}

func TestSetDir(t *testing.T) {
	expected := []byte("{\"objects\":null,\"banner\":\"\",\"cluster\":\"\",\"operation\":\"\",\"owner\":\"\",\"dir\":\"directory\"}")
	cm := &ChariotMessage{}
	cm = cm.SetDir("directory")
	bits, err := cm.ToByte()
	assert.NoError(t, err)
	assert.Equal(t, expected, bits)
}

func TestSetEmptyDir(t *testing.T) {
	expected := []byte("{\"objects\":null,\"banner\":\"\",\"cluster\":\"\",\"operation\":\"\",\"owner\":\"\"}")
	cm := &ChariotMessage{}
	cm = cm.SetDir("")
	bits, err := cm.ToByte()
	assert.NoError(t, err)
	assert.Equal(t, expected, bits)
}

func TestToByte(t *testing.T) {
	expectedObjects := []string{"Sm9l", "QWxhZ29h"}
	expectedChariotMessage := &ChariotMessage{
		Banner:  uuid.NewString(),
		Cluster: uuid.NewString(),
		Objects: expectedObjects,
	}
	byteResponse, err := expectedChariotMessage.ToByte()
	assert.NoError(t, err)
	assert.NotEmpty(t, byteResponse)
}