package main

import (
	"errors"
	"fmt"
	"math"
	"math/rand/v2"
	"regexp"
	"sort"
	"strconv"
	"strings"
)

var numberPattern = regexp.MustCompile(`^-?\d+(\.\d+)?$`)

func sortWorkflowList(items []jsonMap) {
	sort.Slice(items, func(i, j int) bool {
		return strings.ToLower(stringValue(items[i]["title"])) < strings.ToLower(stringValue(items[j]["title"]))
	})
}

func discoverWorkflowFields(workflow jsonMap, capability string) []any {
	fields := make([]any, 0)
	nodeIDs := sortedNodeIDs(workflow)
	promptNode, promptField := findWorkflowPromptTarget(workflow, nodeIDs)
	imageOrder, videoOrder, audioOrder := 0, 0, 0
	for _, nodeID := range nodeIDs {
		node, ok := mapValue(workflow[nodeID])
		if !ok {
			continue
		}
		inputs, ok := mapValue(node["inputs"])
		if !ok {
			continue
		}
		title := ""
		if meta, ok := mapValue(node["_meta"]); ok {
			title = stringValue(meta["title"])
		}
		classType := stringValue(node["class_type"])
		if isCanvasAnnotationNode(classType) {
			continue
		}
		fieldNames := make([]string, 0, len(inputs))
		for fieldName := range inputs {
			fieldNames = append(fieldNames, fieldName)
		}
		sort.Strings(fieldNames)
		for _, fieldName := range fieldNames {
			fieldValue := inputs[fieldName]
			if isWorkflowLink(fieldValue) {
				continue
			}
			fieldType := discoveredFieldType(fieldName, fieldValue, classType)
			label := fieldName
			if title != "" {
				label = title + " · " + fieldName
			}
			field := jsonMap{"id": nodeID + "::" + fieldName, "nodeId": nodeID, "fieldName": fieldName, "fieldValue": fieldValue, "fieldType": fieldType, "label": label, "enabled": true}
			if nodeID == promptNode && fieldName == promptField {
				field["source"] = "prompt"
				field["required"] = true
			} else if source := discoveredDynamicSource(fieldName, fieldType, capability); source != "" {
				field["source"] = source
			}
			switch normalizeSourceName(stringValue(field["source"])) {
			case "referenceimage":
				imageOrder++
				field["imageOrder"] = imageOrder
				field["sourceIndex"] = imageOrder - 1
				field["required"] = imageOrder == 1
			case "referencevideo":
				field["sourceIndex"] = videoOrder
				field["required"] = videoOrder == 0
				videoOrder++
			case "referenceaudio":
				field["sourceIndex"] = audioOrder
				field["required"] = audioOrder == 0
				audioOrder++
			case "mask":
				field["required"] = false
			}
			if isSeedField(fieldName) {
				field["randomEnabled"] = true
			}
			fields = append(fields, field)
		}
	}
	return fields
}

// discoverWorkflowGraph 将 ComfyUI 画布 JSON 压缩成网页只读预览所需的节点和连线。
// 画布 JSON 不能直接提交给 /prompt，因此预览数据必须和可执行 API JSON 分开传输。
func discoverWorkflowGraph(workflow jsonMap) jsonMap {
	rawNodes := sliceValue(workflow["nodes"])
	if len(rawNodes) == 0 {
		return nil
	}

	nodes := make([]any, 0, len(rawNodes))
	nodeIDs := make(map[string]bool, len(rawNodes))
	for _, raw := range rawNodes {
		node, ok := mapValue(raw)
		if !ok {
			continue
		}
		nodeID := strings.TrimSpace(stringValue(node["id"]))
		if nodeID == "" || nodeIDs[nodeID] {
			continue
		}
		classType := firstNonEmpty(stringValue(node["type"]), stringValue(node["class_type"]), "Unknown")
		title := stringValue(node["title"])
		if title == "" {
			if properties, ok := mapValue(node["properties"]); ok {
				title = stringValue(properties["Node name for S&R"])
			}
		}
		if title == "" {
			title = classType
		}
		nodes = append(nodes, jsonMap{"id": nodeID, "title": title, "classType": classType})
		nodeIDs[nodeID] = true
	}
	if len(nodes) == 0 {
		return nil
	}

	edges := make([]any, 0)
	edgeKeys := make(map[string]bool)
	for _, raw := range sliceValue(workflow["links"]) {
		items := sliceValue(raw)
		if len(items) < 4 {
			continue
		}
		from := strings.TrimSpace(stringValue(items[1]))
		to := strings.TrimSpace(stringValue(items[3]))
		if from == "" || to == "" || from == to || !nodeIDs[from] || !nodeIDs[to] {
			continue
		}
		key := from + ":" + to
		if edgeKeys[key] {
			continue
		}
		edgeKeys[key] = true
		edges = append(edges, jsonMap{"from": from, "to": to})
	}
	return jsonMap{"nodes": nodes, "edges": edges}
}

