package reflux

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

	"github.com/spf13/cast"
)

// rfx 是 R 接口的具体实现
// 通过封装 reflect.Value 提供了对结构体、切片、映射等类型的统一访问方式
type rfx struct {
	// value 存储底层的反射值
	// 该值应该是指针类型,以支持修改操作
	value reflect.Value
}

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

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

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

// getValueByPath 通过路径获取值的辅助方法
// 支持两种路径格式:
// 1. 多个参数: Get("Address", "City")
// 2. 点号分割: Get("Address.City") 或混合使用 Get("Address.City", "ZipCode")
func (r *rfx) getValueByPath(p ...string) reflect.Value {
	v := r.value
	for v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface {
		if v.IsNil() {
			return reflect.Value{}
		}
		v = v.Elem()
	}

	// 展开所有路径片段,支持点号分割
	keys := expandPath(p...)

	for _, key := range keys {
		if !v.IsValid() {
			return reflect.Value{}
		}

		switch v.Kind() {
		case reflect.Struct:
			v = tryStructField(v, key)
		case reflect.Map:
			v = v.MapIndex(reflect.ValueOf(key))
		case reflect.Slice, reflect.Array:
			// 尝试将 key 转换为索引
			idx, err := strconv.Atoi(key)
			if err == nil && idx >= 0 && idx < v.Len() {
				v = v.Index(idx)
			} else {
				return reflect.Value{}
			}
		default:
			return reflect.Value{}
		}

		// 解引用指针和接口
		for v.IsValid() && (v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface) {
			if v.IsNil() {
				return reflect.Value{}
			}
			v = v.Elem()
		}
	}

	return v
}

// Set 设置指定路径的值,支持链式调用
// 如果路径不存在或设置失败,会 panic
func (r *rfx) Set(key string, v any) R {
	// 展开路径
	keys := expandPath(key)
	if len(keys) == 0 {
		panic("rfx: empty path")
	}

	// 如果只有一个键,直接设置
	if len(keys) == 1 {
		target := r.getParentValue()
		if !target.IsValid() {
			panic(fmt.Sprintf("rfx: invalid value for path '%s'", key))
		}
		if !target.CanSet() {
			panic(fmt.Sprintf("rfx: cannot set value at path '%s'", key))
		}
		if !r.setFieldValue(target, keys[0], v) {
			panic(fmt.Sprintf("rfx: failed to set value at path '%s'", key))
		}
		return r
	}

	// 多个键的情况,需要特殊处理 map 中的 struct
	if !r.setNestedValue(r.value, keys, v) {
		panic(fmt.Sprintf("rfx: failed to set value at path '%s'", key))
	}
	return r
}

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

	target := r.getParentValue()
	for target.Kind() == reflect.Ptr || target.Kind() == reflect.Interface {
		if target.IsNil() {
			panic("rfx: cannot append to nil value")
		}
		target = target.Elem()
	}

	if !target.IsValid() || target.Kind() != reflect.Slice {
		panic("rfx: Append only supports slice type")
	}

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

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

// setNestedValue 递归设置嵌套值,特殊处理 map 中的 struct
func (r *rfx) setNestedValue(current reflect.Value, keys []string, v any) bool {
	// 解引用指针和接口
	for current.Kind() == reflect.Ptr || current.Kind() == reflect.Interface {
		if current.IsNil() {
			return false
		}
		current = current.Elem()
	}

	if !current.IsValid() {
		return false
	}

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

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

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

	case reflect.Map:
		// Map 的特殊处理
		mapKey := reflect.ValueOf(firstKey)
		mapValue := current.MapIndex(mapKey)

		if !mapValue.IsValid() {
			return false
		}

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

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

		// 将修改后的值设置回 map
		current.SetMapIndex(mapKey, valueCopy)
		return true

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

	return false
}

// getParentValue 获取父级值的辅助方法
func (r *rfx) 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 r.getValueByPath(p...)
}

