<!-- more -->
// 静态类型是 string，值是 "hello, world"
a := "hello, world"
// 静态类型是 int32，值是 12
b := int32(12)

var a interface{}
// 静态类型是 interface{}，值是 ("hello world", string) 对
a = "hello world"

a := 12
aValue := reflect.ValueOf(a)

b := &Point{}
bType := reflect.TypeOf(b)

func ValueOf(i any) Value {
    ...
}

var x float64 = 3.4
v := reflect.ValueOf(x)
v.SetFloat(7.1) // Error: will panic.

var x float64 = 3.4
v := reflect.ValueOf(&x) // 获取到指向 x 的指针的反射对象
for v.Kind() == reflect.Ptr {
    v = v.Elem() // 取得指针指向的值的反射对象
}
if v.CanSet() {
    v.SetFloat(7.1) // 设置指针指向的值
}
fmt.Println(v.Interface()) // 输出 7.1

const (
	Invalid Kind = iota
	Bool
	Int
	Int8
	Int16
	Int32
	Int64
	Uint
	Uint8
	Uint16
	Uint32
	Uint64
	Uintptr
	Float32
	Float64
	Complex64
	Complex128
	Array
	Chan
	Func
	Interface
	Map
	Pointer
	Slice
	String
	Struct
	UnsafePointer
)

type Type interface {
    // 类型的对齐值
    func Align() int
    // 类型作为其它结构体的字段时的对齐值。大多数情况和 Align() 一样，不一样的时候目前还不清楚
    func FieldAlign() int

    // 获取第 i 个方法，方法按字典顺序排
    Method(int) Method
    // 通过方法名获取方法
    MethodByName(string) (Method, bool)
    // 方法数量：非接口类型仅包括导出方法；接口类型既包括导出方法，也包括非导出方法
    NumMethod() int
  
  	// 类型名（包含包路径）
  	Name() string
  	// 包路径
	  PkgPath() string	
  	// 该类型的值需要占用的字节数。类似 unsafe.Sizeof
  	Size() uintptr
  
 		// 返回类型的字符串表示，不同的类型的 String() 可能一样，不保证唯一
  	String() string
  
  	// 当前类型是否实现了接口 u
  	Implements(u Type) bool
  	// 当前类型的值是否可赋值给类型 u 的变量
  	//（可以赋值的几种情况：当前类型实现了接口 u; 当前类型是一个接口，但 u 是兼容的更大的接口; 类型相同等）
  	AssignableTo(u Type) bool
  	// 当前类型是否可以转换为类型 u，即 T(x) 这种转换能否成功
  	ConvertibleTo(u Type) bool
  
  	// 当前类型的值是否可比较
  	Comparable() bool
  
  	// 仅对所有整型、无符号整型、浮点型、复数类型有效，返回该类型所占用的位宽，比如 8 16 32 64 之类的
  	Bits() int
  
  	// 仅当 chan 是时有效，返回通道方向
  	ChanDir() ChanDir
  
  	// 仅当 slice、array、chan、map、指针 时有效，返回它们包含的元素的类型
  	Elem() Type
  
  	// 如下几个方法仅当结构体时有效
  	// 返回第 i 个字段，字段顺序就是声明顺序
  	Field(i int) StructField
  	// 按照索引返回字段，支持嵌套，比如字段的类型也是结构体，则可以获取该结构体的字段
  	FieldByIndex(index []int) StructField
  	// 按字段名获取字段，也支持嵌套
  	FieldByName(name string) (StructField, bool)
  	// 还是按照名称找，只不过使用函数支持更加复杂的处理
  	FieldByNameFunc(match func(string) bool) (StructField, bool)
  	// 导出字段的数量。不包含嵌套
	  NumField() int
  
  	// 如下几个方法仅当函数时有效
  	// 获取第 i 个入参数的类型（如果有接收值，接收值就是第一个参数）
  	In(i int) Type
  	// 获取第 i 个返回值的类型
	  Out(i int) Type
  	// 入参数量（算接收值的）
  	NumIn() int
  	// 出参数量
  	NumOut() int
  	// 判断最后一个参数是否为可变参数。如果是，那么最后一个参数就是 []T 类型
  	IsVariadic() bool
  
  	// 仅当 map 时有效，返回 key 的类型
  	Key() Type
  
  	// 仅当 Array 时有效，返回数组的长度
  	Len() int
}

type Struct1 struct {
	Field1 int8
	Field2 int64
	Field3 int8
}
type Struct2 struct {
	Field1 int8
	Field3 int8
	Field2 int64
}