// convertComfyCanvasWorkflow 将 ComfyUI 保存的画布 JSON 转成 /prompt 接受的 API JSON。
// 画布节点的 link 使用全局 link ID，API 节点则直接保存 [来源节点, 输出槽位]。
// 只转换画布中明确声明的输入和 widget 默认值，避免把布局字段带入执行请求。
func convertComfyCanvasWorkflow(workflow jsonMap) jsonMap {
	rawNodes := sliceValue(workflow["nodes"])
	if len(rawNodes) == 0 {
		return nil
	}
	links := make(map[string][]any)
	for _, raw := range sliceValue(workflow["links"]) {
		items := sliceValue(raw)
		if len(items) < 4 {
			continue
		}
		links[workflowNumberKey(items[0])] = items
	}

	converted := make(jsonMap, len(rawNodes))
	for _, raw := range rawNodes {
		node, ok := mapValue(raw)
		if !ok {
			continue
		}
		nodeID := strings.TrimSpace(stringValue(node["id"]))
		classType := strings.TrimSpace(firstNonEmpty(stringValue(node["type"]), stringValue(node["class_type"])))
		// 画布备注只用于编辑器展示，不是可执行节点。若将其转换进 /prompt，
		// ComfyUI 会按自定义节点校验，缺少 MarkdownNote 时直接让整个任务失败。
		if nodeID == "" || classType == "" || isCanvasAnnotationNode(classType) {
			continue
		}
		inputs := make(jsonMap)
		namedWidgets := make(jsonMap)
		if rawNamed, ok := mapValue(node["widgets_values_named"]); ok {
			namedWidgets = rawNamed
		}
		widgetValues := sliceValue(node["widgets_values"])
		widgetIndex := 0
		for _, rawInput := range sliceValue(node["inputs"]) {
			input, ok := mapValue(rawInput)
			if !ok {
				continue
			}
			fieldName := strings.TrimSpace(stringValue(input["name"]))
			if fieldName == "" {
				continue
			}
			if linkKey := workflowNumberKey(input["link"]); linkKey != "" {
				if link, exists := links[linkKey]; exists {
					fromNode := strings.TrimSpace(stringValue(link[1]))
					fromSlot := int(numberValue(link[2]))
					if fromNode != "" {
						inputs[fieldName] = []any{fromNode, fromSlot}
					}
				}
				continue
			}
			widgetName := fieldName
			if widget, ok := mapValue(input["widget"]); ok {
				widgetName = firstNonEmpty(stringValue(widget["name"]), fieldName)
			}
			if value, exists := namedWidgets[widgetName]; exists {
				inputs[fieldName] = value
				widgetIndex++
				continue
			}
			if _, hasWidget := input["widget"]; hasWidget && widgetIndex < len(widgetValues) {
				inputs[fieldName] = widgetValues[widgetIndex]
				widgetIndex++
			}
		}
		apiNode := jsonMap{"class_type": classType, "inputs": inputs}
		if title := firstNonEmpty(stringValue(node["title"]), nodeTitle(node)); title != "" {
			apiNode["_meta"] = jsonMap{"title": title}
		}
		converted[nodeID] = apiNode
	}
	if len(converted) == 0 {
		return nil
	}
	return converted
}

func isCanvasAnnotationNode(classType string) bool {
	normalized := strings.ToLower(strings.TrimSpace(classType))
	return normalized == "note" ||
		strings.HasPrefix(normalized, "note:") ||
		normalized == "markdownnote" ||
		strings.HasPrefix(normalized, "markdownnote:") ||
		// rgthree labels are canvas-only headings and must not be sent to /prompt.
		normalized == "label (rgthree)" ||
		normalized == "label" ||
		normalized == "addlabel" ||
		normalized == "fast groups bypasser (rgthree)" ||
		normalized == "fast groups bypasser"
}

func stripCanvasAnnotationNodes(workflow jsonMap) {
	for nodeID, raw := range workflow {
		node, ok := mapValue(raw)
		if !ok || !isCanvasAnnotationNode(firstNonEmpty(stringValue(node["class_type"]), stringValue(node["type"]))) {
			continue
		}
		delete(workflow, nodeID)
	}
}

func nodeTitle(node jsonMap) string {
	if properties, ok := mapValue(node["properties"]); ok {
		return stringValue(properties["Node name for S&R"])
	}
	return ""
}