// setFieldValue 设置字段值的辅助方法
func (r *rfx) setFieldValue(target reflect.Value, key string, v any) bool {
	for target.Kind() == reflect.Ptr || target.Kind() == reflect.Interface {
		if target.IsNil() {
			return false
		}
		target = target.Elem()
	}

	switch target.Kind() {
	case reflect.Struct:
		field := tryStructField(target, key)
		if !field.IsValid() || !field.CanSet() {
			return false
		}
		return r.setValue(field, v)
	case reflect.Map:
		if target.IsNil() {
			target.Set(reflect.MakeMap(target.Type()))
		}
		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 false
			}
		}
		target.SetMapIndex(reflect.ValueOf(key), val)
		return true
	case reflect.Slice:
		idx, err := strconv.Atoi(key)
		if err != nil {
			return false
		}

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

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

// setValue 设置值的辅助方法
// 使用 cast 库进行智能类型转换,支持更多的转换场景
func (r *rfx) setValue(field reflect.Value, v any) bool {
	val := reflect.ValueOf(v)

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

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

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

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

		field.Set(newPtr)
		return true
	}

	// 优先使用 cast 进行智能类型转换
	// 这样可以处理 string <-> number, number <-> bool 等常见转换
	targetType := field.Type()
	var converted any
	var err error

	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:
		// 对于 cast 不支持的类型,尝试标准的反射类型转换
		if val.Type().ConvertibleTo(field.Type()) {
			field.Set(val.Convert(field.Type()))
			return true
		}
		return false
	}

	if err != nil {
		// 如果 cast 失败,尝试标准的反射类型转换作为后备
		if val.Type().ConvertibleTo(field.Type()) {
			field.Set(val.Convert(field.Type()))
			return true
		}
		return false
	}

	field.Set(reflect.ValueOf(converted))
	return true
}

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

	// 展开路径
	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 *rfx) Exists(p ...string) bool {
	v := r.getValueByPath(p...)
	return v.IsValid()
}

// Array 将当前值转换为 R 切片
func (r *rfx) 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++ {
		result[i] = &rfx{value: v.Index(i)}
	}
	return result
}

// keys 返回当前映射或结构体的所有键名
func (r *rfx) 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
}

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

// Ptr 返回指向当前值的指针
func (r *rfx) 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 *rfx) 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 *rfx) 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 *rfx) 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 *rfx) 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 *rfx) 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 *rfx) 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 *rfx) 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 *rfx) 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 *rfx) 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 *rfx) 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 *rfx) 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 *rfx) 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 *rfx) 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 *rfx) 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 *rfx) 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 *rfx) StringMapString() map[string]string {
	result, err := cast.ToStringMapStringE(r.Any())
	if err != nil {
		panic(fmt.Sprintf("rfx: failed to convert to map[string]string: %v", err))
	}
	return result
}

// StringMapStringSlice 将当前值转换为 map[string][]string 类型
func (r *rfx) StringMapStringSlice() map[string][]string {
	result, err := cast.ToStringMapStringSliceE(r.Any())
	if err != nil {
		panic(fmt.Sprintf("rfx: failed to convert to map[string][]string: %v", err))
	}
	return result
}

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

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

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

// StringMap 将当前值转换为 map[string]any 类型
func (r *rfx) StringMap() map[string]any {
	result, err := cast.ToStringMapE(r.Any())
	if err != nil {
		panic(fmt.Sprintf("rfx: failed to convert to map[string]any: %v", err))
	}
	return result
}

// Slice 将当前值转换为 []any 切片
func (r *rfx) Slice() []any {
	v := r.value
	for v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface {
		if v.IsNil() {
			return nil
		}
		v = v.Elem()
	}
	if !v.IsValid() || (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 *rfx) BoolSlice() []bool {
	result, err := cast.ToBoolSliceE(r.Any())
	if err != nil {
		panic(fmt.Sprintf("rfx: failed to convert to []bool: %v", err))
	}
	return result
}

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

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