package set

import (
	"testing"

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

func TestFromSlice(t *testing.T) {
	slice := []string{"a", "b", "c"}
	set := FromSlice(slice)

	for item := range set {
		assert.Contains(t, slice, item)
	}
}

func TestFromMap(t *testing.T) {
	stringMap := map[string]int{"a": 0, "b": 1, "c": 2}
	set := FromMap(stringMap)

	for item := range set {
		assert.Contains(t, stringMap, item)
	}
}

func TestToSlice(t *testing.T) {
	set := Set[string]{"a": member, "b": member, "c": member}
	expectedSliceElements := []string{"a", "b", "c"}

	slice := set.ToSlice()
	assert.ElementsMatch(t, expectedSliceElements, slice)
}

func TestAddToSet(t *testing.T) {
	stringSet := Set[string]{}
	stringSet.Add("item a")
	stringSet.Add("item b")

	_, ok := stringSet["item a"]
	assert.True(t, ok)
	_, ok = stringSet["item b"]
	assert.True(t, ok)

	intSet := Set[int]{}
	intSet.Add(1)
	intSet.Add(2)

	_, ok = intSet[1]
	assert.True(t, ok)
	_, ok = intSet[2]
	assert.True(t, ok)
}

func TestRemoveFromSet(t *testing.T) {
	stringSet := Set[string]{"item a": member, "item b": member}
	stringSet.Remove("item a")
	stringSet.Remove("item b")

	_, ok := stringSet["item a"]
	assert.False(t, ok)
	_, ok = stringSet["item b"]
	assert.False(t, ok)

	intSet := Set[int]{1: member, 2: member}
	intSet.Remove(1)
	intSet.Remove(2)

	_, ok = intSet[1]
	assert.False(t, ok)
	_, ok = intSet[2]
	assert.False(t, ok)
}

func TestSetHasMember(t *testing.T) {
	stringSet := Set[string]{"item a": member, "item b": member}
	assert.True(t, stringSet.HasMember("item a"))
	assert.False(t, stringSet.HasMember("item c"))

	intSet := Set[int]{1: member, 2: member}
	assert.True(t, intSet.HasMember(1))
	assert.False(t, intSet.HasMember(3))
}

func TestSetUnion(t *testing.T) {
	left := Set[string]{"a": member, "b": member, "c": member}
	right := Set[string]{"c": member, "d": member, "e": member}
	expectedUnion := Set[string]{"a": member, "b": member, "c": member, "d": member, "e": member}

	union := left.Union(right)
	assert.Equal(t, expectedUnion, union)
}

func TestSetIntersection(t *testing.T) {
	left := Set[string]{"a": member, "b": member, "c": member, "d": member}
	right := Set[string]{"c": member, "d": member, "e": member}
	expectedIntersection := Set[string]{"c": member, "d": member}

	intersection := left.Intersection(right)
	assert.Equal(t, expectedIntersection, intersection)
}

func TestSetDifference(t *testing.T) {
	left := Set[string]{"a": member, "b": member, "c": member}
	right := Set[string]{"c": member, "d": member, "e": member}
	expectedDifference := Set[string]{"a": member, "b": member}

	difference := left.Difference(right)
	assert.Equal(t, expectedDifference, difference)
}

func TestSetSymmetricDifference(t *testing.T) {
	left := Set[string]{"a": member, "b": member, "c": member}
	right := Set[string]{"c": member, "d": member, "e": member}
	expectedSymmetricDifference := Set[string]{"a": member, "b": member, "d": member, "e": member}

	symmetricDifference := left.SymmetricDifference(right)
	assert.Equal(t, expectedSymmetricDifference, symmetricDifference)
}