func workflowNumberKey(value any) string {
	if value == nil || strings.TrimSpace(stringValue(value)) == "" {
		return ""
	}
	return strconv.FormatInt(int64(numberValue(value)), 10)
}

func sortedNodeIDs(workflow jsonMap) []string {
	items := make([]string, 0, len(workflow))
	for nodeID := range workflow {
		items = append(items, nodeID)
	}
	sort.Slice(items, func(i, j int) bool {
		left, leftErr := strconv.ParseInt(items[i], 10, 64)
		right, rightErr := strconv.ParseInt(items[j], 10, 64)
		if leftErr == nil && rightErr == nil {
			return left < right
		}
		return items[i] < items[j]
	})
	return items
}

func findWorkflowPromptTarget(workflow jsonMap, nodeIDs []string) (string, string) {
	bestNode, bestField, bestScore := "", "", math.MinInt
	for _, nodeID := range nodeIDs {
		node, ok := mapValue(workflow[nodeID])
		if !ok {
			continue
		}
		inputs, ok := mapValue(node["inputs"])
		if !ok {
			continue
		}
		classType := strings.ToLower(stringValue(node["class_type"]))
		title := ""
		if meta, ok := mapValue(node["_meta"]); ok {
			title = strings.ToLower(stringValue(meta["title"]))
		}
		for fieldName, value := range inputs {
			if _, ok := value.(string); !ok || !isPromptCandidate(fieldName, classType, title) {
				continue
			}
			descriptor := strings.ToLower(fieldName + " " + title)
			score := 0
			if strings.Contains(descriptor, "negative") || strings.Contains(descriptor, "负面") || strings.Contains(descriptor, "反向") || strings.Contains(descriptor, "负向") {
				score -= 100
			}
			if strings.Contains(descriptor, "positive") || strings.Contains(descriptor, "正面") || strings.Contains(descriptor, "正向") {
				score += 20
			}
			if strings.Contains(classType, "cliptextencode") {
				score += 5
			}
			if isPromptWorkflowField(jsonMap{"fieldName": fieldName}) {
				score += 2
			}
			if bestNode == "" || score > bestScore {
				bestNode, bestField, bestScore = nodeID, fieldName, score
			}
		}
	}
	return bestNode, bestField
}

func isPromptCandidate(fieldName, classType, title string) bool {
	key := normalizeSourceName(fieldName)
	if stringIn(key, "text", "prompt", "positiveprompt", "positive", "caption", "description") {
		return true
	}
	if strings.ToLower(fieldName) != "value" {
		return false
	}
	descriptor := classType + " " + title
	return strings.Contains(descriptor, "cliptextencode") || strings.Contains(descriptor, "text") || strings.Contains(descriptor, "string") || strings.Contains(descriptor, "prompt") || strings.Contains(descriptor, "提示词") || strings.Contains(descriptor, "文本")
}

func discoveredFieldType(fieldName string, value any, classType string) string {
	key, classKey := normalizeSourceName(fieldName), normalizeSourceName(classType)
	if strings.Contains(key, "mask") {
		return "IMAGE"
	}
	if strings.Contains(classKey, "loadimage") && stringIn(key, "image", "file", "path") {
		return "IMAGE"
	}
	if strings.Contains(classKey, "loadvideo") && stringIn(key, "video", "file", "path") {
		return "VIDEO"
	}
	if strings.Contains(classKey, "loadaudio") && stringIn(key, "audio", "file", "path") {
		return "AUDIO"
	}
	if discoveredNamedDynamicSource(fieldName, "") != "" {
		return scalarFieldType(value)
	}
	switch value.(type) {
	case bool:
		return "BOOLEAN"
	case float64, float32, int, int64:
		return "NUMBER"
	}
	if mediaFieldName(key, "image") || mediaValueType(value) == "IMAGE" {
		return "IMAGE"
	}
	if mediaFieldName(key, "video") || mediaValueType(value) == "VIDEO" {
		return "VIDEO"
	}
	if mediaFieldName(key, "audio") || mediaValueType(value) == "AUDIO" {
		return "AUDIO"
	}
	return "TEXT"
}

func mediaValueType(value any) string {
	if items := sliceValue(value); len(items) > 0 {
		value = items[0]
	}
	text := strings.ToLower(stringValue(value))
	if index := strings.IndexAny(text, "?#"); index >= 0 {
		text = text[:index]
	}
	if hasAnySuffix(text, ".png", ".jpg", ".jpeg", ".webp", ".gif", ".bmp", ".avif") {
		return "IMAGE"
	}
	if hasAnySuffix(text, ".mp4", ".webm", ".mov", ".m4v", ".mkv") {
		return "VIDEO"
	}
	if hasAnySuffix(text, ".mp3", ".wav", ".ogg", ".m4a", ".flac", ".aac") {
		return "AUDIO"
	}
	return ""
}

