package flow

import (
	"ai-agent/workflow/consts/node"
	flowDto "ai-agent/workflow/model/dto/flow"
	"regexp"

	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/util/gconv"
	"github.com/tidwall/gjson"
)

var (
	// 匹配 [数字]
	regNumIndex = regexp.MustCompile(`\[\d+\]`)
	// 匹配 .attrs
	regAttrs = regexp.MustCompile(`\.attrs`)
)

// CleanFieldPath 清理字段路径：移除 .attrs、数字下标转为 [*]
// 示例：usage.attrs.total_tokens → usage.total_tokens
// 示例：choices.attrs[0].attrs.message.attrs.content → choices[*].message.content
func CleanFieldPath(path string) string {
	// 1. 替换 [数字] 为 [*]
	s := regNumIndex.ReplaceAllString(path, `.#`)
	// 2. 移除所有 .attrs
	s = regAttrs.ReplaceAllString(s, "")
	return s
}

// UnwrapSchemaWrapper 递归剥掉 json-schema-editor 输出的 {type, value/attrs} 包裹层，
// 只保留干净的 key/value 嵌套结构。
// 示例：
//
//	{"a": {"type":"string","value":"hi"}}                    → {"a": "hi"}
//	{"b": {"type":"object","attrs":{"c":1}}}                 → {"b": {"c": 1}}
//	{"arr": {"type":"array","attrs":[{"type":"number","value":1}]}} → {"arr": [1]}
func UnwrapSchemaWrapper(v any) any {
	switch val := v.(type) {
	case map[string]any:
		// 识别包裹节点：{type: "<jsonType>", value/attrs: <实际值>, ...}
		if t, ok := val["type"].(string); ok && isSchemaEditorType(t) {
			dataKey := "value"
			if t == "object" || t == "array" {
				dataKey = "attrs"
			}
			if raw, has := val[dataKey]; has {
				return UnwrapSchemaWrapper(raw)
			}
		}
		res := make(map[string]any, len(val))
		for k, child := range val {
			res[k] = UnwrapSchemaWrapper(child)
		}
		return res
	case []any:
		res := make([]any, len(val))
		for i, item := range val {
			res[i] = UnwrapSchemaWrapper(item)
		}
		return res
	default:
		return val
	}
}

// isSchemaEditorType 是否为 json-schema-editor 的 6 种类型标识
func isSchemaEditorType(t string) bool {
	switch t {
	case "string", "number", "boolean", "null", "object", "array":
		return true
	}
	return false
}

// MapResultByTemplate 按 template 定义的结构，从 source 中拷贝对应字段的值。
// 只保留 template 里出现的字段：对象字段按同名字段递归拷贝，标量/数组字段直接拷贝 source 的值。
func MapResultByTemplate(template map[string]any, source map[string]any) map[string]any {
	result := make(map[string]any, len(template))
	for key, tmplVal := range template {
		srcVal, ok := source[key]
		if !ok {
			continue
		}
		if tmplMap, isMap := tmplVal.(map[string]any); isMap {
			if srcMap, isMap := srcVal.(map[string]any); isMap {
				result[key] = MapResultByTemplate(tmplMap, srcMap)
			}
			continue
		}
		result[key] = srcVal
	}
	return result
}

// ProcessValueSourceRecursive 递归遍历map，同级同时存在value和valueSource则把value设置为"AA"
func ProcessValueSourceRecursive(rawParams map[string]interface{}, globalParams *flowDto.FlowExecutionInput) {
	walkMap(rawParams, globalParams)
}

// resolveValueSource 解析 valueSource {nodeId, fieldName} 引用的实际值。
// 返回 (value, refsName, ok)；ok=false 表示引用节点不存在或引用值仍为空。
//   - 开始/表单节点：OutputConfig 平铺条目按 field == fieldName 匹配（前端约定以 field 为主，
//     不兼容 path），直接读 entry 的 value / refsName
//   - scriptTranscribe 节点：读 OutputResult 的 shots
//   - 其他节点：读 OutputResult 中 fieldName 路径对应的值
func resolveValueSource(global *flowDto.FlowExecutionInput, nodeId, fieldName string) (value any, refsName any, ok bool) {
	if global == nil || global.ConfigMap == nil {
		return nil, nil, false
	}
	nodeConfig := global.ConfigMap[nodeId]
	if nodeConfig == nil {
		return nil, nil, false
	}
	switch nodeConfig.NodeCode {
	case node.NodeTypeStart, node.NodeTypeForm:
		for _, output := range nodeConfig.OutputConfig {
			if gconv.String(output["field"]) != fieldName {
				continue
			}
			if !g.IsEmpty(output["value"]) {
				return output["value"], output["refsName"], true
			}
		}
	case node.NodeTypeScriptTranscribe:
		for _, output := range nodeConfig.OutputResult {
			value := gjson.Get(gconv.String(output), CleanFieldPath("shots")).Value()
			if !g.IsEmpty(value) {
				return value, gjson.Get(gconv.String(output), CleanFieldPath("refsName")).Value(), true
			}
		}
	default:
		for _, output := range nodeConfig.OutputResult {
			value := gjson.Get(gconv.String(output), CleanFieldPath(fieldName)).Value()
			if !g.IsEmpty(value) {
				return value, gjson.Get(gconv.String(output), CleanFieldPath("refsName")).Value(), true
			}
		}
	}
	return nil, nil, false
}

