/*
01-reflection.go - Go 语言反射详解

学习目标：
1. 理解反射的概念和原理
2. 掌握 reflect 包的基本使用
3. 学会反射的类型和值操作
4. 了解反射的应用场景
5. 掌握反射的最佳实践和注意事项

知识点：
- 反射的基本概念
- reflect.Type 和 reflect.Value
- 类型检查和转换
- 结构体字段和方法的反射
- 反射的性能考虑
- 反射的实际应用
*/

package main

import (
	"fmt"
	"reflect"
	"strconv"
	"strings"
	"time"
)

func main() {
	fmt.Println("=== Go 语言反射详解 ===\\n")

	// 演示反射的基本概念
	demonstrateReflectionBasics()

	// 演示类型反射
	demonstrateTypeReflection()

	// 演示值反射
	demonstrateValueReflection()

	// 演示结构体反射
	demonstrateStructReflection()

	// 演示方法反射
	demonstrateMethodReflection()

	// 演示反射的实际应用
	demonstratePracticalApplications()

	// 演示反射的最佳实践
	demonstrateBestPractices()
}

// demonstrateReflectionBasics 演示反射的基本概念
func demonstrateReflectionBasics() {
	fmt.Println("1. 反射的基本概念:")

	// 反射的基本概念
	fmt.Printf("   反射的基本概念:\\n")
	fmt.Printf("     - 反射是程序在运行时检查自身结构的能力\\n")
	fmt.Printf("     - Go 通过 reflect 包提供反射功能\\n")
	fmt.Printf("     - 反射基于接口的动态类型信息\\n")
	fmt.Printf("     - 主要包括类型反射和值反射\\n")
	fmt.Printf("     - 反射遵循 Go 的类型系统规则\\n")

	// 反射的核心类型
	fmt.Printf("   反射的核心类型:\\n")
	fmt.Printf("     - reflect.Type: 表示类型信息\\n")
	fmt.Printf("     - reflect.Value: 表示值信息\\n")
	fmt.Printf("     - reflect.Kind: 表示基础类型种类\\n")

	// 基本反射示例
	fmt.Printf("   基本反射示例:\\n")

	var x interface{} = 42

	// 获取类型信息
	t := reflect.TypeOf(x)
	fmt.Printf("     类型: %v\\n", t)
	fmt.Printf("     类型名称: %s\\n", t.Name())
	fmt.Printf("     类型种类: %v\\n", t.Kind())

	// 获取值信息
	v := reflect.ValueOf(x)
	fmt.Printf("     值: %v\\n", v)
	fmt.Printf("     值的类型: %v\\n", v.Type())
	fmt.Printf("     值的种类: %v\\n", v.Kind())
	fmt.Printf("     值的接口: %v\\n", v.Interface())

	// 不同类型的反射
	fmt.Printf("   不同类型的反射:\\n")

	values := []interface{}{
		42,
		"hello",
		3.14,
		true,
		[]int{1, 2, 3},
		map[string]int{"a": 1},
		Person{Name: "Alice", Age: 30},
	}

	for i, val := range values {
		t := reflect.TypeOf(val)
		v := reflect.ValueOf(val)
		fmt.Printf("     值%d: %v (类型: %v, 种类: %v)\\n",
			i+1, val, t, v.Kind())
	}

	fmt.Println()
}