func discoveredDynamicSource(fieldName, fieldType, capability string) string {
	if source := discoveredNamedDynamicSource(fieldName, capability); source != "" {
		return source
	}
	switch strings.ToUpper(strings.TrimSpace(fieldType)) {
	case "IMAGE":
		return "referenceImage"
	case "VIDEO":
		return "referenceVideo"
	case "AUDIO":
		return "referenceAudio"
	default:
		return ""
	}
}

func discoveredNamedDynamicSource(fieldName, capability string) string {
	key := normalizeSourceName(fieldName)
	if strings.Contains(key, "mask") {
		return "mask"
	}
	if source := dimensionFieldSource(key); source != "" {
		return source
	}
	if stringIn(key, "ratio", "aspectratio", "imageaspectratio", "imageratio", "videoaspectratio", "videoratio") {
		return "aspectRatio"
	}
	if stringIn(key, "videoresolution", "videoquality", "vquality") {
		return "vquality"
	}
	if stringIn(key, "size", "imagesize", "imageresolution") {
		return "size"
	}
	if key == "resolution" {
		if capability == "video" {
			return "vquality"
		}
		if capability == "image" {
			return "size"
		}
	}
	aliases := map[string]string{
		"batch": "count", "batchsize": "count", "count": "count", "numimages": "count", "numberofimages": "count", "imagecount": "count", "imagescount": "count",
		"quality": "quality", "duration": "videoSeconds", "seconds": "videoSeconds", "durationseconds": "videoSeconds", "videoseconds": "videoSeconds", "videoduration": "videoSeconds", "videodurationseconds": "videoSeconds", "videolength": "videoSeconds", "clipduration": "videoSeconds",
		"generateaudio": "videoGenerateAudio", "videogenerateaudio": "videoGenerateAudio", "watermark": "videoWatermark", "videowatermark": "videoWatermark",
		"audioformat": "audioFormat", "voice": "audioVoice", "audiovoice": "audioVoice", "audiospeed": "audioSpeed", "audioinstructions": "audioInstructions",
		"transparent": "transparentBackground", "transparentbackground": "transparentBackground",
	}
	return aliases[key]
}

var dimensionPrefixes = []string{"", "image", "video", "size", "output", "target", "latent", "frame", "canvas", "source", "resolution", "final"}

func dimensionFieldSource(key string) string {
	for _, prefix := range dimensionPrefixes {
		if key == prefix+"width" {
			return "width"
		}
		if key == prefix+"height" {
			return "height"
		}
	}
	if key == "pixelwidth" || key == "widthpixels" {
		return "width"
	}
	if key == "pixelheight" || key == "heightpixels" {
		return "height"
	}
	return ""
}

func scalarFieldType(value any) string {
	switch value.(type) {
	case bool:
		return "BOOLEAN"
	case float64, float32, int, int64:
		return "NUMBER"
	default:
		return "TEXT"
	}
}

func mediaFieldName(key, mediaType string) bool {
	if key == mediaType {
		return true
	}
	for _, prefix := range []string{"input", "reference", "ref", "source", "init", "start", "end", "first", "last", "control", "controlnet", "style", "subject"} {
		if key == prefix+mediaType {
			return true
		}
	}
	for _, suffix := range []string{"file", "path", "filename", "upload"} {
		if key == mediaType+suffix {
			return true
		}
	}
	return mediaType == "image" && stringIn(key, "firstframe", "lastframe", "startframe", "endframe")
}

func isWorkflowLink(value any) bool {
	items := sliceValue(value)
	if len(items) != 2 || stringValue(items[0]) == "" {
		return false
	}
	index := numberValue(items[1])
	return index == math.Trunc(index)
}

func isSeedField(value string) bool {
	key := normalizeSourceName(value)
	return key == "seed" || strings.HasSuffix(key, "seed") || strings.Contains(key, "noiseseed")
}

func normalizeSourceName(value string) string {
	replacer := strings.NewReplacer(" ", "", "_", "", "-", "")
	return strings.ToLower(replacer.Replace(strings.TrimSpace(value)))
}

