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
	}
	// 如果有 messages 字段，直接返回
	if j.Contains("messages") {
		return gconv.Maps(j.Get("messages").Array())
	}
	// 否则当成单条 message
	return []map[string]any{
		j.Map(),
	}
}

// IsMessageValid 校验推理结果是否合法
func IsMessageValid(message map[string]any) bool {
	if message == nil {
		return false
	}
	return true
}

// FormToJSON 将表单数据转换为 JSON 字符串
func FormToJSON(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)
}

// ParseJSONField 解析 JSON 字段
func ParseJSONField(field any) any {
	var v *gvar.Var
	switch val := field.(type) {
	case *gvar.Var:
		v = val
	default:
		return field
	}

	if v == nil || v.IsNil() || v.IsEmpty() {
		return nil
	}

	str := v.String()
	var result any
	if json.Unmarshal([]byte(str), &result) == nil {
		return result
	}
	return str
}

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

	// 统一转 map 再美化
	var tmp map[string]any
	if err := gconv.Struct(v, &tmp); err != nil {
		return gconv.String(v)
	}

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