// demonstrateTypeReflection 演示类型反射
func demonstrateTypeReflection() {
	fmt.Println("2. 类型反射:")

	// 基本类型反射
	fmt.Printf("   基本类型反射:\\n")

	var i int = 42
	var s string = "hello"
	var f float64 = 3.14
	var b bool = true

	types := []interface{}{i, s, f, b}
	for _, val := range types {
		t := reflect.TypeOf(val)
		fmt.Printf("     %v: 名称=%s, 种类=%v, 大小=%d字节\\n",
			val, t.Name(), t.Kind(), t.Size())
	}

	// 复合类型反射
	fmt.Printf("   复合类型反射:\\n")

	// 切片类型
	slice := []int{1, 2, 3}
	sliceType := reflect.TypeOf(slice)
	fmt.Printf("     切片类型: %v\\n", sliceType)
	fmt.Printf("     元素类型: %v\\n", sliceType.Elem())
	fmt.Printf("     是否为切片: %t\\n", sliceType.Kind() == reflect.Slice)

	// 映射类型
	m := map[string]int{"a": 1, "b": 2}
	mapType := reflect.TypeOf(m)
	fmt.Printf("     映射类型: %v\\n", mapType)
	fmt.Printf("     键类型: %v\\n", mapType.Key())
	fmt.Printf("     值类型: %v\\n", mapType.Elem())

	// 指针类型
	var p *int = &i
	ptrType := reflect.TypeOf(p)
	fmt.Printf("     指针类型: %v\\n", ptrType)
	fmt.Printf("     指向类型: %v\\n", ptrType.Elem())
	fmt.Printf("     是否为指针: %t\\n", ptrType.Kind() == reflect.Ptr)

	// 函数类型
	fn := func(int, string) bool { return true }
	fnType := reflect.TypeOf(fn)
	fmt.Printf("     函数类型: %v\\n", fnType)
	fmt.Printf("     参数个数: %d\\n", fnType.NumIn())
	fmt.Printf("     返回值个数: %d\\n", fnType.NumOut())

	for i := 0; i < fnType.NumIn(); i++ {
		fmt.Printf("     参数%d类型: %v\\n", i, fnType.In(i))
	}

	for i := 0; i < fnType.NumOut(); i++ {
		fmt.Printf("     返回值%d类型: %v\\n", i, fnType.Out(i))
	}

	// 通道类型
	ch := make(chan int)
	chType := reflect.TypeOf(ch)
	fmt.Printf("     通道类型: %v\\n", chType)
	fmt.Printf("     通道方向: %v\\n", chType.ChanDir())
	fmt.Printf("     元素类型: %v\\n", chType.Elem())

	fmt.Println()
}

// demonstrateValueReflection 演示值反射
func demonstrateValueReflection() {
	fmt.Println("3. 值反射:")

	// 基本值操作
	fmt.Printf("   基本值操作:\\n")

	var x interface{} = 42
	v := reflect.ValueOf(x)

	fmt.Printf("     原始值: %v\\n", v.Interface())
	fmt.Printf("     整数值: %d\\n", v.Int())
	fmt.Printf("     是否有效: %t\\n", v.IsValid())
	fmt.Printf("     是否为零值: %t\\n", v.IsZero())

	// 值的修改
	fmt.Printf("   值的修改:\\n")

	var y int = 100
	v = reflect.ValueOf(&y) // 需要传递指针才能修改
	if v.Kind() == reflect.Ptr && v.Elem().CanSet() {
		v.Elem().SetInt(200)
		fmt.Printf("     修改后的值: %d\\n", y)
	}

	// 字符串值操作
	var str string = "hello"
	v = reflect.ValueOf(&str)
	if v.Kind() == reflect.Ptr && v.Elem().CanSet() {
		v.Elem().SetString("world")
		fmt.Printf("     修改后的字符串: %s\\n", str)
	}

	// 切片值操作
	fmt.Printf("   切片值操作:\\n")

	slice := []int{1, 2, 3}
	v = reflect.ValueOf(slice)

	fmt.Printf("     切片长度: %d\\n", v.Len())
	fmt.Printf("     切片容量: %d\\n", v.Cap())

	// 访问切片元素
	for i := 0; i < v.Len(); i++ {
		elem := v.Index(i)
		fmt.Printf("     元素[%d]: %v\\n", i, elem.Interface())
	}

	// 映射值操作
	fmt.Printf("   映射值操作:\\n")

	m := map[string]int{"a": 1, "b": 2, "c": 3}
	v = reflect.ValueOf(m)

	fmt.Printf("     映射长度: %d\\n", v.Len())

	// 遍历映射
	for _, key := range v.MapKeys() {
		value := v.MapIndex(key)
		fmt.Printf("     %v: %v\\n", key.Interface(), value.Interface())
	}

	// 设置映射值
	v.SetMapIndex(reflect.ValueOf("d"), reflect.ValueOf(4))
	fmt.Printf("     添加元素后: %v\\n", m)

	// 创建新值
	fmt.Printf("   创建新值:\\n")

	// 创建新的整数值
	newInt := reflect.New(reflect.TypeOf(0))
	newInt.Elem().SetInt(999)
	fmt.Printf("     新创建的整数: %v\\n", newInt.Elem().Interface())

	// 创建新的切片
	sliceType := reflect.SliceOf(reflect.TypeOf(0))
	newSlice := reflect.MakeSlice(sliceType, 3, 5)
	for i := 0; i < newSlice.Len(); i++ {
		newSlice.Index(i).SetInt(int64(i * 10))
	}
	fmt.Printf("     新创建的切片: %v\\n", newSlice.Interface())

	fmt.Println()
}