func validateWorkflowMediaInputs(fields []any, payload jsonMap) error {
	capacities := map[string]int{"referenceimage": 0, "referencevideo": 0, "referenceaudio": 0}
	hasMask := false
	for _, raw := range fields {
		field, ok := mapValue(raw)
		if !ok || field["enabled"] == false {
			continue
		}
		source := normalizedWorkflowFieldSource(field)
		if source == "mask" {
			hasMask = true
			continue
		}
		key := canonicalMediaSource(source)
		if _, ok := capacities[key]; !ok {
			continue
		}
		index := workflowSourceIndex(field)
		if index+1 > capacities[key] {
			capacities[key] = index + 1
		}
	}
	checks := []struct {
		label string
		key   string
		value any
	}{{"参考图片", "referenceimage", payload["referenceImages"]}, {"参考视频", "referencevideo", payload["referenceVideos"]}, {"参考音频", "referenceaudio", payload["referenceAudios"]}}
	for _, check := range checks {
		count := len(sliceValue(check.value))
		if count > capacities[check.key] {
			return fmt.Errorf("工作流只配置了 %d 个%s槽位，但画布传入了 %d 个；请在字段映射中补齐槽位", capacities[check.key], check.label, count)
		}
	}
	if payload["mask"] != nil && !hasMask {
		return errors.New("画布传入了蒙版，但工作流没有配置蒙版字段映射")
	}
	return nil
}

func applyWorkflowFields(workflow jsonMap, payload jsonMap, files map[string]string) error {
	fields := sliceValue(payload["workflowFields"])
	removed := map[string]bool{}
	for _, raw := range fields {
		field, ok := mapValue(raw)
		if !ok || field["enabled"] == false {
			continue
		}
		nodeID := firstNonEmpty(stringValue(field["nodeId"]), stringValue(field["node"]))
		fieldName := firstNonEmpty(stringValue(field["fieldName"]), stringValue(field["input"]))
		if nodeID == "" || fieldName == "" {
			continue
		}
		node, ok := mapValue(workflow[nodeID])
		if !ok {
			if boolValue(field["required"]) {
				return fmt.Errorf("工作流缺少必填映射节点 %s", nodeID)
			}
			continue
		}
		inputs, ok := mapValue(node["inputs"])
		if !ok {
			inputs = jsonMap{}
		}
		source := normalizedWorkflowFieldSource(field)
		value := firstValue(field["value"], field["fieldValue"], field["default"])
		if source != "" {
			value = resolveSource(source, field, payload, files)
		} else if boolValue(field["randomEnabled"]) || boolValue(field["random_enabled"]) {
			var err error
			value, err = randomWorkflowValue(field)
			if err != nil {
				return err
			}
		}
		if !emptyWorkflowValue(value) {
			inputs[fieldName] = normalizeComfyValue(value)
		} else if boolValue(field["required"]) {
			return fmt.Errorf("工作流必填字段 %s.%s 缺少值", nodeID, fieldName)
		} else if isMediaSource(source) {
			delete(inputs, fieldName)
		}
		node["inputs"] = inputs
		if len(inputs) == 0 && isMediaSource(source) {
			removed[nodeID] = true
		}
	}
	for nodeID := range removed {
		delete(workflow, nodeID)
	}
	if len(removed) == 0 {
		return nil
	}
	for _, rawNode := range workflow {
		node, ok := mapValue(rawNode)
		if !ok {
			continue
		}
		inputs, ok := mapValue(node["inputs"])
		if !ok {
			continue
		}
		for fieldName, value := range inputs {
			link := sliceValue(value)
			if len(link) > 0 && removed[stringValue(link[0])] {
				delete(inputs, fieldName)
			}
		}
	}
	return nil
}

func normalizedWorkflowFieldSource(field jsonMap) string {
	source := stringValue(field["source"])
	if source == "" && (boolValue(field["bindPrompt"]) || boolValue(field["bind_prompt"])) {
		source = "prompt"
	}
	if source == "" && (boolValue(field["sourceFromUpstream"]) || boolValue(field["source_from_upstream"])) {
		fieldType := strings.ToLower(firstNonEmpty(stringValue(field["fieldType"]), stringValue(field["type"])))
		switch fieldType {
		case "image":
			source = "referenceImage"
		case "video":
			source = "referenceVideo"
		case "audio":
			source = "referenceAudio"
		default:
			if isPromptWorkflowField(field) {
				source = "prompt"
			}
		}
	}
	return normalizeSourceName(source)
}

func randomWorkflowValue(field jsonMap) (int64, error) {
	minimum, err := integerFieldBound(field["min"], 0)
	if err != nil {
		return 0, err
	}
	maximum, err := integerFieldBound(field["max"], math.MaxInt32)
	if err != nil {
		return 0, err
	}
	if maximum < minimum {
		return 0, errors.New("工作流随机值最大值不能小于最小值")
	}
	return minimum + rand.Int64N(maximum-minimum+1), nil
}

func integerFieldBound(value any, fallback int64) (int64, error) {
	if value == nil || stringValue(value) == "" {
		return fallback, nil
	}
	parsed, err := strconv.ParseInt(strings.Trim(stringValue(value), `"`), 10, 64)
	if err != nil {
		return 0, fmt.Errorf("工作流随机值范围不是有效整数：%s", stringValue(value))
	}
	return parsed, nil
}

