reflux/rfx_reflect.go

package reflux

import (
	"encoding/json"
	"fmt"
	"reflect"
	"strconv"
	"strings"

	"git.fsdpf.net/go/reflux/valuex"
	"github.com/spf13/cast"
)

// refx 是基于 reflect.Value 的实现, 现在作为**冷路径回退**存在。
//
// 热路径(Get/Set/标量访问器)由 rfx 用类型布局缓存 + unsafe 指针运算完成;
// 语义复杂、调用频次低的操作 —— 复合类型赋值、Append、Delete、
// 容器转换(StringMap*/Slice*)、map 的 Keys —— 仍然走这里。
//
// 这样划分的理由: 这些操作的语义(指针字段是"设置指向的值"、[]any 逐元素转换、
// map 填充进 struct ...)非常琐碎, 重新实现一遍必然引入行为偏差,
// 而它们本来就不在性能热点上。
type refx struct {
	// value 存储底层的反射值
	// 该值应该是指针类型,以支持修改操作
	value reflect.Value
}

// Get 通过路径获取嵌套字段的值
func (r *refx) Get(p ...string) R {
	return &refx{value: getValueByPath(r.value, p...)}
}

// Scope 创建一个指定路径的作用域视图(深度克隆)
func (r *refx) Scope(p ...string) R {
	v := getValueByPath(r.value, p...)
	if !v.IsValid() {
		return &refx{value: reflect.Value{}}
	}

	// 深度克隆值
	cloned := DeepClone(v)
	return &refx{value: cloned}
}

// Set 设置指定路径的值,支持链式调用
// 如果路径不存在或设置失败,会 panic 并提供详细错误信息
func (r *refx) Set(key string, v any) R {
	// 展开路径
	keys := expandPath(key)
	if len(keys) == 0 {
		panic(ErrEmptyPath)
	}

	// 如果只有一个键,直接设置
	if len(keys) == 1 {
		target := r.getParentValue()
		if !target.IsValid() {
			panic(NewErrInvalidValueForPath(key))
		}
		if !target.CanSet() {
			panic(NewErrCannotSetPath(key))
		}
		if err := r.setFieldValue(target, keys[0], v); err != nil {
			panic(NewErrSetFailed(key, err))
		}
		return r
	}

	// 多个键的情况,需要特殊处理 map 中的 struct
	if err := r.setNestedValue(r.value, keys, v); err != nil {
		panic(NewErrSetFailed(key, err))
	}
	return r
}

// Append 追加指定路径的值
// 参数 items 为要追加的值
// 返回当前 R 实例以支持链式调用
func (r *refx) Append(items ...any) R {
	// 没有要追加的元素,直接返回
	if len(items) == 0 {
		return r
	}

	target := r.getParentValue()
	target = deref(target)

	if !target.IsValid() {
		panic(ErrAppendNilValue)
	}
	if target.Kind() != reflect.Slice {
		panic(ErrAppendNotSupported)
	}

	// 一次性构造所有要追加的元素,然后调用一次 reflect.Append
	elemType := target.Type().Elem()
	newValues := make([]reflect.Value, len(items))
	for i, item := range items {
		newElem := reflect.New(elemType).Elem()
		if err := r.setValue(newElem, item); err != nil {
			panic(NewErrAppendItemFailed(i, err))
		}
		newValues[i] = newElem
	}

	target.Set(reflect.Append(target, newValues...))
	return r
}