// demonstrateStructReflection 演示结构体反射
func demonstrateStructReflection() {
	fmt.Println("4. 结构体反射:")

	// 结构体类型信息
	fmt.Printf("   结构体类型信息:\\n")

	person := Person{
		Name:  "Alice",
		Age:   30,
		Email: "alice@example.com",
	}

	t := reflect.TypeOf(person)
	v := reflect.ValueOf(person)

	fmt.Printf("     结构体名称: %s\\n", t.Name())
	fmt.Printf("     字段数量: %d\\n", t.NumField())

	// 遍历结构体字段
	fmt.Printf("   遍历结构体字段:\\n")

	for i := 0; i < t.NumField(); i++ {
		field := t.Field(i)
		value := v.Field(i)

		fmt.Printf("     字段%d: %s (类型: %v, 值: %v)\\n",
			i, field.Name, field.Type, value.Interface())

		// 检查字段标签
		if tag := field.Tag; tag != "" {
			fmt.Printf("       标签: %s\\n", tag)
			if jsonTag := tag.Get("json"); jsonTag != "" {
				fmt.Printf("       JSON标签: %s\\n", jsonTag)
			}
		}
	}

	// 按名称访问字段
	fmt.Printf("   按名称访问字段:\\n")

	nameField := v.FieldByName("Name")
	if nameField.IsValid() {
		fmt.Printf("     Name字段值: %v\\n", nameField.Interface())
	}

	// 修改结构体字段
	fmt.Printf("   修改结构体字段:\\n")

	// 需要使用指针才能修改
	v = reflect.ValueOf(&person)
	if v.Kind() == reflect.Ptr {
		v = v.Elem() // 获取指针指向的值

		nameField = v.FieldByName("Name")
		if nameField.CanSet() {
			nameField.SetString("Bob")
			fmt.Printf("     修改后的Name: %s\\n", person.Name)
		}

		ageField := v.FieldByName("Age")
		if ageField.CanSet() {
			ageField.SetInt(35)
			fmt.Printf("     修改后的Age: %d\\n", person.Age)
		}
	}

	// 嵌套结构体
	fmt.Printf("   嵌套结构体:\\n")

	employee := Employee{
		Person: Person{Name: "Charlie", Age: 28},
		Title:  "Developer",
		Salary: 80000,
	}

	t = reflect.TypeOf(employee)
	v = reflect.ValueOf(employee)

	fmt.Printf("     嵌套结构体字段数: %d\\n", t.NumField())

	for i := 0; i < t.NumField(); i++ {
		field := t.Field(i)
		value := v.Field(i)

		fmt.Printf("     字段%d: %s (类型: %v)\\n", i, field.Name, field.Type)

		// 如果是嵌套结构体，进一步展开
		if field.Type.Kind() == reflect.Struct {
			fmt.Printf("       嵌套字段:\\n")
			nestedValue := value
			nestedType := field.Type

			for j := 0; j < nestedType.NumField(); j++ {
				nestedField := nestedType.Field(j)
				nestedFieldValue := nestedValue.Field(j)
				fmt.Printf("         %s: %v\\n", nestedField.Name, nestedFieldValue.Interface())
			}
		} else {
			fmt.Printf("       值: %v\\n", value.Interface())
		}
	}

	fmt.Println()
}