func main() {
	st1 := Struct1{Field1: 1, Field2: 2, Field3: 3}
	st2 := Struct2{Field1: 1, Field3: 3, Field2: 2}
	println(unsafe.Sizeof(st1)) // 输出 24
	println(unsafe.Sizeof(st2)) // 输出 16
}

var slice1 any = []string{"1", "2"}
var slice2 any = []string{"1", "2"}
println(slice1 == slice2) // panic: runtime error: comparing uncomparable type []string

var slice1 any = []string{"1", "2"}
var slice2 any = []string{"1", "2"}
if reflect.TypeOf(slice1).Comparable() && reflect.TypeOf(slice2).Comparable() {
  println(slice1 == slice2)
}

a := 12
b := 1.1
println(a == b) // compile error: invalid operation: a == b (mismatched types int and float64)

var a any = 12
var b any = 1.1
println(a == b) // output: false

rValue := reflect.ValueOf(12)
rValueType := reflect.TypeOf(rValue)
for i := 0; i < rValueType.NumMethod(); i++ {
  methodName := rValueType.Method(i).Name
  methodType := rValueType.Method(i).Type
  methodInParams := []string{}
  methodOutParams := []string{}
  for j := 1; j < methodType.NumIn(); j++ {
    methodInParams = append(methodInParams, methodType.In(j).Name())
  }
  for j := 0; j < methodType.NumOut(); j++ {
    methodOutParams = append(methodOutParams, methodType.Out(j).Name())
  }
  fmt.Printf("%s(%s) %s\n", methodName, strings.Join(methodInParams, ","), strings.Join(methodOutParams, ","))
}

// 获取 Type 对象
func Type() Type
// 返回 Kind，得到的效果和 Type.Kind() 一样
func Kind() Kind

func CanAddr() bool
// 返回指针值对象，该指针指向当前值（仅当当前值是 CanAddr 的才能返回，否则报 panic）
func Addr() Value
// 获取指针。仅对 指针、map、chan、slice、func、interface 有效
func Pointer() uintptr
// 也是返回指针，只不过类型是 unsafe.Pointer，也仅对 指针、map、chan、slice、func、interface 有效
func UnsafePointer() unsafe.Pointer
// 对所有可寻址的对象有效，返回存储数据的地址。当 指针、map、chan、slice、func、interface 时，得到的结果和 Pointer() 一样
func UnsafeAddr() uintptr
// 对 interface 或 pointer 有效
// interface 时返回其包含的元素反射值对象；指针时返回其执行的元素的反射值对象
func Elem() Value
// 判断是否 nil。仅对 指针、map、chan、slice、func、string、UnsafePointer 有效
func IsNil() bool
// 仅对 UnsafePointer，设置一个新的指针
func SetPointer(x unsafe.Pointer)

// 是否可设置值，仅当一个值是是 CanAddr，且是导出的，才能够设置值
func CanSet() bool
// 设置值的通用方法
func Set(Value) 
// 设置为当前类型的空值
func SetZero() 
// 将 *MapIter 当前轮 key 设置到当前值
func SetIterKey(iter *MapIter) 
// 将 *MapIter 当前轮 value 设置到当前值
func SetIterValue(iter *MapIter) 
// 说明：MapIter 是 MapRange() 函数返回的，设置上面两个方法是为了直接从 MapRange 返回的内容设置，避免创建新的 Value 对象

// 一些具体类型的方法
func Bool() bool
func SetBool(bool) 

func Bytes() []byte
func SetBytes() 

func CanFloat() bool
func Float() float64
func SetFloat(float64) 
func OverflowFloat(float64) bool // 判断将给定值赋给当前值时是否会发生溢出

func CanInt() bool
func Int() int64
func SetInt(int64)
func OverflowInt(int64) bool

func CanUint() bool
func Uint() uint64
func SetUint(uint64) 
func OverflowUint(uint64) bool

func CanComplex() bool
func Complex() complex128
func SetComplex(complex128) 
func OverflowComplex(complex128) bool

// 仅对通道，阻塞地接收一个元素
func Recv() (x Value, ok bool)
// 仅对通道，阻塞地发送一个元素
func Send(Value) 
// 仅对通道，非阻塞地接受一个元素
func TryRecv() Value,bool
func TrySend(Value) bool
// 仅对通道，关闭通道
func Close() 

// 如下仅对 map 生效
// 返回指定 key 对应的值的 Value 对象
func MapIndex(key Value) Value
// 返回所有 key
func MapKeys() []Value
// 返回一个用于遍历 map 的迭代器
func MapRange() *MapIter
// 设置一个键值对
func SetMapIndex(key, elem Value) 