// setNestedValue 递归设置嵌套值,特殊处理 map 中的 struct
func (r *refx) setNestedValue(current reflect.Value, keys []string, v any) error {
	// 解引用指针和接口
	current = derefWithAccessor(current)
	if !current.IsValid() {
		return ErrNilPointerInPath
	}

	// 如果只剩一个键,直接设置
	if len(keys) == 1 {
		if !current.CanSet() {
			return ErrValueCannotBeSet
		}
		return r.setFieldValue(current, keys[0], v)
	}

	// 多个键的情况
	firstKey := keys[0]
	remainingKeys := keys[1:]

	switch current.Kind() {
	case reflect.Struct:
		field := tryStructFieldValue(current, firstKey)
		if !field.IsValid() {
			return NewErrFieldNotFound(firstKey)
		}
		return r.setNestedValue(field, remainingKeys, v)

	case reflect.Map:
		// Map 的特殊处理
		// 使用 tryMapFieldKey 获取实际的键
		actualKey := tryMapFieldKey(current, firstKey)
		if !actualKey.IsValid() {
			return NewErrKeyNotFound(firstKey)
		}

		mapValue := current.MapIndex(actualKey)
		if !mapValue.IsValid() {
			return NewErrValueNotFound(firstKey)
		}

		// 解开 interface 包装获取实际的值
		actualValue := mapValue
		for actualValue.Kind() == reflect.Interface && !actualValue.IsNil() {
			actualValue = actualValue.Elem()
		}

		// 创建 map 值的副本以便修改
		valueCopy := reflect.New(actualValue.Type()).Elem()
		valueCopy.Set(actualValue)

		// 在副本上递归设置值
		if err := r.setNestedValue(valueCopy, remainingKeys, v); err != nil {
			return err
		}

		// 将修改后的值设置回 map,使用实际找到的键
		current.SetMapIndex(actualKey, valueCopy)
		return nil

	case reflect.Slice, reflect.Array:
		idx, err := strconv.Atoi(firstKey)
		if err != nil || idx < 0 || idx >= current.Len() {
			return NewErrInvalidIndex(firstKey, current.Len())
		}
		elem := current.Index(idx)
		if !elem.IsValid() {
			return NewErrElementInvalid(firstKey)
		}
		return r.setNestedValue(elem, remainingKeys, v)
	}

	return NewErrUnsupportedType(current.Kind(), firstKey)
}

// getParentValue 获取父级值的辅助方法
func (r *refx) getParentValue(p ...string) reflect.Value {
	if len(p) == 0 {
		v := r.value
		for v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface {
			if v.IsNil() {
				return reflect.Value{}
			}
			v = v.Elem()
		}
		return v
	}
	return getValueByPath(r.value, p...)
}

// setFieldValue 设置字段值的辅助方法
// 返回 error 包含详细的设置失败信息
func (r *refx) setFieldValue(target reflect.Value, key string, v any) error {
	target = deref(target)
	if !target.IsValid() {
		return ErrTargetNilPointer
	}

	switch target.Kind() {
	case reflect.Struct:
		field := tryStructFieldValue(target, key)
		if !field.IsValid() {
			return NewErrFieldNotFoundInStruct(key, target.Type())
		}
		if !field.CanSet() {
			return NewErrFieldCannotSet(key, field.Type())
		}
		return r.setValue(field, v)
	case reflect.Map:
		if target.IsNil() {
			target.Set(reflect.MakeMap(target.Type()))
		}

		// 先尝试使用 tryMapFieldKey 检查字段是否已存在并获取实际的键
		actualKey := tryMapFieldKey(target, key)
		if actualKey.IsValid() {
			// 字段已存在,创建新值用于设置
			newValue := reflect.New(target.Type().Elem()).Elem()
			if err := r.setValue(newValue, v); err != nil {
				return err
			}
			target.SetMapIndex(actualKey, newValue)
			return nil
		}

		// 字段不存在,创建新的 map 值
		// 处理 nil 值的情况
		if v == nil {
			target.SetMapIndex(reflect.ValueOf(key), reflect.Zero(target.Type().Elem()))
			return nil
		}

		val := reflect.ValueOf(v)
		if !val.Type().AssignableTo(target.Type().Elem()) {
			// 尝试转换
			if val.Type().ConvertibleTo(target.Type().Elem()) {
				val = val.Convert(target.Type().Elem())
			} else {
				return NewErrCannotAssign(val.Type(), target.Type().Elem())
			}
		}
		target.SetMapIndex(reflect.ValueOf(key), val)
		return nil
	case reflect.Slice:
		idx, err := strconv.Atoi(key)
		if err != nil {
			return NewErrInvalidSliceIndex(key, err)
		}

		// 对于切片,支持使用索引 -1 追加新元素(插入到切片前面)
		if idx == -1 {
			elemType := target.Type().Elem()
			newElem := reflect.New(elemType).Elem()
			if err := r.setValue(newElem, v); err != nil {
				return err
			}
			// 将新元素放在前面,原有元素顺序后移
			newSlice := reflect.MakeSlice(target.Type(), 0, target.Len()+1)
			newSlice = reflect.Append(newSlice, newElem)
			newSlice = reflect.AppendSlice(newSlice, target)
			target.Set(newSlice)
			return nil
		}

		if idx < 0 || idx >= target.Len() {
			return NewErrSliceIndexOutOfRange(idx, target.Len())
		}
		elem := target.Index(idx)
		if !elem.CanSet() {
			return NewErrSliceElementCannotSet(idx)
		}
		return r.setValue(elem, v)
	case reflect.Array:
		idx, err := strconv.Atoi(key)
		if err != nil {
			return NewErrInvalidArrayIndex(key, err)
		}
		if idx < 0 || idx >= target.Len() {
			return NewErrArrayIndexOutOfRange(idx, target.Len())
		}
		elem := target.Index(idx)
		if !elem.CanSet() {
			return NewErrArrayElementCannotSet(idx)
		}
		return r.setValue(elem, v)
	}
	return NewErrUnsupportedTargetType(target.Kind())
}