func resolveSource(source string, field, payload jsonMap, files map[string]string) any {
	normalized := normalizeSourceName(source)
	if stringIn(normalized, "prompt", "text", "positiveprompt", "positive") {
		return stringValue(payload["prompt"])
	}
	params, _ := mapValue(payload["params"])
	switch {
	case stringIn(normalized, "size", "imagesize", "imageresolution"):
		return params["size"]
	case normalized == "resolution":
		if strings.ToLower(stringValue(payload["mode"])) == "video" {
			return videoResolutionValue(field, params["vquality"])
		}
		return params["size"]
	case stringIn(normalized, "aspectratio", "ratio", "imageaspectratio", "imageratio", "videoaspectratio", "videoratio"):
		return aspectRatioValue(field, params["size"])
	case stringIn(normalized, "sizewidth", "width", "imagewidth", "videowidth"):
		return dimensionPart(stringValue(payload["mode"]), stringValue(params["size"]), stringValue(params["vquality"]), 0)
	case stringIn(normalized, "sizeheight", "height", "imageheight", "videoheight"):
		return dimensionPart(stringValue(payload["mode"]), stringValue(params["size"]), stringValue(params["vquality"]), 1)
	}
	aliases := map[string]string{
		"quality": "quality", "count": "count", "batch": "count", "batchsize": "count", "videoseconds": "videoSeconds", "duration": "videoSeconds",
		"videogenerateaudio": "videoGenerateAudio", "generateaudio": "videoGenerateAudio", "videowatermark": "videoWatermark", "watermark": "videoWatermark",
		"audioformat": "audioFormat", "systemprompt": "systemPrompt", "transparentbackground": "transparentBackground", "audiovoice": "audioVoice", "voice": "audioVoice", "audiospeed": "audioSpeed", "audioinstructions": "audioInstructions",
	}
	if stringIn(normalized, "vquality", "videoquality", "videoresolution") {
		return videoResolutionValue(field, params["vquality"])
	}
	if key := aliases[normalized]; key != "" {
		return params[key]
	}
	if normalized == "mask" {
		media, _ := mapValue(payload["mask"])
		return files[stringValue(media["id"])]
	}
	values := payload["referenceImages"]
	if strings.Contains(normalized, "video") {
		values = payload["referenceVideos"]
	} else if strings.Contains(normalized, "audio") {
		values = payload["referenceAudios"]
	}
	items := sliceValue(values)
	index := workflowSourceIndex(field)
	if index < 0 || index >= len(items) {
		return nil
	}
	media, _ := mapValue(items[index])
	return files[stringValue(media["id"])]
}

func applyPromptFallback(workflow jsonMap, prompt string, fields []any) {
	if prompt == "" {
		return
	}
	for _, raw := range fields {
		field, ok := mapValue(raw)
		if !ok {
			continue
		}
		source := normalizedWorkflowFieldSource(field)
		if boolValue(field["bind_prompt"]) || stringIn(source, "prompt", "text", "positiveprompt", "positive") {
			return
		}
	}
	nodeID, fieldName := findWorkflowPromptTarget(workflow, sortedNodeIDs(workflow))
	node, ok := mapValue(workflow[nodeID])
	if !ok {
		return
	}
	inputs, ok := mapValue(node["inputs"])
	if ok {
		inputs[fieldName] = prompt
	}
}

func isPromptWorkflowField(field jsonMap) bool {
	for _, key := range []string{"fieldName", "input", "label", "name"} {
		if stringIn(normalizeSourceName(stringValue(field[key])), "prompt", "text", "positiveprompt", "caption", "description", "提示词", "正向提示词") {
			return true
		}
	}
	return false
}

func normalizeComfyValue(value any) any {
	text, ok := value.(string)
	if !ok {
		return value
	}
	trimmed := strings.TrimSpace(text)
	if strings.EqualFold(trimmed, "true") {
		return true
	}
	if strings.EqualFold(trimmed, "false") {
		return false
	}
	if numberPattern.MatchString(trimmed) {
		if number, err := strconv.ParseFloat(trimmed, 64); err == nil {
			return number
		}
	}
	return value
}

func emptyWorkflowValue(value any) bool {
	return value == nil || (func() bool { text, ok := value.(string); return ok && strings.TrimSpace(text) == "" })()
}

func workflowSourceIndex(field jsonMap) int {
	if order := int(numberValue(field["imageOrder"])); order > 0 {
		return order - 1
	}
	index := int(numberValue(field["sourceIndex"]))
	if index < 0 {
		return 0
	}
	return index
}