// 仅对 array slice string 有用，返回 v[i:j]
func Slice(int,int) Value
// 仅对 array slice 有用，返回 v[i:j:k]
func Slice3(int,int,int) Value
// 仅对 slice 有用，设置容量
func SetCap(int) 
// 仅对 slice 有用，设置长度
func SetLen(int) 
// 仅对 slice，增长 n 个容量。增长后，添加 n 个以内的元素都不会再触发内存分配
func Grow(int) 
// 仅对 slice，返回容量
func Cap() int

// 仅对 array slice string 有效，返回第 i 个元素
func Index(int) Value

// 仅对 array slice map chan string 以及指向 array 的指针有效。返回长度
func Len() int

// 仅对 slice 和 map，清空切片或者 map 包含的值
func Clear() 

// 检测调用 Interface() 时会不会 panic
func CanInterface() bool
// 以 interface{} 形式返回值对象代表的值，等效于: var i interface{} = (v's underlying value)
func Interface() 
// 已过时，不用管
func InterfaceData() 

// 如果是 string，就返回字符串的值；否则返回 (T value) 这样的值，比如 <*main.mystruct Value>；它不会调用类型的 String 方法。
func String() string
// 仅对 String 有效，设置字符串
func SetString(string) 

// Func 相关和 Type 中定义的差不多，但是多了 Call 方法
func Method(int) Value
func MethodByName(string) Value
func NumMethod() int
// 调用方法，in 会作为参数逐个传递
func Call(in []Value) []Value
// 调用带有可变参数的方法，in 切片的最后一个元素会被传递给可变参数
func CallSlice(in []Value) []Value

// 是否可转换成目标类型，这里的转换就是 T(x) 这种转换
func CanConvert(Type) bool
func Convert(Type) Value

// 是否可比较，如果当前值是 interface{}，则检查其代表的具体类型是否可比较
func Comparable() bool
// 比较：如果当前值和目标值具有不同的类型，直接返回 false；如果是 interface{} 则比较具体类型；其它情况比较值
// 这个和 == 其实差不对，只不过 == 会在编译器检查并报错
func Equal(Value) bool


// 以下仅对 struct 有效
// 返回第 i 个字段
func Field(int) Value
// 返回嵌套字段
func FieldByIndex([]int) Value
// 返回嵌套字段，如果 index 路径上有空指针，返回一个 error。
func FieldByIndexErr([]int) Value,error
func FieldByName(string) Value
func FieldByNameFunc(func(string) bool) Value
func NumField() int

// 返回当前是否是一个有效值。一般来说，function 和 method 得到的 Value 都是无效的；
// 此外，通过 reflect.Zero() 创建的 Value 是无效的
func IsValid() bool

// 判断当前值是否是其所代表类型的空值
func IsZero() bool

a := 12
aValue := reflect.ValueOf(a)
println(aValue.CanAddr()) // false

b := lo.ToPtr(12)
bValue := reflect.ValueOf(b)
println(bValue.CanAddr())        // false
println(bValue.Elem().CanAddr()) // true

s := lo.ToPtr(12)
sValue := reflect.ValueOf(&s)
println(sValue.CanAddr())               // false
println(sValue.Elem().CanAddr())        // true
println(sValue.Elem().Elem().CanAddr()) // true

type mystr string

func (m *mystr) Hello() {
	println("hello, mystr")
}

type mystruct struct {
	Field1 mystr
}

func main() {
	s := &mystruct{Field1: "嘻嘻"}
	sValue := reflect.ValueOf(s)

	fieldValue := sValue.Elem().Field(0) // 获取 Field1 的反射值对象，类型是 mystr
	fieldPtrValue := fieldValue.Addr()   // Field1 的地址的反射纸对象，类型是 *mystr

	println(fieldValue.NumMethod())                 // 输出 0
	println(fieldPtrValue.NumMethod())              // 输出 1
	fieldPtrValue.Method(0).Call([]reflect.Value{}) // 输出 hello, mystr
}

type MyStruct struct {
	A int32
	B int64
}

func main() {
	s := MyStruct{
		A: 123,
		B: 456,
	}

	basePtr := unsafe.Pointer(&s)
	offsetB := unsafe.Offsetof(s.B)
	bPtr := (*int64)(unsafe.Pointer(uintptr(basePtr) + offsetB))

	// 修改字段 B 的值
	*bPtr = 999

	fmt.Println("s.A =", s.A) // 输出 123
	fmt.Println("s.B =", s.B) // 输出 999（被我们通过偏移写入的）
}

