package util

import (
	"encoding/json"
	"fmt"

	"github.com/gogf/gf/v2/container/gvar"
	"github.com/gogf/gf/v2/encoding/gjson"
	"github.com/gogf/gf/v2/util/gconv"
)

// ParseOutput 解析模型输出为 JSON 格式
func ParseOutput(text string) (map[string]any, error) {
	j, err := gjson.LoadJson([]byte(text))
	if err != nil {
		return nil, fmt.Errorf("解析模型输出失败: %w", err)
	}

	return j.Map(), nil
}

// ConvertToMessages 将原始数据转换为消息列表
func ConvertToMessages(raw any) []map[string]any {
	if raw == nil {
		return nil
	}

	j, err := gjson.LoadJson(gconv.Bytes(raw))
	if err != nil {
		return nil
	}

	if j.Contains("messages") {
		return gconv.Maps(j.Get("messages").Array())
	}

	return []map[string]any{j.Map()}
}

// FormToJSON 将表单数据转换为 JSON 字符串
func FormToJSON(form map[string]any) string {
	if form == nil {
		return "{}"
	}

	b, _ := json.Marshal(form)
	return string(b)
}

// UserFormToJSON 将用户表单数据转换为 JSON 字符串
func UserFormToJSON(form []map[string]any) string {
	if form == nil {
		return "{}"
	}

	b, _ := json.Marshal(form)
	return string(b)
}

// MustMarshal 将对象序列化为 JSON 字符串，失败时返回空对象
func MustMarshal(v any) string {
	b, err := json.Marshal(v)
	if err != nil {
		return "{}"
	}

	return string(b)
}

// JSONPretty 将任意类型转为格式化的 JSON 字符串
func JSONPretty(v any) string {
	if gv, ok := v.(*gvar.Var); ok {
		v = gconv.Map(gv.String())
	}

	var tmp map[string]any
	if err := gconv.Struct(v, &tmp); err != nil {
		return gconv.String(v)
	}

	b, _ := json.MarshalIndent(tmp, "", "  ")
	return string(b)
}

// GvarToMap 将 *gvar.Var 类型转换为 map[string]any
func GvarToMap(v *gvar.Var) map[string]any {
	if v == nil || v.IsNil() {
		return nil
	}

	result := make(map[string]any)

	// 方法1：尝试获取 map 值
	if m := v.Map(); len(m) > 0 {
		return m
	}

	// 方法2：尝试解析 JSON 字符串
	str := v.String()
	if str != "" && str != "<nil>" {
		json.Unmarshal([]byte(str), &result)
		if len(result) > 0 {
			return result
		}
	}

	// 方法3：尝试获取 interface 再转换
	if val := v.Val(); val != nil {
		switch val.(type) {
		case map[string]any:
			return val.(map[string]any)
		default:
			data, _ := json.Marshal(val)
			json.Unmarshal(data, &result)
		}
	}

	return result
}

// ParseJSONFieldFromGvar 专门处理 *gvar.Var 类型的 JSON 字段解析
func ParseJSONFieldFromGvar(source any, target any) {
	if source == nil {
		return
	}

	switch v := source.(type) {
	case *gvar.Var:
		if v.IsNil() {
			return
		}

		// 尝试获取 map
		if m := v.Map(); len(m) > 0 {
			data, _ := json.Marshal(m)
			json.Unmarshal(data, target)
			return
		}

		// 尝试解析 JSON 字符串
		str := v.String()
		if str != "" && str != "<nil>" {
			json.Unmarshal([]byte(str), target)
		}

	default:
		// 其他类型走原来的逻辑
		data, _ := json.Marshal(source)
		json.Unmarshal(data, target)
	}
}