// setValue 设置值的辅助方法
// 使用 cast 库进行智能类型转换,支持更多的转换场景
// 返回 error 包含详细的类型转换失败信息
func (r *refx) setValue(field reflect.Value, v any) error {
	val, _, err := normalizeInputValue(v)

	if err != nil {
		return NewErrNormalizeInputFailed(err)
	}

	targetType := field.Type()

	if !val.IsValid() {
		val = reflect.Zero(targetType)
	}

	// 如果 val 有效，进行正常的类型处理
	// 统一解开最外层的 interface 包装,便于后续根据底层实际类型做处理
	for val.Kind() == reflect.Interface && !val.IsNil() {
		val = val.Elem()
	}

	// 尝试直接赋值(类型完全匹配)
	if val.Type().AssignableTo(targetType) {
		field.Set(val)
		return nil
	}

	// 如果源值是指针但目标不是指针,尝试解引用后再赋值
	if val.Kind() == reflect.Ptr && !val.IsNil() && targetType.Kind() != reflect.Ptr {
		derefVal := val.Elem()
		if derefVal.Type().AssignableTo(targetType) {
			field.Set(derefVal)
			return nil
		}
		// 解引用后继续使用下面的逻辑处理
		val = derefVal
	}

	switch targetType.Kind() {
	case reflect.Ptr:
		// 处理指针类型
		// 如果传入的值已经是指针类型,尝试直接赋值
		if val.Type().AssignableTo(targetType) {
			field.Set(val)
			return nil
		}

		// 如果传入的值不是指针,创建新指针并设置值
		elemType := targetType.Elem()
		newPtr := reflect.New(elemType)

		// 递归设置指针指向的值
		if err := r.setValue(newPtr.Elem(), v); err != nil {
			return err
		}

		field.Set(newPtr)
		return nil

	case reflect.Slice: // 处理切片类型,支持从通用切片(如 []any)转换
		if val.Kind() != reflect.Slice && val.Kind() != reflect.Array {
			return NewErrCannotConvertToSlice(val.Type(), targetType)
		}

		newSlice := reflect.MakeSlice(targetType, val.Len(), val.Len())

		for i := 0; i < val.Len(); i++ {
			if err := r.setValue(newSlice.Index(i), val.Index(i).Interface()); err != nil {
				return NewErrSetSliceElementFailed(i, err)
			}
		}

		field.Set(newSlice)

		return nil

	case reflect.Struct:
		// 遍历目标结构体的字段,从源值(结构体或 map)中按字段名取值并设置
		// 仅支持从 struct 或 map 填充
		if val.Kind() != reflect.Struct && val.Kind() != reflect.Map {
			return NewErrCannotConvertToStruct(val.Type(), targetType)
		}

		fieldType := field.Type()
		for i := 0; i < fieldType.NumField(); i++ {
			dstField := field.Field(i)
			if !dstField.CanSet() {
				continue
			}

			valField := getValueByPath(val, fieldType.Field(i).Name)

			if !valField.IsValid() {
				continue
			}

			// 使用 setValue 复用现有的类型转换逻辑,忽略单个字段失败
			if err := r.setValue(dstField, valField.Interface()); err != nil {
				return NewErrSetStructFieldFailed(fieldType.Field(i).Name, err)
			}
		}
		return nil

	}

	// 优先使用 cast 进行智能类型转换
	// 这样可以处理 string <-> number, number <-> bool 等常见转换
	var converted any

	switch targetType.Kind() {
	case reflect.Bool:
		converted, err = cast.ToBoolE(v)
	case reflect.Int:
		converted, err = cast.ToIntE(v)
	case reflect.Int8:
		converted, err = cast.ToInt8E(v)
	case reflect.Int16:
		converted, err = cast.ToInt16E(v)
	case reflect.Int32:
		converted, err = cast.ToInt32E(v)
	case reflect.Int64:
		converted, err = cast.ToInt64E(v)
	case reflect.Uint:
		converted, err = cast.ToUintE(v)
	case reflect.Uint8:
		converted, err = cast.ToUint8E(v)
	case reflect.Uint16:
		converted, err = cast.ToUint16E(v)
	case reflect.Uint32:
		converted, err = cast.ToUint32E(v)
	case reflect.Uint64:
		converted, err = cast.ToUint64E(v)
	case reflect.Float32:
		converted, err = cast.ToFloat32E(v)
	case reflect.Float64:
		converted, err = cast.ToFloat64E(v)
	case reflect.String:
		converted, err = cast.ToStringE(v)
	default:
		return NewErrUnsupportedTargetTypeForValue(targetType, fmt.Sprintf("%T", v))
	}

	if err != nil {
		// 如果 cast 失败,尝试标准的反射类型转换作为后备
		if val.IsValid() && val.Type().ConvertibleTo(field.Type()) {
			field.Set(val.Convert(field.Type()))
			return nil
		}
		return NewErrCannotConvertValue(fmt.Sprintf("%T", v), targetType, err)
	}

	field.Set(reflect.ValueOf(converted))

	return nil
}