// 创建 reflect.Value
// 创建零值
func Zero(typ Type) Value
// 创建切片
func MakeSlice(typ Type, len, cap int) Value
func SliceAt(typ Type, p unsafe.Pointer, n int) Value // 创建切片，切片其实地址是 p
// 创建 map
func MakeMap(typ Type) Value
func MakeMapWithSize(typ Type, n int) Value
// 创建函数
func MakeFunc(typ Type, fn func(args []Value) (results []Value)) Value
// 创建指针
func New(typ Type) Value
func NewAt(typ Type, p unsafe.Pointer) Value // 创建指针，指针的值是传入的 p
// 创建通道
func MakeChan(typ Type, buffer int) Value


// 解一次引用
func Indirect(v Value) Value

// 切片操作
// 逐个元素添加
func Append(s Value, x ...Value) Value 
// 添加一批元素
func AppendSlice(s, t Value) Value

// select 操作
func Select(cases []SelectCase) (chosen int, recv Value, recvOK bool)

// 获取一个变量的 reflect.Value
func ValueOf(i any) Value

// 目标切片长度为0，不会复制任何东西
var s1 []string = make([]string, 0)
var s2 []string = []string{"hello"}
s1Value := reflect.ValueOf(s1)
s2Value := reflect.ValueOf(s2)
result := reflect.Copy(s1Value, s2Value)
// 目标切片长度为 1，能复制成功
var s1 []string = make([]string, 1)
var s2 []string = []string{"hello"}
s1Value := reflect.ValueOf(s1)
s2Value := reflect.ValueOf(s2)
result := reflect.Copy(s1Value, s2Value)

func retrieveVarAsString(v any) ([]string, bool) {
	// 仅支持基础类型，不支持复杂类型
	var values []string
	switch v := v.(type) {
	case []any:
		......
	case int, int8, int16, int32, int64:
		values = append(values, fmt.Sprintf("%d", v))
	case uint, uint8, uint16, uint32, uint64:
		values = append(values, fmt.Sprintf("%d", v))
	case float32, float64:
		values = append(values, fmt.Sprintf("%f", v))
	case string:
		values = append(values, v)
	default:
		return nil, false
	}
	return values, true
}

func ValidateStruct(s interface{}) error

func validate(in interface{}) error {
	return validateValue(reflect.ValueOf(in))
}

func validateValue(v reflect.Value) error {
	switch v.Kind() {
	case reflect.Slice, reflect.Array:
		for i := 0; i < v.Len(); i++ {
			if err := validateValue(v.Index(i)); err != nil {
				return err
			}
		}
	case reflect.Map:
		iter := v.MapRange()
		for iter.Next() {
			if err := validateValue(iter.Value()); err != nil {
				return err
			}
		}
	case reflect.Pointer, reflect.Interface:
		if v.IsNil() {
			return nil
		}
		return validateValue(v.Elem())
	case reflect.Struct:
		for i := 0; i < v.NumField(); i++ {
			fieldValue := v.Field(i)
			structField := v.Type().Field(i)
			fieldName := structField.Name
			fieldTag := structField.Tag

			// 先对当前字段做检查
			validateStr, ok := fieldTag.Lookup("validate")
			if !ok {
				continue
			}
			constraints := strings.Split(validateStr, ",")
			for _, constraint := range constraints {
				if constraint == "required" && fieldValue.IsZero() {
					return fmt.Errorf("字段 %s 不可为空值", fieldName)
				}
				if strings.Contains(constraint, "min=") {
					min := strings.TrimPrefix(constraint, "min=")
					if err := validateMin(fieldName, fieldValue, min); err != nil {
						return err
					}
				}
			}

			// 如果字段是复合类型，还需要对复合类型的元素做检查
			for fieldValue.Kind() == reflect.Interface {
				fieldValue = fieldValue.Elem()
			}
			for fieldValue.Kind() == reflect.Ptr && !fieldValue.IsNil() {
				fieldValue = fieldValue.Elem()
			}
			switch fieldValue.Kind() {
			case reflect.Struct, reflect.Map, reflect.Slice, reflect.Array:
				if err := validateValue(fieldValue); err != nil {
					return err
				}
			}
		}
	default:
		return errors.New("Type not support")
	}
	return nil
}

func validateMin(fieldName string, fieldValue reflect.Value, min string) error {
	minInt, err := strconv.Atoi(min)
	if err != nil {
		return fmt.Errorf("%s: min 的参数必须为 int，实际为 %s.", fieldName, min)
	}
	switch fieldValue.Kind() {
	case reflect.Ptr, reflect.Interface:
		return validateMin(fieldName, fieldValue.Elem(), min)
	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
		if fieldValue.Int() < int64(minInt) {
			return fmt.Errorf("%s:  的值小于最小值 %s", fieldName, min)
		}
		return nil
	default:
		return fmt.Errorf("%s: min 只能用在 int 类型", fieldName)
	}
}