package set

import (
	"testing"

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

func TestOrderedFromSet(t *testing.T) {
	set := Set[int]{5: member, 2: member, 3: member, 7: member, 9: member}
	orderedSet := OrderedFromSet(set)

	expectedOrder := []int{2, 3, 5, 7, 9}
	expectedSet := &OrderedSet[int]{
		Set:   Set[int]{5: member, 2: member, 3: member, 7: member, 9: member},
		order: expectedOrder,
	}

	assert.Equal(t, expectedSet, orderedSet)
	assert.Equal(t, expectedOrder, orderedSet.ToSlice())
}

func TestOrderedFromSlice(t *testing.T) {
	slice := []float32{3.5, 2.3, 8.3, 7.01, 9.999}
	set := OrderedFromSlice(slice)

	expectedOrder := []float32{2.3, 3.5, 7.01, 8.3, 9.999}
	expectedSet := &OrderedSet[float32]{
		Set:   Set[float32]{2.3: member, 3.5: member, 7.01: member, 8.3: member, 9.999: member},
		order: expectedOrder,
	}

	assert.Equal(t, expectedSet, set)
	assert.Equal(t, expectedOrder, set.ToSlice())
}

func TestOrderedFromMap(t *testing.T) {
	m := map[string]int{"d": 0, "b": 1, "a": 2, "c": 3}
	set := OrderedFromMap(m)

	expectedOrder := []string{"a", "b", "c", "d"}
	expectedSet := &OrderedSet[string]{
		Set:   Set[string]{"d": member, "b": member, "a": member, "c": member},
		order: expectedOrder,
	}

	assert.Equal(t, expectedSet, set)
	assert.Equal(t, expectedOrder, set.ToSlice())
}

func TestOrderedToSet(t *testing.T) {
	orderedSet := OrderedFromSlice([]int{5, 2, 3, 7, 9})
	expectedSet := Set[int]{5: member, 2: member, 3: member, 7: member, 9: member}
	set := orderedSet.ToSet()
	assert.Equal(t, expectedSet, set)
}

func TestAddToOrderedSet(t *testing.T) {
	set := OrderedFromSlice([]string{})

	set.Add("c")
	expectedOrder := []string{"c"}
	assert.Equal(t, expectedOrder, set.ToSlice())

	set.Add("e", "a")
	expectedOrder = []string{"a", "c", "e"}
	assert.Equal(t, expectedOrder, set.ToSlice())

	set.Add("b", "a", "d", "c", "f")
	expectedOrder = []string{"a", "b", "c", "d", "e", "f"}
	assert.Equal(t, expectedOrder, set.ToSlice())
}

func TestRemoveFromOrderedSet(t *testing.T) {
	set := OrderedFromSlice([]int{2, 3, 5, 7, 9})

	set.Remove(2, 7)
	expectedOrder := []int{3, 5, 9}
	assert.Equal(t, expectedOrder, set.ToSlice())

	set.Remove(3, 5, 9)
	expectedOrder = []int{}
	assert.Equal(t, expectedOrder, set.ToSlice())

	set.Remove(1)
	expectedOrder = []int{}
	assert.Equal(t, expectedOrder, set.ToSlice())
}