// Delete 删除指定路径的值,支持链式调用
// 如果删除失败会 panic
func (r *refx) Delete(p ...string) R {
	if len(p) == 0 {
		panic(ErrEmptyPath)
	}

	// 展开路径
	keys := expandPath(p...)
	if len(keys) == 0 {
		panic("rfx: empty path")
	}

	target := r.getParentValue(keys[:len(keys)-1]...)
	if !target.IsValid() {
		panic(fmt.Sprintf("rfx: invalid path '%s'", strings.Join(keys[:len(keys)-1], ".")))
	}

	lastKey := keys[len(keys)-1]
	for target.Kind() == reflect.Ptr || target.Kind() == reflect.Interface {
		if target.IsNil() {
			panic(fmt.Sprintf("rfx: nil value at path '%s'", strings.Join(keys[:len(keys)-1], ".")))
		}
		target = target.Elem()
	}

	switch target.Kind() {
	case reflect.Map:
		target.SetMapIndex(reflect.ValueOf(lastKey), reflect.Value{})
		return r
	case reflect.Slice:
		idx, err := strconv.Atoi(lastKey)
		if err != nil {
			panic(fmt.Sprintf("rfx: invalid slice index '%s'", lastKey))
		}
		if idx < 0 || idx >= target.Len() {
			panic(fmt.Sprintf("rfx: slice index out of range: %d", idx))
		}
		// 删除切片元素
		newSlice := reflect.AppendSlice(
			target.Slice(0, idx),
			target.Slice(idx+1, target.Len()),
		)
		target.Set(newSlice)
		return r
	default:
		panic(fmt.Sprintf("rfx: cannot delete from type %s", target.Kind()))
	}
}

// Exists 检查指定路径的值是否存在
func (r *refx) Exists(p ...string) bool {
	return getValueByPath(r.value, p...).IsValid()
}

// Array 将当前值转换为 R 切片
func (r *refx) Array() []R {
	v := r.value
	for v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface {
		if v.IsNil() {
			return nil
		}
		v = v.Elem()
	}

	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
		return nil
	}

	result := make([]R, v.Len())
	for i := 0; i < v.Len(); i++ {
		elem := v.Index(i)
		if elem.Kind() == reflect.Interface && !elem.IsNil() {
			if r, ok := elem.Interface().(R); ok {
				result[i] = r
				continue
			}
		}
		result[i] = &refx{value: elem}
	}
	return result
}

