package ds

import "testing"

// 辅助:int 指针构造器,简化测试用例。
func iptr(i int) *int { return &i }

func TestBuildTreeRoundTrip(t *testing.T) {
	//     1
	//    / \
	//   2   3
	//      / \
	//     4   5
	vals := []*int{iptr(1), iptr(2), iptr(3), nil, nil, iptr(4), iptr(5)}
	root := BuildTree[int](vals)
	if root == nil {
		t.Fatal("BuildTree 不应返回 nil")
	}
	// 层序应为 [1,2,3,nil,nil,4,5]
	out := TreeToLevelOrder[int](root)
	want := []*int{iptr(1), iptr(2), iptr(3), nil, nil, iptr(4), iptr(5)}
	if len(out) != len(want) {
		t.Fatalf("TreeToLevelOrder 长度 = %d, want %d", len(out), len(want))
	}
	for i := range want {
		if (out[i] == nil) != (want[i] == nil) {
			t.Fatalf("位置 %d: out nil=%v, want nil=%v", i, out[i] == nil, want[i] == nil)
		}
		if out[i] != nil && *out[i] != *want[i] {
			t.Fatalf("位置 %d: out = %d, want %d", i, *out[i], *want[i])
		}
	}
}

func TestBuildTreeTraversals(t *testing.T) {
	//     1
	//    / \
	//   2   3
	//  / \
	// 4   5
	vals := []*int{iptr(1), iptr(2), iptr(3), iptr(4), iptr(5)}
	root := BuildTree[int](vals)

	pre := PreOrderAny[int](root)
	wantPre := []int{1, 2, 4, 5, 3}
	for i := range wantPre {
		if pre[i] != wantPre[i] {
			t.Fatalf("PreOrderAny[%d] = %d, want %d", i, pre[i], wantPre[i])
		}
	}

	in := InOrderAny[int](root)
	wantIn := []int{4, 2, 5, 1, 3}
	for i := range wantIn {
		if in[i] != wantIn[i] {
			t.Fatalf("InOrderAny[%d] = %d, want %d", i, in[i], wantIn[i])
		}
	}

	post := PostOrderAny[int](root)
	wantPost := []int{4, 5, 2, 3, 1}
	for i := range wantPost {
		if post[i] != wantPost[i] {
			t.Fatalf("PostOrderAny[%d] = %d, want %d", i, post[i], wantPost[i])
		}
	}

	lvl := LevelOrderAny[int](root)
	wantLvl := []int{1, 2, 3, 4, 5}
	for i := range wantLvl {
		if lvl[i] != wantLvl[i] {
			t.Fatalf("LevelOrderAny[%d] = %d, want %d", i, lvl[i], wantLvl[i])
		}
	}
}

func TestBuildTreeEdgeCases(t *testing.T) {
	// 空数组
	if r := BuildTree[int](nil); r != nil {
		t.Fatal("空数组应返回 nil")
	}
	// 数组首元素为 nil
	if r := BuildTree[int]([]*int{nil, iptr(1)}); r != nil {
		t.Fatal("首元素 nil 应返回 nil")
	}
	// 单节点
	root := BuildTree[int]([]*int{iptr(42)})
	if root.Val != 42 || root.Left != nil || root.Right != nil {
		t.Fatalf("单节点树结构错误: %+v", root)
	}
}

func TestMaxDepth(t *testing.T) {
	//     1
	//    / \
	//   2   3
	//  /
	// 4
	vals := []*int{iptr(1), iptr(2), iptr(3), iptr(4)}
	root := BuildTree[int](vals)
	if d := MaxDepth[int](root); d != 3 {
		t.Fatalf("MaxDepth = %d, want 3", d)
	}
	if d := MaxDepth[int](nil); d != 0 {
		t.Fatalf("空树 MaxDepth = %d, want 0", d)
	}
}