func DeepCopy(src interface{}) interface{} {
	v := reflect.ValueOf(src)
	if !v.IsValid() {
		return nil
	}
	return deepCopyValue(v).Interface()
}

func deepCopyValue(v reflect.Value) reflect.Value {
	// 处理零值或不可设置的情况
	if !v.IsValid() {
		return reflect.Zero(v.Type())
	}

	// 处理指针：解引用后拷贝，再取地址
	if v.Kind() == reflect.Ptr {
		if v.IsNil() {
			return reflect.Zero(v.Type())
		}
		elem := deepCopyValue(v.Elem())
		ptr := reflect.New(elem.Type())
		ptr.Elem().Set(elem)
		return ptr
	}

	// 处理 slice：新建 slice，逐项拷贝
	if v.Kind() == reflect.Slice {
		if v.IsNil() {
			return reflect.Zero(v.Type())
		}
		newSlice := reflect.MakeSlice(v.Type(), v.Len(), v.Cap())
		for i := 0; i < v.Len(); i++ {
			newSlice.Index(i).Set(deepCopyValue(v.Index(i)))
		}
		return newSlice
	}

	// 处理 map：新建 map，递归拷贝键值对
	if v.Kind() == reflect.Map {
		if v.IsNil() {
			return reflect.Zero(v.Type())
		}
		newMap := reflect.MakeMap(v.Type())
		for _, key := range v.MapKeys() {
			newKey := deepCopyValue(key)
			newVal := deepCopyValue(v.MapIndex(key))
			newMap.SetMapIndex(newKey, newVal)
		}
		return newMap
	}

	// 处理 struct：逐字段拷贝（仅导出字段）
	if v.Kind() == reflect.Struct {
		newStruct := reflect.New(v.Type()).Elem()
		for i := 0; i < v.NumField(); i++ {
			field := v.Field(i)
			if !field.CanInterface() { // 跳过不可导出字段
				continue
			}
			newStruct.Field(i).Set(deepCopyValue(field))
		}
		return newStruct
	}

	// 处理 interface{}：递归处理其底层值
	if v.Kind() == reflect.Interface {
		if v.IsNil() {
			return reflect.Zero(v.Type())
		}
		return deepCopyValue(v.Elem())
	}

	// 基本类型、chan、func、unsafe.Pointer 等：直接返回（func/chan 不可拷贝，此处返回零值）
	if v.CanInterface() {
		return reflect.ValueOf(v.Interface())
	}

	return reflect.Zero(v.Type())
}

type Address struct {
	City string
	Code int
}

type Person struct {
	Name    string
	Age     int
	Address *Address
	Tags    []string
	Meta    map[string]interface{}
}

p1 := &Person{
	Name: "Alice",
	Age:  30,
	Address: &Address{City: "Beijing", Code: 100000},
	Tags:    []string{"dev", "golang"},
	Meta:    map[string]interface{}{"active": true, "score": 95.5},
}

p2 := DeepCopy(p1).(*Person) // 类型断言还原为 *Person
p2.Name = "Bob"
p2.Address.City = "Shanghai"

fmt.Println(p1.Name, p1.Address.City) // Alice Beijing（未被修改）
fmt.Println(p2.Name, p2.Address.City) // Bob Shanghai（独立副本）