package langext

import (
	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
	"testing"
)

func TestSortInPlace(t *testing.T) {
	arr := []int{3, 1, 2}
	Sort(arr)
	tst.AssertArrayEqual(t, arr, []int{1, 2, 3})
}

func TestSortStrings(t *testing.T) {
	arr := []string{"c", "a", "b"}
	Sort(arr)
	tst.AssertArrayEqual(t, arr, []string{"a", "b", "c"})
}

func TestAsSorted(t *testing.T) {
	src := []int{3, 1, 2}
	out := AsSorted(src)
	tst.AssertArrayEqual(t, out, []int{1, 2, 3})
	// original unchanged
	tst.AssertArrayEqual(t, src, []int{3, 1, 2})
}

func TestSortStable(t *testing.T) {
	arr := []int{3, 1, 2, 1}
	SortStable(arr)
	tst.AssertArrayEqual(t, arr, []int{1, 1, 2, 3})
}

func TestAsSortedStable(t *testing.T) {
	src := []int{3, 1, 2, 1}
	out := AsSortedStable(src)
	tst.AssertArrayEqual(t, out, []int{1, 1, 2, 3})
	tst.AssertArrayEqual(t, src, []int{3, 1, 2, 1})
}

func TestIsSorted(t *testing.T) {
	tst.AssertEqual(t, IsSorted([]int{1, 2, 3}), true)
	tst.AssertEqual(t, IsSorted([]int{3, 2, 1}), false)
	tst.AssertEqual(t, IsSorted([]int{1, 1, 1}), true)
	tst.AssertEqual(t, IsSorted([]int{}), true)
}

func TestSortSlice(t *testing.T) {
	arr := []int{3, 1, 2}
	SortSlice(arr, func(a, b int) bool { return a < b })
	tst.AssertArrayEqual(t, arr, []int{1, 2, 3})
}

func TestAsSortedSlice(t *testing.T) {
	src := []int{3, 1, 2}
	out := AsSortedSlice(src, func(a, b int) bool { return a > b })
	tst.AssertArrayEqual(t, out, []int{3, 2, 1})
	tst.AssertArrayEqual(t, src, []int{3, 1, 2})
}

func TestSortSliceStable(t *testing.T) {
	arr := []int{3, 1, 2, 1}
	SortSliceStable(arr, func(a, b int) bool { return a < b })
	tst.AssertArrayEqual(t, arr, []int{1, 1, 2, 3})
}

func TestAsSortedSliceStable(t *testing.T) {
	src := []int{3, 1, 2, 1}
	out := AsSortedSliceStable(src, func(a, b int) bool { return a < b })
	tst.AssertArrayEqual(t, out, []int{1, 1, 2, 3})
	tst.AssertArrayEqual(t, src, []int{3, 1, 2, 1})
}

func TestIsSliceSorted(t *testing.T) {
	tst.AssertEqual(t, IsSliceSorted([]int{1, 2, 3}, func(a, b int) bool { return a < b }), true)
	tst.AssertEqual(t, IsSliceSorted([]int{3, 2, 1}, func(a, b int) bool { return a < b }), false)
}

type byKey struct {
	key int
	v   string
}

func TestSortBy(t *testing.T) {
	arr := []byKey{{3, "c"}, {1, "a"}, {2, "b"}}
	SortBy(arr, func(v byKey) int { return v.key })
	tst.AssertEqual(t, arr[0].v, "a")
	tst.AssertEqual(t, arr[1].v, "b")
	tst.AssertEqual(t, arr[2].v, "c")
}

func TestAsSortedBy(t *testing.T) {
	src := []byKey{{3, "c"}, {1, "a"}, {2, "b"}}
	out := AsSortedBy(src, func(v byKey) int { return v.key })
	tst.AssertEqual(t, out[0].v, "a")
	tst.AssertEqual(t, out[2].v, "c")
	// source unchanged
	tst.AssertEqual(t, src[0].v, "c")
}

func TestSortByStable(t *testing.T) {
	arr := []byKey{{1, "a1"}, {1, "a2"}, {0, "b"}}
	SortByStable(arr, func(v byKey) int { return v.key })
	tst.AssertEqual(t, arr[0].v, "b")
	// stable order for ties
	tst.AssertEqual(t, arr[1].v, "a1")
	tst.AssertEqual(t, arr[2].v, "a2")
}

func TestAsSortedByStable(t *testing.T) {
	src := []byKey{{1, "a1"}, {1, "a2"}, {0, "b"}}
	out := AsSortedByStable(src, func(v byKey) int { return v.key })
	tst.AssertEqual(t, out[0].v, "b")
	tst.AssertEqual(t, out[1].v, "a1")
	tst.AssertEqual(t, out[2].v, "a2")
	// source unchanged
	tst.AssertEqual(t, src[0].v, "a1")
}