// keys 返回当前映射或结构体的所有键名
func (r *refx) Keys() []string {
	v := r.value
	for v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface {
		if v.IsNil() {
			return nil
		}
		v = v.Elem()
	}

	switch v.Kind() {
	case reflect.Map:
		keys := v.MapKeys()
		result := make([]string, len(keys))
		for i, k := range keys {
			result[i] = fmt.Sprint(k.Interface())
		}
		return result
	case reflect.Struct:
		t := v.Type()
		result := make([]string, t.NumField())
		for i := 0; i < t.NumField(); i++ {
			result[i] = t.Field(i).Name
		}
		return result
	}
	return nil
}

// Raw 返回底层的 reflect.Value
func (r *refx) Raw() reflect.Value {
	return r.value
}

// Lookup 根据路径查找并返回对应值的访问器
func (r *refx) Lookup(path string) (valuex.Accessor, bool) {
	v := r.Get(path)
	if v.Exists() {
		return v, true
	}
	return valuex.Nil, false
}

// MustLookup 根据路径查找并直接返回对应值的访问器
// 如果路径不存在,返回 valuex.Nil 访问器(所有方法返回零值)
func (r *refx) MustLookup(path string) valuex.Accessor {
	v := r.Get(path)
	if v.Exists() {
		return v
	}
	return valuex.Nil
}

// Ptr 返回指向当前值的指针
func (r *refx) Ptr() any {
	v := r.value
	if v.Kind() == reflect.Ptr {
		return v.Interface()
	}
	if v.CanAddr() {
		return v.Addr().Interface()
	}
	return nil
}

// Any 将当前值转换为 any 类型
func (r *refx) Any() any {
	v := r.value
	for v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface {
		if v.IsNil() {
			return nil
		}
		v = v.Elem()
	}
	if !v.IsValid() {
		return nil
	}
	return v.Interface()
}

// Bool 将当前值转换为 bool 类型
func (r *refx) Bool() bool {
	result, err := cast.ToBoolE(r.Any())
	if err != nil {
		panic(fmt.Sprintf("rfx: failed to convert to bool: %v", err))
	}
	return result
}

// Float64 将当前值转换为 float64 类型
func (r *refx) Float64() float64 {
	result, err := cast.ToFloat64E(r.Any())
	if err != nil {
		panic(fmt.Sprintf("rfx: failed to convert to float64: %v", err))
	}
	return result
}

// Float32 将当前值转换为 float32 类型
func (r *refx) Float32() float32 {
	result, err := cast.ToFloat32E(r.Any())
	if err != nil {
		panic(fmt.Sprintf("rfx: failed to convert to float32: %v", err))
	}
	return result
}

// Int64 将当前值转换为 int64 类型
func (r *refx) Int64() int64 {
	result, err := cast.ToInt64E(r.Any())
	if err != nil {
		panic(fmt.Sprintf("rfx: failed to convert to int64: %v", err))
	}
	return result
}

// Int32 将当前值转换为 int32 类型
func (r *refx) Int32() int32 {
	result, err := cast.ToInt32E(r.Any())
	if err != nil {
		panic(fmt.Sprintf("rfx: failed to convert to int32: %v", err))
	}
	return result
}

// Int16 将当前值转换为 int16 类型
func (r *refx) Int16() int16 {
	result, err := cast.ToInt16E(r.Any())
	if err != nil {
		panic(fmt.Sprintf("rfx: failed to convert to int16: %v", err))
	}
	return result
}

// Int8 将当前值转换为 int8 类型
func (r *refx) Int8() int8 {
	result, err := cast.ToInt8E(r.Any())
	if err != nil {
		panic(fmt.Sprintf("rfx: failed to convert to int8: %v", err))
	}
	return result
}

// Int 将当前值转换为 int 类型
func (r *refx) Int() int {
	result, err := cast.ToIntE(r.Any())
	if err != nil {
		panic(fmt.Sprintf("rfx: failed to convert to int: %v", err))
	}
	return result
}

// Uint 将当前值转换为 uint 类型
func (r *refx) Uint() uint {
	result, err := cast.ToUintE(r.Any())
	if err != nil {
		panic(fmt.Sprintf("rfx: failed to convert to uint: %v", err))
	}
	return result
}

