package mergesort

import (
	"reflect"
	"testing"
)

// MergeSort returns a sorted copy without modifying the input.
func MergeSort(values []int) []int {
	if len(values) <= 1 {
		return append([]int(nil), values...)
	}

	middle := len(values) / 2
	left := MergeSort(values[:middle])
	right := MergeSort(values[middle:])
	return merge(left, right)
}

func merge(left, right []int) []int {
	result := make([]int, 0, len(left)+len(right))
	i, j := 0, 0

	for i < len(left) && j < len(right) {
		if left[i] <= right[j] {
			result = append(result, left[i])
			i++
		} else {
			result = append(result, right[j])
			j++
		}
	}

	result = append(result, left[i:]...)
	result = append(result, right[j:]...)
	return result
}

func TestMergeSort(t *testing.T) {
	input := []int{5, 2, 8, 1, 3}
	want := []int{1, 2, 3, 5, 8}

	if got := MergeSort(input); !reflect.DeepEqual(got, want) {
		t.Fatalf("MergeSort(%v) = %v; want %v", input, got, want)
	}
}

func TestMergeSortWithDuplicatesAndNegatives(t *testing.T) {
	input := []int{3, -1, 3, 0, -5}
	want := []int{-5, -1, 0, 3, 3}

	if got := MergeSort(input); !reflect.DeepEqual(got, want) {
		t.Fatalf("MergeSort(%v) = %v; want %v", input, got, want)
	}
}

func TestMergeSortDoesNotModifyInput(t *testing.T) {
	input := []int{3, 1, 2}
	original := append([]int(nil), input...)

	MergeSort(input)

	if !reflect.DeepEqual(input, original) {
		t.Fatalf("input was modified: got %v; want %v", input, original)
	}
}