package gio

import (
	"encoding/json"
	"fmt"
	"io"
	"reflect"
	"runtime"
	"strings"
	"sync/atomic"
)

func ReadLimit(r io.Reader, n int64) ([]byte, error) {
	if n == 0 {
		n = 4096
	}
	return io.ReadAll(io.LimitReader(r, n))
}

func CallFuncName(skip int) string {
	pc, _, _, _ := runtime.Caller(skip + 1)
	funcName := runtime.FuncForPC(pc).Name()
	return funcName[strings.LastIndex(funcName, ".")+1:]
}

func StructToMap(obj any) (map[string]any, error) {
	// 获取反射值
	val := reflect.ValueOf(obj)
	if val.Kind() == reflect.Ptr {
		val = val.Elem()
	}

	// 确保输入是结构体
	if val.Kind() != reflect.Struct {
		return nil, fmt.Errorf("input must be a struct or struct pointer")
	}

	// 创建结果 map
	result := make(map[string]any)
	typ := val.Type()

	// 遍历结构体的字段
	for i := 0; i < val.NumField(); i++ {
		field := typ.Field(i)
		if !field.IsExported() {
			continue
		}
		fieldVal := val.Field(i)

		// 获取 json 标签
		jsonTag := field.Tag.Get("json")
		if jsonTag == "" {
			jsonTag = field.Name
		} else {
			if idx := strings.Index(jsonTag, ","); idx != -1 {
				jsonTag = jsonTag[:idx]
			}
		}
		// 跳过忽略字段或无效字段
		if jsonTag == "-" || !fieldVal.IsValid() {
			continue
		}

		// 检查字段是否为结构体或结构体指针，且是否有 json 标签
		hasJsonTag := field.Tag.Get("json") != ""
		if (fieldVal.Kind() == reflect.Struct || (fieldVal.Kind() == reflect.Ptr && !fieldVal.IsNil() && fieldVal.Elem().Kind() == reflect.Struct)) && !hasJsonTag {
			// 如果是结构体且无 json 标签，递归展开
			var nestedVal interface{}
			if fieldVal.Kind() == reflect.Ptr {
				nestedVal = fieldVal.Interface()
			} else {
				nestedVal = fieldVal.Interface()
			}
			nestedMap, err := StructToMap(nestedVal)
			if err != nil {
				return nil, err
			}
			for k, v := range nestedMap {
				result[k] = v
			}
		} else {
			// 其他情况（包括有 json 标签的嵌套结构体），直接存储字段值
			result[jsonTag] = fieldVal.Interface()
		}
	}

	return result, nil
}

func DecodeJson[T any](v any) (T, error) {
	var t T
	b, err := json.Marshal(v)
	if err != nil {
		return t, err
	}
	if err = json.Unmarshal(b, &t); err != nil {
		return t, err
	}
	return t, nil
}

func Equal(a, b any) bool {
	if a == nil && b == nil {
		return true
	}
	if a == nil || b == nil {
		return false
	}
	return reflect.DeepEqual(a, b)
}

// FreeCap 计算 chan 容量剩余, 当 int = 0 时表示 chan 已满
func FreeCap[T any](buff chan T) int {
	remaining := cap(buff) - len(buff)
	return remaining
}

type AtomicValue[T any] struct {
	v atomic.Value
}

func NewAtomicValue[T any](initial T) *AtomicValue[T] {
	av := &AtomicValue[T]{}
	av.v.Store(initial)
	return av
}

func (av *AtomicValue[T]) Store(val T) {
	av.v.Store(val)
}

func (av *AtomicValue[T]) Swap(val T) any {
	return av.v.Swap(val)
}

func (av *AtomicValue[T]) Load() T {
	if val := av.v.Load(); val != nil {
		return val.(T) // 类型断言在泛型约束下是安全的
	}
	var zero T // 返回类型
	return zero
}