// Uint64 将当前值转换为 uint64 类型
func (r *refx) Uint64() uint64 {
	result, err := cast.ToUint64E(r.Any())
	if err != nil {
		panic(fmt.Sprintf("rfx: failed to convert to uint64: %v", err))
	}
	return result
}

// Uint32 将当前值转换为 uint32 类型
func (r *refx) Uint32() uint32 {
	result, err := cast.ToUint32E(r.Any())
	if err != nil {
		panic(fmt.Sprintf("rfx: failed to convert to uint32: %v", err))
	}
	return result
}

// Uint16 将当前值转换为 uint16 类型
func (r *refx) Uint16() uint16 {
	result, err := cast.ToUint16E(r.Any())
	if err != nil {
		panic(fmt.Sprintf("rfx: failed to convert to uint16: %v", err))
	}
	return result
}

// Uint8 将当前值转换为 uint8 类型
func (r *refx) Uint8() uint8 {
	result, err := cast.ToUint8E(r.Any())
	if err != nil {
		panic(fmt.Sprintf("rfx: failed to convert to uint8: %v", err))
	}
	return result
}

// String 将当前值转换为 string 类型
func (r *refx) String() string {
	data := r.Any()
	result, err := cast.ToStringE(data)
	if err != nil {
		if b, e := json.Marshal(data); e == nil {
			result = string(b)
		} else {
			panic(fmt.Sprintf("rfx: failed to convert to string: %v", err))
		}
	}
	return result
}

// StringMapString 将当前值转换为 map[string]string 类型
func (r *refx) StringMapString() map[string]string {
	data := r.Any()

	// 首先尝试使用 cast 进行转换
	result, err := cast.ToStringMapStringE(data)
	if err == nil {
		return result
	}

	// cast 失败后，尝试自定义转换逻辑
	defer func() {
		if p := recover(); p != nil {
			panic(fmt.Sprintf("rfx: failed to convert to map[string]string, cast error: %v, custom conversion error: %v", err, p))
		}
	}()

	result = make(map[string]string)
	for _, k := range r.Keys() {
		result[k] = r.Get(k).String()
	}

	return result
}

// StringMapStringSlice 将当前值转换为 map[string][]string 类型
func (r *refx) StringMapStringSlice() map[string][]string {
	data := r.Any()

	// 首先尝试使用 cast 进行转换
	result, err := cast.ToStringMapStringSliceE(data)
	if err == nil {
		return result
	}

	// cast 失败后，尝试自定义转换逻辑
	defer func() {
		if p := recover(); p != nil {
			panic(fmt.Sprintf("rfx: failed to convert to map[string][]string, cast error: %v, custom conversion error: %v", err, p))
		}
	}()

	result = make(map[string][]string)
	for _, k := range r.Keys() {
		result[k] = r.Get(k).StringSlice()
	}

	return result
}

// StringMapBool 将当前值转换为 map[string]bool 类型
func (r *refx) StringMapBool() map[string]bool {
	data := r.Any()

	// 首先尝试使用 cast 进行转换
	result, err := cast.ToStringMapBoolE(data)
	if err == nil {
		return result
	}

	// cast 失败后，尝试自定义转换逻辑
	defer func() {
		if p := recover(); p != nil {
			panic(fmt.Sprintf("rfx: failed to convert to map[string]bool, cast error: %v, custom conversion error: %v", err, p))
		}
	}()

	result = make(map[string]bool)
	for _, k := range r.Keys() {
		result[k] = r.Get(k).Bool()
	}

	return result
}

// StringMapInt 将当前值转换为 map[string]int 类型
func (r *refx) StringMapInt() map[string]int {
	data := r.Any()

	// 首先尝试使用 cast 进行转换
	result, err := cast.ToStringMapIntE(data)
	if err == nil {
		return result
	}

	// cast 失败后，尝试自定义转换逻辑
	defer func() {
		if p := recover(); p != nil {
			panic(fmt.Sprintf("rfx: failed to convert to map[string]int, cast error: %v, custom conversion error: %v", err, p))
		}
	}()

	result = make(map[string]int)
	for _, k := range r.Keys() {
		result[k] = r.Get(k).Int()
	}

	return result
}

