package reflux

import (
	"testing"
)

// TestNestedRInMap 测试在 map 中嵌套 R 对象的情况
func TestNestedRInMap(t *testing.T) {
	// 创建一个嵌套的 R 对象
	inner := New(map[string]any{
		"X": map[string]any{
			"XX": "value",
		},
	})

	// 将 R 对象嵌入到 map 中
	outer := New(map[string]any{
		"A": inner,
	})

	// 尝试通过路径访问
	result := outer.Get("A", "X", "XX").String()
	if result != "value" {
		t.Errorf("Expected 'value', got '%s'", result)
	}

	// 尝试通过点号路径访问
	result2 := outer.Get("A.X.XX").String()
	if result2 != "value" {
		t.Errorf("Expected 'value', got '%s'", result2)
	}
}

// TestNestedRSetInMap 测试在包含 R 对象的 map 中设置值
func TestNestedRSetInMap(t *testing.T) {
	inner := New(map[string]any{
		"X": map[string]any{
			"XX": "old_value",
		},
	})

	outer := New(map[string]any{
		"A": inner,
	})

	// 尝试通过路径设置值
	outer.Set("A.X.XX", "new_value")

	result := outer.Get("A.X.XX").String()
	if result != "new_value" {
		t.Errorf("Expected 'new_value', got '%s'", result)
	}
}

// TestNestedRInStruct 测试在 struct 中嵌套 R 对象
func TestNestedRInStruct(t *testing.T) {
	type Container struct {
		Data R
	}

	inner := New(map[string]any{
		"Name": "Alice",
		"Age":  30,
	})

	container := Container{Data: inner}
	outer := New(&container)

	// 通过路径访问
	name := outer.Get("Data", "Name").String()
	if name != "Alice" {
		t.Errorf("Expected 'Alice', got '%s'", name)
	}

	// 通过点号路径访问
	age := outer.Get("Data.Age").Int()
	if age != 30 {
		t.Errorf("Expected 30, got %d", age)
	}

	// 设置值
	outer.Set("Data.Name", "Bob")
	newName := outer.Get("Data.Name").String()
	if newName != "Bob" {
		t.Errorf("Expected 'Bob', got '%s'", newName)
	}
}

// TestNestedRInSlice 测试在 slice 中嵌套 R 对象
func TestNestedRInSlice(t *testing.T) {
	r1 := New(map[string]any{"id": 1, "name": "Alice"})
	r2 := New(map[string]any{"id": 2, "name": "Bob"})

	outer := New(map[string]any{
		"items": []any{r1, r2},
	})

	// 访问 slice 中的 R 对象
	name1 := outer.Get("items", "0", "name").String()
	if name1 != "Alice" {
		t.Errorf("Expected 'Alice', got '%s'", name1)
	}

	name2 := outer.Get("items.1.name").String()
	if name2 != "Bob" {
		t.Errorf("Expected 'Bob', got '%s'", name2)
	}

	// 设置值
	outer.Set("items.0.name", "Charlie")
	newName := outer.Get("items.0.name").String()
	if newName != "Charlie" {
		t.Errorf("Expected 'Charlie', got '%s'", newName)
	}
}

// TestDeepNestedR 测试深度嵌套的 R 对象
func TestDeepNestedR(t *testing.T) {
	level3 := New(map[string]any{
		"value": "deep",
	})

	level2 := New(map[string]any{
		"level3": level3,
	})

	level1 := New(map[string]any{
		"level2": level2,
	})

	outer := New(map[string]any{
		"level1": level1,
	})

	// 深度路径访问
	value := outer.Get("level1", "level2", "level3", "value").String()
	if value != "deep" {
		t.Errorf("Expected 'deep', got '%s'", value)
	}

	// 深度路径设置
	outer.Set("level1.level2.level3.value", "updated")
	newValue := outer.Get("level1.level2.level3.value").String()
	if newValue != "updated" {
		t.Errorf("Expected 'updated', got '%s'", newValue)
	}
}

// TestNestedRExists 测试 Exists 方法对嵌套 R 对象的支持
func TestNestedRExists(t *testing.T) {
	inner := New(map[string]any{
		"X": map[string]any{
			"XX": "value",
		},
	})

	outer := New(map[string]any{
		"A": inner,
	})

	if !outer.Exists("A", "X", "XX") {
		t.Error("Expected A.X.XX to exist")
	}

	if outer.Exists("A", "X", "YY") {
		t.Error("Expected A.X.YY to not exist")
	}
}

// TestNestedRArray 测试 Array 方法
func TestNestedRArray(t *testing.T) {
	r1 := New(map[string]any{"id": 1})
	r2 := New(map[string]any{"id": 2})

	outer := New(map[string]any{
		"items": []any{r1, r2},
	})

	items := outer.Get("items").Array()
	if len(items) != 2 {
		t.Errorf("Expected 2 items, got %d", len(items))
	}

	// 验证数组元素可以访问
	id1 := items[0].Get("id").Int()
	if id1 != 1 {
		t.Errorf("Expected id 1, got %d", id1)
	}
}