// walkMap 递归处理map/数组
func walkMap(data interface{}, globalParams *flowDto.FlowExecutionInput) {
	switch v := data.(type) {
	case map[string]interface{}:
		// 当前对象同时存在 value 和 valueSource
		if valueSource, hasSource := v["valueSource"]; hasSource {
			mapValueSource := gconv.Map(valueSource)
			nodeId := gconv.String(mapValueSource["nodeId"])
			fieldName := gconv.String(mapValueSource["fieldName"])
			if fieldName == "" {
				fieldName = gconv.String(mapValueSource["field"])
			}
			if nodeId != "" && fieldName != "" {
				if value, refsName, ok := resolveValueSource(globalParams, nodeId, fieldName); ok {
					v["value"] = value
					if !g.IsEmpty(refsName) {
						v["refsName"] = refsName
					}
					return
				}
			}
		}
		// 递归遍历所有子元素
		for _, child := range v {
			walkMap(child, globalParams)
		}
	case []interface{}:
		// 数组遍历
		for _, item := range v {
			walkMap(item, globalParams)
		}
	}
}

// CleanEmptyModelParams 剔除模型请求参数中 value 为空的字段；
// 数组/枚举（attrs / enumValues）元素整体为空时移除整个元素。0/false 视为有效值。
func CleanEmptyModelParams(params map[string]interface{}) {
	cleanSchemaMap(params)
}

// cleanSchemaMap 递归清理普通 map：包装节点按 schema 语义清理，空字段删除
func cleanSchemaMap(m map[string]interface{}) {
	for key, val := range m {
		switch v := val.(type) {
		case map[string]interface{}:
			if isSchemaWrapperNode(v) {
				cleanSchemaWrapper(v)
				if isSchemaNodeEmpty(v) {
					delete(m, key)
				}
			} else {
				cleanSchemaMap(v)
			}
		case []interface{}:
			m[key] = cleanSchemaSlice(v)
		}
	}
}

// cleanSchemaWrapper 清理单个 {type,...} 包装节点：递归 value / attrs / enumValues 容器
func cleanSchemaWrapper(node map[string]interface{}) {
	if mv, ok := node["value"].(map[string]interface{}); ok {
		cleanSchemaMap(mv)
	}
	if lv, ok := node["value"].([]interface{}); ok {
		node["value"] = cleanSchemaSlice(lv)
	}
	if attrs, ok := node["attrs"].(map[string]interface{}); ok {
		cleanSchemaMap(attrs)
	}
	if attrs, ok := node["attrs"].([]interface{}); ok {
		node["attrs"] = cleanSchemaSlice(attrs)
	}
	if evs, ok := node["enumValues"].([]interface{}); ok {
		node["enumValues"] = cleanSchemaSlice(evs)
	}
}

// cleanSchemaSlice 清理数组/枚举元素，元素为包装节点且整体为空时移除
func cleanSchemaSlice(list []interface{}) []interface{} {
	i := 0
	for i < len(list) {
		if item, ok := list[i].(map[string]interface{}); ok {
			if isSchemaWrapperNode(item) {
				cleanSchemaWrapper(item)
				if isSchemaNodeEmpty(item) {
					list = append(list[:i], list[i+1:]...)
					continue
				}
			} else {
				cleanSchemaMap(item)
			}
		}
		i++
	}
	return list
}

// isSchemaWrapperNode 是否为 {type: <schemaEditorType>} 包装节点
func isSchemaWrapperNode(m map[string]interface{}) bool {
	t, ok := m["type"].(string)
	return ok && isSchemaEditorType(t)
}

// isSchemaNodeEmpty 判断 schema 节点是否已无有效内容：
// 标量看 value（0/false 有效）；object/array 看 value/attrs/enumValues 容器是否都为空
func isSchemaNodeEmpty(node map[string]interface{}) bool {
	t, _ := node["type"].(string)
	switch t {
	case "object":
		return schemaContainerEmpty(node, "value") && schemaContainerEmpty(node, "attrs")
	case "array":
		return schemaContainerEmpty(node, "value") && schemaContainerEmpty(node, "attrs") && schemaContainerEmpty(node, "enumValues")
	default:
		return schemaValueEmpty(node["value"])
	}
}

// schemaContainerEmpty 容器（value/attrs/enumValues）是否为空
func schemaContainerEmpty(node map[string]interface{}, key string) bool {
	switch v := node[key].(type) {
	case []interface{}:
		return len(v) == 0
	case map[string]interface{}:
		return len(v) == 0
	default:
		return v == nil
	}
}

// schemaValueEmpty 值是否为空；0/false 视为有效值不剔除
func schemaValueEmpty(v interface{}) bool {
	switch val := v.(type) {
	case nil:
		return true
	case string:
		return val == ""
	case []interface{}:
		return len(val) == 0
	case map[string]interface{}:
		return len(val) == 0
	default:
		return false
	}
}