func canonicalMediaSource(source string) string {
	switch source {
	case "image", "referenceimages":
		return "referenceimage"
	case "video", "referencevideos":
		return "referencevideo"
	case "audio", "referenceaudios":
		return "referenceaudio"
	default:
		return source
	}
}

func isMediaSource(source string) bool {
	return stringIn(source, "referenceimage", "referenceimages", "image", "referencevideo", "referencevideos", "video", "referenceaudio", "referenceaudios", "audio", "mask")
}

func dimensionPart(mode, size, quality string, index int) any {
	if pixels, ok := pixelDimensions(size); ok {
		return pixels[index]
	}
	var dimensions [2]int
	var ok bool
	if strings.EqualFold(strings.TrimSpace(mode), "video") {
		dimensions, ok = videoDimensions(size, quality)
	} else {
		dimensions, ok = imageDimensions(size)
	}
	if !ok {
		return nil
	}
	return dimensions[index]
}

func pixelDimensions(value string) ([2]int, bool) {
	parts := strings.Split(strings.ToLower(strings.TrimSpace(value)), "x")
	if len(parts) != 2 {
		return [2]int{}, false
	}
	width, errWidth := strconv.Atoi(strings.TrimSpace(parts[0]))
	height, errHeight := strconv.Atoi(strings.TrimSpace(parts[1]))
	return [2]int{width, height}, errWidth == nil && errHeight == nil && width > 0 && height > 0
}

func aspectRatio(value string) any {
	normalized := strings.ToLower(strings.TrimSpace(value))
	if match := regexp.MustCompile(`^(\d+)\s*:\s*(\d+)`).FindStringSubmatch(normalized); len(match) == 3 {
		width, widthErr := strconv.Atoi(match[1])
		height, heightErr := strconv.Atoi(match[2])
		if widthErr == nil && heightErr == nil && width > 0 && height > 0 {
			divisor := gcd(width, height)
			return fmt.Sprintf("%d:%d", width/divisor, height/divisor)
		}
	}
	normalized = regexp.MustCompile(`-(1k|2k|4k)$`).ReplaceAllString(normalized, "")
	if parts, ok := ratioParts(normalized); ok {
		divisor := gcd(parts[0], parts[1])
		return fmt.Sprintf("%d:%d", parts[0]/divisor, parts[1]/divisor)
	}
	dimensions, ok := pixelDimensions(normalized)
	if !ok {
		return nil
	}
	actual := float64(dimensions[0]) / float64(dimensions[1])
	known := [][2]int{{1, 1}, {3, 2}, {2, 3}, {4, 3}, {3, 4}, {4, 5}, {5, 4}, {16, 9}, {9, 16}, {2, 1}, {1, 2}, {21, 9}}
	best, difference := [2]int{}, math.Inf(1)
	for _, candidate := range known {
		expected := float64(candidate[0]) / float64(candidate[1])
		current := math.Abs(actual-expected) / expected
		if current < difference {
			best, difference = candidate, current
		}
	}
	if difference <= 0.03 {
		return fmt.Sprintf("%d:%d", best[0], best[1])
	}
	divisor := gcd(dimensions[0], dimensions[1])
	return fmt.Sprintf("%d:%d", dimensions[0]/divisor, dimensions[1]/divisor)
}

// aspectRatioValue keeps the canonical canvas ratio while restoring the exact
// enum value expected by ComfyUI nodes such as ResolutionSelector.
func aspectRatioValue(field jsonMap, value any) any {
	canonical, _ := aspectRatio(stringValue(value)).(string)
	if canonical == "" {
		return value
	}
	candidates := sliceValue(field["options"])
	for _, candidate := range []any{field["value"], field["fieldValue"], field["default"]} {
		if !emptyWorkflowValue(candidate) {
			candidates = append(candidates, candidate)
		}
	}
	for _, candidate := range candidates {
		option := optionString(candidate)
		if option == "" {
			continue
		}
		optionCanonical, _ := aspectRatio(option).(string)
		if optionCanonical == canonical {
			return option
		}
	}
	return canonical
}

func ratioParts(value string) ([2]int, bool) {
	parts := strings.Split(strings.TrimSpace(value), ":")
	if len(parts) != 2 {
		return [2]int{}, false
	}
	width, errWidth := strconv.Atoi(parts[0])
	height, errHeight := strconv.Atoi(parts[1])
	return [2]int{width, height}, errWidth == nil && errHeight == nil && width > 0 && height > 0
}