// StringMapInt64 将当前值转换为 map[string]int64 类型
func (r *refx) StringMapInt64() map[string]int64 {
	data := r.Any()

	// 首先尝试使用 cast 进行转换
	result, err := cast.ToStringMapInt64E(data)
	if err == nil {
		return result
	}

	// cast 失败后，尝试自定义转换逻辑
	defer func() {
		if p := recover(); p != nil {
			panic(fmt.Sprintf("rfx: failed to convert to map[string]int64, cast error: %v, custom conversion error: %v", err, p))
		}
	}()

	result = make(map[string]int64)
	for _, k := range r.Keys() {
		result[k] = r.Get(k).Int64()
	}

	return result
}

// StringMap 将当前值转换为 map[string]any 类型
func (r *refx) StringMap() map[string]any {
	data := r.Any()

	// 首先尝试使用 cast 进行转换
	result, err := cast.ToStringMapE(data)
	if err == nil {
		return result
	}

	// cast 失败后，尝试自定义转换逻辑
	defer func() {
		if p := recover(); p != nil {
			panic(fmt.Sprintf("rfx: failed to convert to map[string]any, cast error: %v, custom conversion error: %v", err, p))
		}
	}()

	result = make(map[string]any)
	for _, k := range r.Keys() {
		result[k] = r.Get(k).Any()
	}

	return result
}

// Slice 将当前值转换为 []any 切片
func (r *refx) Slice() (result []any) {
	v := r.value
	for v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface {
		if v.IsNil() {
			return nil
		}
		v = v.Elem()
	}

	if !v.IsValid() {
		return nil
	} else if v.Kind() == reflect.String {
		if str := r.String(); len(str) >= 2 && str[0] == '[' {
			if err := json.Unmarshal([]byte(str), &result); err == nil {
				return result
			}
		}
	} else if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
		return nil
	}

	result = make([]any, v.Len())
	for i := 0; i < v.Len(); i++ {
		elem := v.Index(i)
		for elem.Kind() == reflect.Ptr || elem.Kind() == reflect.Interface {
			if elem.IsNil() {
				break
			}
			elem = elem.Elem()
		}
		if elem.IsValid() {
			result[i] = elem.Interface()
		}
	}
	return result
}

// BoolSlice 将当前值转换为 []bool 切片
func (r *refx) BoolSlice() []bool {
	result, err := cast.ToBoolSliceE(r.Slice())
	if err != nil {
		panic(fmt.Sprintf("rfx: failed to convert to []bool: %v", err))
	}
	return result
}

// StringSlice 将当前值转换为 []string 切片
func (r *refx) StringSlice() []string {
	result, err := cast.ToStringSliceE(r.Slice())
	if err != nil {
		panic(fmt.Sprintf("rfx: failed to convert to []string: %v", err))
	}
	return result
}

// IntSlice 将当前值转换为 []int 切片
func (r *refx) IntSlice() []int {
	result, err := cast.ToIntSliceE(r.Slice())
	if err != nil {
		panic(fmt.Sprintf("rfx: failed to convert to []int: %v", err))
	}
	return result
}

// MarshalJSON 实现 json.Marshaler 接口
// 将当前值序列化为 JSON 字节数组
func (r *refx) MarshalJSON() ([]byte, error) {
	return json.Marshal(r.Any())
}

// UnmarshalJSON 实现 json.Unmarshaler 接口
// 从 JSON 字节数组反序列化到当前值
func (r *refx) UnmarshalJSON(data []byte) error {
	// 先解析到 any 类型
	var v any
	if err := json.Unmarshal(data, &v); err != nil {
		return err
	}

	// 获取当前值的实际类型
	target := r.value
	for target.Kind() == reflect.Ptr || target.Kind() == reflect.Interface {
		if target.IsNil() {
			break
		}
		target = target.Elem()
	}

	// 如果当前值无效或为 nil，创建一个新的 map[string]any
	if !target.IsValid() || !target.CanSet() {
		r.value = reflect.ValueOf(&v).Elem()
		return nil
	}

	// 尝试将解析的值设置到当前值
	newValue := reflect.ValueOf(v)
	if newValue.Type().AssignableTo(target.Type()) {
		target.Set(newValue)
		return nil
	}

	// 如果类型不匹配，尝试使用 setValue 进行转换
	if err := r.setValue(target, v); err != nil {
		return NewErrUnmarshalFailed(target.Type(), err)
	}

	return nil
}