// demonstrateMethodReflection 演示方法反射
func demonstrateMethodReflection() {
	fmt.Println("5. 方法反射:")

	// 方法信息
	fmt.Printf("   方法信息:\\n")

	person := &Person{Name: "David", Age: 25}
	t := reflect.TypeOf(person)
	v := reflect.ValueOf(person)

	fmt.Printf("     方法数量: %d\\n", t.NumMethod())

	// 遍历方法
	for i := 0; i < t.NumMethod(); i++ {
		method := t.Method(i)
		fmt.Printf("     方法%d: %s (类型: %v)\\n", i, method.Name, method.Type)
	}

	// 调用方法
	fmt.Printf("   调用方法:\\n")

	// 按名称获取方法
	greetMethod := v.MethodByName("Greet")
	if greetMethod.IsValid() {
		// 调用无参数方法
		result := greetMethod.Call(nil)
		if len(result) > 0 {
			fmt.Printf("     Greet方法返回: %v\\n", result[0].Interface())
		}
	}

	// 调用带参数的方法
	setAgeMethod := v.MethodByName("SetAge")
	if setAgeMethod.IsValid() {
		args := []reflect.Value{reflect.ValueOf(30)}
		setAgeMethod.Call(args)
		fmt.Printf("     调用SetAge后，年龄: %d\\n", person.Age)
	}

	// 调用带返回值的方法
	getInfoMethod := v.MethodByName("GetInfo")
	if getInfoMethod.IsValid() {
		result := getInfoMethod.Call(nil)
		if len(result) > 0 {
			fmt.Printf("     GetInfo方法返回: %v\\n", result[0].Interface())
		}
	}

	// 函数值的反射调用
	fmt.Printf("   函数值的反射调用:\\n")

	fn := func(a, b int) int {
		return a + b
	}

	fnValue := reflect.ValueOf(fn)
	args := []reflect.Value{
		reflect.ValueOf(10),
		reflect.ValueOf(20),
	}

	result := fnValue.Call(args)
	fmt.Printf("     函数调用结果: %v\\n", result[0].Interface())

	// 方法集的检查
	fmt.Printf("   方法集的检查:\\n")

	// 检查类型是否实现了某个接口
	stringerType := reflect.TypeOf((*fmt.Stringer)(nil)).Elem()
	personType := reflect.TypeOf(person)

	fmt.Printf("     Person是否实现Stringer接口: %t\\n",
		personType.Implements(stringerType))

	fmt.Println()
}

// demonstratePracticalApplications 演示反射的实际应用
func demonstratePracticalApplications() {
	fmt.Println("6. 反射的实际应用:")

	// 应用1: JSON 序列化
	fmt.Printf("   应用1 - JSON 序列化:\\n")

	person := Person{
		Name:  "Eve",
		Age:   32,
		Email: "eve@example.com",
	}

	jsonStr := structToJSON(person)
	fmt.Printf("     JSON序列化结果: %s\\n", jsonStr)

	// 应用2: 结构体复制
	fmt.Printf("   应用2 - 结构体复制:\\n")

	original := Person{Name: "Frank", Age: 40}
	copied := copyStruct(original).(Person)

	fmt.Printf("     原始结构体: %+v\\n", original)
	fmt.Printf("     复制结构体: %+v\\n", copied)

	// 应用3: 结构体比较
	fmt.Printf("   应用3 - 结构体比较:\\n")

	person1 := Person{Name: "Grace", Age: 28}
	person2 := Person{Name: "Grace", Age: 28}
	person3 := Person{Name: "Henry", Age: 30}

	fmt.Printf("     person1 == person2: %t\\n", deepEqual(person1, person2))
	fmt.Printf("     person1 == person3: %t\\n", deepEqual(person1, person3))

	// 应用4: 配置映射
	fmt.Printf("   应用4 - 配置映射:\\n")

	config := map[string]interface{}{
		"Name":  "Iris",
		"Age":   26,
		"Email": "iris@example.com",
	}

	var configPerson Person
	mapToStruct(config, &configPerson)
	fmt.Printf("     配置映射结果: %+v\\n", configPerson)

	// 应用5: 验证器
	fmt.Printf("   应用5 - 验证器:\\n")

	validPerson := Person{Name: "Jack", Age: 25, Email: "jack@example.com"}
	invalidPerson := Person{Name: "", Age: -5, Email: "invalid"}

	fmt.Printf("     有效Person验证: %t\\n", validateStruct(validPerson))
	fmt.Printf("     无效Person验证: %t\\n", validateStruct(invalidPerson))

	// 应用6: ORM 映射
	fmt.Printf("   应用6 - ORM 映射:\\n")

	tableName := getTableName(Person{})
	columns := getColumns(Person{})

	fmt.Printf("     表名: %s\\n", tableName)
	fmt.Printf("     列名: %v\\n", columns)

	fmt.Println()
}