func imageDimensions(value string) ([2]int, bool) {
	normalized := strings.ToLower(strings.TrimSpace(value))
	presets := map[string][2]int{"1:1": {1024, 1024}, "3:2": {1536, 1024}, "2:3": {1024, 1536}, "4:3": {1360, 1024}, "3:4": {1024, 1360}, "4:5": {1024, 1280}, "5:4": {1280, 1024}, "16:9": {1824, 1024}, "9:16": {1024, 1824}, "2:1": {2048, 1024}, "1:2": {1024, 2048}, "21:9": {2352, 1008}, "1:1-2k": {2048, 2048}, "16:9-2k": {2048, 1152}, "9:16-2k": {1152, 2048}, "16:9-4k": {3840, 2160}, "9:16-4k": {2160, 3840}}
	if result, ok := presets[normalized]; ok {
		return result, true
	}
	ratio, ok := aspectRatio(normalized).(string)
	if !ok {
		return [2]int{}, false
	}
	parts, ok := ratioParts(ratio)
	if !ok {
		return [2]int{}, false
	}
	longEdge := 1024
	if strings.HasSuffix(normalized, "-4k") {
		longEdge = 3840
	} else if strings.HasSuffix(normalized, "-2k") {
		longEdge = 2048
	}
	if parts[0] >= parts[1] {
		if longEdge == 1024 {
			return [2]int{roundStep(1024*parts[0]/parts[1], 16), 1024}, true
		}
		return [2]int{longEdge, roundStep(longEdge*parts[1]/parts[0], 16)}, true
	}
	if longEdge == 1024 {
		return [2]int{1024, roundStep(1024*parts[1]/parts[0], 16)}, true
	}
	return [2]int{roundStep(longEdge*parts[0]/parts[1], 16), longEdge}, true
}

func videoDimensions(size, quality string) ([2]int, bool) {
	ratio, ok := aspectRatio(size).(string)
	if !ok {
		return [2]int{}, false
	}
	parts, ok := ratioParts(ratio)
	shortEdge := videoResolutionPixels(quality)
	if !ok || shortEdge == 0 {
		return [2]int{}, false
	}
	if parts[0] >= parts[1] {
		return [2]int{roundStep(shortEdge*parts[0]/parts[1], 2), shortEdge}, true
	}
	return [2]int{shortEdge, roundStep(shortEdge*parts[1]/parts[0], 2)}, true
}

func videoResolutionPixels(value any) int {
	normalized := strings.ToLower(strings.Trim(strings.TrimSpace(stringValue(value)), `"`))
	switch normalized {
	case "low":
		return 480
	case "auto", "default", "medium", "high":
		return 720
	case "2k":
		return 1440
	case "4k":
		return 2160
	}
	parsed, _ := strconv.Atoi(strings.TrimSuffix(normalized, "p"))
	return parsed
}

func videoResolutionValue(field jsonMap, value any) any {
	raw := strings.Trim(stringValue(value), `"`)
	if raw == "" {
		return nil
	}
	pixels := videoResolutionPixels(raw)
	if pixels == 0 {
		return value
	}
	candidates := []string{raw, strconv.Itoa(pixels), strconv.Itoa(pixels) + "p"}
	if pixels == 1440 {
		candidates = append(candidates, "2k")
	} else if pixels == 2160 {
		candidates = append(candidates, "4k")
	}
	for _, option := range sliceValue(field["options"]) {
		for _, candidate := range candidates {
			if strings.EqualFold(optionString(option), candidate) {
				return option
			}
		}
	}
	defaultValue := firstValue(field["value"], field["fieldValue"], field["default"])
	if _, ok := defaultValue.(float64); ok {
		return pixels
	}
	normalizedDefault := strings.ToLower(strings.Trim(stringValue(defaultValue), `"`))
	if strings.HasSuffix(normalizedDefault, "p") {
		return strconv.Itoa(pixels) + "p"
	}
	if normalizedDefault == "2k" || normalizedDefault == "4k" {
		if pixels == 1440 {
			return "2k"
		}
		if pixels == 2160 {
			return "4k"
		}
	}
	return value
}

func optionString(value any) string {
	if item, ok := mapValue(value); ok {
		for _, key := range []string{"value", "id", "key", "label", "name"} {
			if candidate := strings.Trim(stringValue(item[key]), `"`); candidate != "" {
				return candidate
			}
		}
	}
	return strings.Trim(stringValue(value), `"`)
}

func gcd(left, right int) int {
	for right != 0 {
		left, right = right, left%right
	}
	if left <= 0 {
		return 1
	}
	return left
}

func roundStep(value, step int) int {
	return int(math.Round(float64(value)/float64(step))) * step
}

func stringIn(value string, candidates ...string) bool {
	for _, candidate := range candidates {
		if value == candidate {
			return true
		}
	}
	return false
}

func hasAnySuffix(value string, suffixes ...string) bool {
	for _, suffix := range suffixes {
		if strings.HasSuffix(value, suffix) {
			return true
		}
	}
	return false
}