// demonstrateBestPractices 演示反射的最佳实践
func demonstrateBestPractices() {
	fmt.Println("7. 反射的最佳实践:")

	// 最佳实践原则
	fmt.Printf("   最佳实践原则:\\n")
	fmt.Printf("     1. 谨慎使用反射，优先考虑类型安全的方案\\n")
	fmt.Printf("     2. 缓存反射结果以提高性能\\n")
	fmt.Printf("     3. 进行充分的错误检查\\n")
	fmt.Printf("     4. 避免在热点路径使用反射\\n")
	fmt.Printf("     5. 使用接口而不是反射来实现多态\\n")

	// 性能考虑
	fmt.Printf("   性能考虑:\\n")

	// 性能测试示例
	person := Person{Name: "Test", Age: 30}

	// 直接访问 vs 反射访问
	start := time.Now()
	for i := 0; i < 100000; i++ {
		_ = person.Name // 直接访问
	}
	directTime := time.Since(start)

	start = time.Now()
	v := reflect.ValueOf(person)
	nameField := v.FieldByName("Name")
	for i := 0; i < 100000; i++ {
		_ = nameField.Interface() // 反射访问
	}
	reflectTime := time.Since(start)

	fmt.Printf("     直接访问耗时: %v\\n", directTime)
	fmt.Printf("     反射访问耗时: %v\\n", reflectTime)
	fmt.Printf("     性能差异: %.2fx\\n", float64(reflectTime)/float64(directTime))

	// 错误处理
	fmt.Printf("   错误处理:\\n")

	// 安全的反射操作
	safeReflectOperation := func(obj interface{}, fieldName string) (interface{}, error) {
		v := reflect.ValueOf(obj)
		if v.Kind() != reflect.Struct {
			return nil, fmt.Errorf("对象不是结构体")
		}

		field := v.FieldByName(fieldName)
		if !field.IsValid() {
			return nil, fmt.Errorf("字段 %s 不存在", fieldName)
		}

		return field.Interface(), nil
	}

	// 测试安全操作
	result, err := safeReflectOperation(person, "Name")
	if err != nil {
		fmt.Printf("     错误: %v\\n", err)
	} else {
		fmt.Printf("     安全获取Name字段: %v\\n", result)
	}

	result, err = safeReflectOperation(person, "NonExistent")
	if err != nil {
		fmt.Printf("     预期错误: %v\\n", err)
	}

	// 反射的替代方案
	fmt.Printf("   反射的替代方案:\\n")
	fmt.Printf("     1. 接口: 使用接口实现多态\\n")
	fmt.Printf("     2. 类型断言: 处理已知的有限类型集合\\n")
	fmt.Printf("     3. 代码生成: 编译时生成类型安全的代码\\n")
	fmt.Printf("     4. 泛型: Go 1.18+ 支持泛型编程\\n")

	// 何时使用反射
	fmt.Printf("   何时使用反射:\\n")
	fmt.Printf("     ✓ 序列化/反序列化库\\n")
	fmt.Printf("     ✓ ORM 框架\\n")
	fmt.Printf("     ✓ 配置映射\\n")
	fmt.Printf("     ✓ 测试框架\\n")
	fmt.Printf("     ✓ 依赖注入容器\\n")
	fmt.Printf("\\n")
	fmt.Printf("     ✗ 简单的类型转换\\n")
	fmt.Printf("     ✗ 已知类型的操作\\n")
	fmt.Printf("     ✗ 性能敏感的代码\\n")
	fmt.Printf("     ✗ 可以用接口解决的问题\\n")

	fmt.Println()
}

// ========== 类型定义 ==========

// Person 人员结构体
type Person struct {
	Name  string `json:"name" db:"name" validate:"required"`
	Age   int    `json:"age" db:"age" validate:"min=0,max=150"`
	Email string `json:"email" db:"email" validate:"email"`
}

// Greet 问候方法
func (p *Person) Greet() string {
	return fmt.Sprintf("Hello, I'm %s", p.Name)
}

// SetAge 设置年龄
func (p *Person) SetAge(age int) {
	p.Age = age
}

// GetInfo 获取信息
func (p *Person) GetInfo() string {
	return fmt.Sprintf("Name: %s, Age: %d, Email: %s", p.Name, p.Age, p.Email)
}

// String 实现 Stringer 接口
func (p Person) String() string {
	return fmt.Sprintf("Person{Name: %s, Age: %d}", p.Name, p.Age)
}

// Employee 员工结构体
type Employee struct {
	Person
	Title  string  `json:"title" db:"title"`
	Salary float64 `json:"salary" db:"salary"`
}

// ========== 辅助函数 ==========

// structToJSON 将结构体转换为 JSON 字符串
func structToJSON(obj interface{}) string {
	v := reflect.ValueOf(obj)
	t := reflect.TypeOf(obj)

	if v.Kind() != reflect.Struct {
		return "{}"
	}

	var parts []string
	for i := 0; i < v.NumField(); i++ {
		field := t.Field(i)
		value := v.Field(i)

		// 获取 JSON 标签
		jsonTag := field.Tag.Get("json")
		if jsonTag == "" {
			jsonTag = strings.ToLower(field.Name)
		}

		// 根据类型格式化值
		var valueStr string
		switch value.Kind() {
		case reflect.String:
			valueStr = fmt.Sprintf("\\\"%s\\\"", value.String())
		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
			valueStr = fmt.Sprintf("%d", value.Int())
		case reflect.Float32, reflect.Float64:
			valueStr = fmt.Sprintf("%.2f", value.Float())
		case reflect.Bool:
			valueStr = fmt.Sprintf("%t", value.Bool())
		default:
			valueStr = fmt.Sprintf("\\\"%v\\\"", value.Interface())
		}

		parts = append(parts, fmt.Sprintf("\\\"%s\\\": %s", jsonTag, valueStr))
	}

	return "{" + strings.Join(parts, ", ") + "}"
}

// copyStruct 复制结构体
func copyStruct(src interface{}) interface{} {
	srcValue := reflect.ValueOf(src)
	srcType := reflect.TypeOf(src)

	if srcValue.Kind() != reflect.Struct {
		return src
	}

	// 创建新的结构体实例
	newValue := reflect.New(srcType).Elem()

	// 复制所有字段
	for i := 0; i < srcValue.NumField(); i++ {
		srcField := srcValue.Field(i)
		newField := newValue.Field(i)

		if newField.CanSet() {
			newField.Set(srcField)
		}
	}

	return newValue.Interface()
}

// deepEqual 深度比较两个值
func deepEqual(a, b interface{}) bool {
	va := reflect.ValueOf(a)
	vb := reflect.ValueOf(b)

	if va.Type() != vb.Type() {
		return false
	}

	switch va.Kind() {
	case reflect.Struct:
		for i := 0; i < va.NumField(); i++ {
			if !deepEqual(va.Field(i).Interface(), vb.Field(i).Interface()) {
				return false
			}
		}
		return true
	case reflect.Slice:
		if va.Len() != vb.Len() {
			return false
		}
		for i := 0; i < va.Len(); i++ {
			if !deepEqual(va.Index(i).Interface(), vb.Index(i).Interface()) {
				return false
			}
		}
		return true
	case reflect.Map:
		if va.Len() != vb.Len() {
			return false
		}
		for _, key := range va.MapKeys() {
			aVal := va.MapIndex(key)
			bVal := vb.MapIndex(key)
			if !bVal.IsValid() || !deepEqual(aVal.Interface(), bVal.Interface()) {
				return false
			}
		}
		return true
	default:
		return va.Interface() == vb.Interface()
	}
}

// mapToStruct 将 map 映射到结构体
func mapToStruct(m map[string]interface{}, dst interface{}) error {
	dstValue := reflect.ValueOf(dst)
	if dstValue.Kind() != reflect.Ptr || dstValue.Elem().Kind() != reflect.Struct {
		return fmt.Errorf("dst 必须是结构体指针")
	}

	dstValue = dstValue.Elem()
	dstType := dstValue.Type()

	for i := 0; i < dstValue.NumField(); i++ {
		field := dstType.Field(i)
		fieldValue := dstValue.Field(i)

		if !fieldValue.CanSet() {
			continue
		}

		// 从 map 中获取对应的值
		if mapValue, ok := m[field.Name]; ok {
			mapValueReflect := reflect.ValueOf(mapValue)

			// 类型转换
			if mapValueReflect.Type().ConvertibleTo(fieldValue.Type()) {
				fieldValue.Set(mapValueReflect.Convert(fieldValue.Type()))
			}
		}
	}

	return nil
}

// validateStruct 验证结构体
func validateStruct(obj interface{}) bool {
	v := reflect.ValueOf(obj)
	t := reflect.TypeOf(obj)

	if v.Kind() != reflect.Struct {
		return false
	}

	for i := 0; i < v.NumField(); i++ {
		field := t.Field(i)
		value := v.Field(i)

		// 获取验证标签
		validateTag := field.Tag.Get("validate")
		if validateTag == "" {
			continue
		}

		// 解析验证规则
		rules := strings.Split(validateTag, ",")
		for _, rule := range rules {
			if !validateField(value, strings.TrimSpace(rule)) {
				return false
			}
		}
	}

	return true
}

// validateField 验证单个字段
func validateField(value reflect.Value, rule string) bool {
	switch rule {
	case "required":
		return !value.IsZero()
	case "email":
		if value.Kind() == reflect.String {
			email := value.String()
			return strings.Contains(email, "@") && strings.Contains(email, ".")
		}
		return false
	default:
		// 处理 min=0, max=150 等规则
		if strings.HasPrefix(rule, "min=") {
			minStr := strings.TrimPrefix(rule, "min=")
			if min, err := strconv.Atoi(minStr); err == nil {
				if value.Kind() == reflect.Int {
					return value.Int() >= int64(min)
				}
			}
		}
		if strings.HasPrefix(rule, "max=") {
			maxStr := strings.TrimPrefix(rule, "max=")
			if max, err := strconv.Atoi(maxStr); err == nil {
				if value.Kind() == reflect.Int {
					return value.Int() <= int64(max)
				}
			}
		}
	}

	return true
}

// getTableName 获取表名
func getTableName(obj interface{}) string {
	t := reflect.TypeOf(obj)
	if t.Kind() == reflect.Ptr {
		t = t.Elem()
	}

	// 将结构体名转换为表名（简单的复数形式）
	name := t.Name()
	return strings.ToLower(name) + "s"
}

// getColumns 获取列名
func getColumns(obj interface{}) []string {
	t := reflect.TypeOf(obj)
	if t.Kind() == reflect.Ptr {
		t = t.Elem()
	}

	var columns []string
	for i := 0; i < t.NumField(); i++ {
		field := t.Field(i)

		// 获取数据库标签
		dbTag := field.Tag.Get("db")
		if dbTag != "" {
			columns = append(columns, dbTag)
		} else {
			columns = append(columns, strings.ToLower(field.Name))
		}
	}

	return columns
}

/*
运行这个程序：
go run 01-reflection.go

学习要点：
1. 反射是程序在运行时检查自身结构的能力
2. Go 通过 reflect 包提供反射功能
3. 反射主要包括类型反射和值反射
4. 反射可以用于序列化、ORM、配置映射等场景
5. 反射有性能开销，应该谨慎使用

反射的核心概念：
1. reflect.Type: 表示类型信息
2. reflect.Value: 表示值信息
3. reflect.Kind: 表示基础类型种类
4. 反射遵循 Go 的类型系统规则
5. 反射可以检查和修改值

类型反射：
1. 获取类型信息：reflect.TypeOf()
2. 类型名称和种类：Name(), Kind()
3. 复合类型：Elem(), Key(), In(), Out()
4. 结构体字段：NumField(), Field()
5. 方法信息：NumMethod(), Method()

值反射：
1. 获取值信息：reflect.ValueOf()
2. 值的访问：Interface(), Int(), String()
3. 值的修改：Set(), SetInt(), SetString()
4. 集合操作：Len(), Index(), MapIndex()
5. 创建新值：New(), MakeSlice(), MakeMap()

结构体反射：
1. 字段访问：Field(), FieldByName()
2. 字段信息：Name, Type, Tag
3. 字段修改：CanSet(), Set()
4. 标签解析：Tag.Get()
5. 嵌套结构体处理

方法反射：
1. 方法信息：Method(), MethodByName()
2. 方法调用：Call()
3. 方法类型：Type, NumIn(), NumOut()
4. 接口检查：Implements()
5. 方法集分析

实际应用场景：
1. JSON 序列化/反序列化
2. ORM 数据库映射
3. 配置文件映射
4. 结构体验证
5. 依赖注入
6. 测试框架
7. 代码生成工具

性能考虑：
1. 反射比直接访问慢很多
2. 缓存反射结果可以提高性能
3. 避免在热点路径使用反射
4. 考虑使用接口替代反射
5. 编译时代码生成是更好的选择

最佳实践：
1. 谨慎使用反射，优先考虑类型安全
2. 进行充分的错误检查
3. 缓存反射操作的结果
4. 使用接口实现多态
5. 考虑性能影响
6. 提供清晰的文档说明

注意事项：
1. 反射会破坏类型安全
2. 反射代码难以理解和维护
3. 反射错误只能在运行时发现
4. 反射会影响代码的可读性
5. 反射操作可能导致 panic
*/