// 工作流字段取值：把用户在画布上的选择（尺寸、比例、时长、分辨率、提示词、种子）
// 解析成 RunningHub 节点可接受的具体值。
//
// 规则：显式值优先；其次按字段声明的选项/范围就近取值；都没有才用配置默认值。
// 尺寸类字段会按上游要求的步长取整，避免上游拒绝非法分辨率。

package app

import (
	cryptorand "crypto/rand"
	"encoding/json"
	"errors"
	"fmt"
	"math"
	"math/big"
	"sort"
	"strconv"
	"strings"
)

func workflowFieldsFromManagement(workflow map[string]interface{}, mode string) ([]WorkflowField, error) {
	rawFields := collectManagementWorkflowFields(workflow, mode)
	encoded, err := json.Marshal(rawFields)
	if err != nil {
		return nil, fmt.Errorf("工作流字段映射编码失败：%w", err)
	}
	var fields []WorkflowField
	if err := json.Unmarshal(encoded, &fields); err != nil {
		return nil, fmt.Errorf("工作流字段映射解析失败：%w", err)
	}
	return fields, nil
}

func workflowFieldsForMode(fields []WorkflowField, mode string) []WorkflowField {
	if len(fields) == 0 {
		return fields
	}
	normalized := make([]WorkflowField, len(fields))
	copy(normalized, fields)
	for index := range normalized {
		field := &normalized[index]
		if canonical := workflowNamedDynamicSource(field.Source, mode); canonical != "" {
			field.Source = canonical
		}
		inferred := workflowDynamicSourceForMode(field.FieldName, field.FieldType, mode)
		if strings.TrimSpace(field.Source) == "" && !field.sourceConfigured && !field.BindPrompt {
			field.Source = inferred
			if inferred != "" {
				field.SourceAutomatic = ptr(true)
			}
			continue
		}
		if shouldRepairLegacyWorkflowSource(field.FieldName, field.Source, inferred, mode) {
			field.Source = inferred
		}
	}
	return normalized
}

func shouldRepairLegacyWorkflowSource(fieldName string, source string, inferred string, mode string) bool {
	sourceKey := normalizeManagementFieldName(source)
	inferredKey := normalizeManagementFieldName(inferred)
	if sourceKey == "" || inferredKey == "" || sourceKey == inferredKey {
		return false
	}
	fieldKey := normalizeManagementFieldName(fieldName)
	wasMistakenForMedia := sourceKey == "referenceimage" || sourceKey == "referencevideo" || sourceKey == "referenceaudio"
	if wasMistakenForMedia && (workflowDimensionNameSource(fieldKey) != "" || inferredKey == "aspectratio" || inferredKey == "vquality") {
		return true
	}
	mode = strings.ToLower(strings.TrimSpace(mode))
	return (fieldKey == "resolution" && (mode == "video" && sourceKey == "size" || mode == "image" && sourceKey == "vquality")) || (fieldKey == "quality" && sourceKey == "vquality")
}

func validateWorkflowMediaInputs(fields []WorkflowField, input canvasGenerationInput) error {
	capacities := map[string]int{"referenceimage": 0, "referencevideo": 0, "referenceaudio": 0}
	hasMaskMapping := false
	for _, field := range fields {
		if field.Enabled != nil && !*field.Enabled {
			continue
		}
		source := strings.ReplaceAll(strings.ReplaceAll(normalizeWorkflowFieldSource(field), "_", ""), "-", "")
		if source == "mask" {
			hasMaskMapping = true
			continue
		}
		key := ""
		switch source {
		case "referenceimage", "image", "referenceimages":
			key = "referenceimage"
		case "referencevideo", "video", "referencevideos":
			key = "referencevideo"
		case "referenceaudio", "audio", "referenceaudios":
			key = "referenceaudio"
		}
		if key == "" {
			continue
		}
		index := field.SourceIndex
		if field.ImageOrder > 0 {
			index = field.ImageOrder - 1
		}
		if index < 0 {
			index = 0
		}
		if index+1 > capacities[key] {
			capacities[key] = index + 1
		}
	}
	checks := []struct {
		label    string
		count    int
		capacity int
	}{
		{label: "参考图片", count: len(input.ReferenceImages), capacity: capacities["referenceimage"]},
		{label: "参考视频", count: len(input.ReferenceVideos), capacity: capacities["referencevideo"]},
		{label: "参考音频", count: len(input.ReferenceAudios), capacity: capacities["referenceaudio"]},
	}
	for _, check := range checks {
		if check.count > check.capacity {
			return fmt.Errorf("工作流只配置了 %d 个%s槽位，但画布传入了 %d 个；请在工作流字段映射中补齐槽位", check.capacity, check.label, check.count)
		}
	}
	if input.Mask != nil && !hasMaskMapping {
		return errors.New("画布传入了蒙版，但工作流没有配置蒙版字段映射")
	}
	return nil
}

func runningHubNodeInfo(fields []WorkflowField, files map[string]string, input canvasGenerationInput) ([]map[string]any, error) {
	return runningHubNodeInfoWithWorkflow(fields, files, input, nil)
}

func runningHubNodeInfoWithWorkflow(fields []WorkflowField, files map[string]string, input canvasGenerationInput, workflow map[string]interface{}) ([]map[string]any, error) {
	items := make([]map[string]any, 0, len(fields)+3)
	for _, field := range fields {
		if field.Enabled != nil && !*field.Enabled || strings.TrimSpace(field.NodeID) == "" || strings.TrimSpace(field.FieldName) == "" {
			continue
		}
		// RunningHub 的 nodeInfoList 只接受字符串 fieldValue。部分内部节点不会把
		// 字符串恢复为数值，因此安全边界必须由服务端强制执行，不能依赖前端隐藏。
		if isRunningHubUnsafeInternalField(workflow, field) {
			continue
		}
		value, present, err := resolveWorkflowFieldValue(field, files, input)
		if err != nil {
			return nil, err
		}
		if !present {
			if field.Required {
				return nil, fmt.Errorf("工作流字段 %s 缺少值", firstNonEmptyString(field.ID, field.FieldName))
			}
			continue
		}
		if err := validateRunningHubWorkflowFieldValue(field, value); err != nil {
			return nil, err
		}
		encoded := workflowScalarString(value)
		if !shouldSendRunningHubWorkflowField(workflow, field, encoded) {
			continue
		}
		items = append(items, map[string]any{"nodeId": field.NodeID, "fieldName": field.FieldName, "fieldValue": encoded})
	}
	return items, nil
}

func shouldSendRunningHubWorkflowField(workflow map[string]interface{}, field WorkflowField, encoded string) bool {
	if len(workflow) == 0 {
		// AI App 只有公开参数列表，没有可用于比较的工作流 JSON。
		return true
	}
	node, ok := workflow[strings.TrimSpace(field.NodeID)].(map[string]interface{})
	if !ok {
		return true
	}
	inputs, ok := node["inputs"].(map[string]interface{})
	if !ok {
		return true
	}
	original, exists := inputs[strings.TrimSpace(field.FieldName)]
	if exists && isWorkflowLinkValue(original) {
		// 已连接输入属于工作流拓扑，不能被旧字段映射拆成字符串覆盖。
		return false
	}
	if normalizeWorkflowFieldSource(field) != "" || field.RandomEnabled {
		return !isRunningHubAutomaticInternalBinding(node, field)
	}
	if !exists {
		return true
	}
	// 拉取参数时会保存所有 widget 的默认值；未修改项无需重复覆盖工作流。
	return encoded != workflowScalarString(original)
}

func isRunningHubAutomaticInternalBinding(node map[string]interface{}, field WorkflowField) bool {
	if field.SourceAutomatic != nil && !*field.SourceAutomatic {
		return false
	}
	classType := strings.ToLower(strings.TrimSpace(stringValue(node["class_type"])))
	if classType != "imageresize+" {
		return false
	}
	// 旧配置没有 sourceAutomatic，但 ImageResize+ 的宽高来源是按同名字段自动误判的。
	// 保留节点自身尺寸链；用户仍可将来源设为默认并明确修改静态值。
	source := strings.ReplaceAll(strings.ReplaceAll(normalizeWorkflowFieldSource(field), "_", ""), "-", "")
	return source == "size" || source == "imagesize" || source == "sizewidth" || source == "width" || source == "imagewidth" || source == "videowidth" || source == "sizeheight" || source == "height" || source == "imageheight" || source == "videoheight"
}

func isRunningHubUnsafeInternalField(workflow map[string]interface{}, field WorkflowField) bool {
	if field.SafeToOverride != nil && !*field.SafeToOverride {
		return true
	}
	classType := strings.ToLower(strings.TrimSpace(field.ClassType))
	if node, ok := workflow[strings.TrimSpace(field.NodeID)].(map[string]interface{}); ok {
		classType = strings.ToLower(strings.TrimSpace(stringValue(node["class_type"])))
	}
	fieldName := strings.ToLower(strings.TrimSpace(field.FieldName))
	if classType == "int" && fieldName == "value" {
		return true
	}
	return classType == "imageresize+" && (fieldName == "width" || fieldName == "height" || fieldName == "multiple_of")
}

func validateRunningHubWorkflowFieldValue(field WorkflowField, value interface{}) error {
	fieldID := firstNonEmptyString(strings.TrimSpace(field.ID), strings.TrimSpace(field.NodeID)+"."+strings.TrimSpace(field.FieldName))
	fieldType := strings.ToUpper(strings.TrimSpace(field.FieldType))
	if fieldType == "NUMBER" || fieldType == "FLOAT" || fieldType == "INTEGER" || fieldType == "INT" || fieldType == "SLIDER" {
		numeric, ok := workflowNumericBound(value)
		if !ok {
			return fmt.Errorf("工作流字段 %s 不是有效数字", fieldID)
		}
		minValue, hasMin := workflowNumericBound(field.Min)
		maxValue, hasMax := workflowNumericBound(field.Max)
		stepValue, hasStep := workflowNumericBound(field.Step)
		if hasMin && hasMax && minValue > maxValue {
			return fmt.Errorf("工作流字段 %s 的最小值不能大于最大值", fieldID)
		}
		if hasStep && stepValue <= 0 {
			return fmt.Errorf("工作流字段 %s 的步长必须大于 0", fieldID)
		}
		if (hasMin && numeric < minValue) || (hasMax && numeric > maxValue) {
			return fmt.Errorf("工作流字段 %s 的值超出允许范围", fieldID)
		}
		if hasStep {
			start := float64(0)
			if hasMin {
				start = minValue
			}
			steps := (numeric - start) / stepValue
			if math.Abs(steps-math.Round(steps)) > 1e-7 {
				return fmt.Errorf("工作流字段 %s 的值不符合步长", fieldID)
			}
		}
	}
	if fieldType == "BOOLEAN" || fieldType == "BOOL" {
		switch item := value.(type) {
		case bool:
		case string:
			normalized := strings.ToLower(strings.TrimSpace(item))
			if normalized != "true" && normalized != "false" {
				return fmt.Errorf("工作流字段 %s 不是有效开关值", fieldID)
			}
		default:
			return fmt.Errorf("工作流字段 %s 不是有效开关值", fieldID)
		}
	}
	if options := workflowFieldAllowedOptions(field); len(options) > 0 {
		encoded := strings.TrimSpace(workflowScalarString(value))
		matched := false
		hasScalarOption := false
		for _, option := range options {
			if workflowOptionIsRange(option) {
				continue
			}
			candidate := strings.TrimSpace(workflowOptionString(option))
			if candidate == "" || candidate == "<nil>" {
				continue
			}
			hasScalarOption = true
			if candidate == encoded {
				matched = true
				break
			}
		}
		if hasScalarOption && !matched {
			return fmt.Errorf("工作流字段 %s 的值不在允许选项中", fieldID)
		}
	}
	return nil
}

func workflowOptionIsRange(value interface{}) bool {
	object, ok := value.(map[string]interface{})
	if !ok {
		return false
	}
	for _, key := range []string{"min", "max", "step", "minValue", "maxValue", "stepValue"} {
		if _, exists := object[key]; exists {
			return true
		}
	}
	if nested, ok := object["range"].(map[string]interface{}); ok {
		return workflowOptionIsRange(nested)
	}
	return false
}

func resolveWorkflowFieldValue(field WorkflowField, files map[string]string, input canvasGenerationInput) (interface{}, bool, error) {
	source := normalizeWorkflowFieldSource(field)
	// 画布参数按 nodeId + fieldName 独立保存时 source 可能为空；枚举字段仍必须
	// 使用工作流原始 options 的完整值，不能把用户界面上的比例简称直接发给 ComfyUI。
	if source == "" && strings.EqualFold(strings.TrimSpace(field.FieldName), "aspect_ratio") {
		// 旧版前端只把比例写入 Config.Size，没有同步改写字段映射。此时不能
		// 直接使用工作流保存的默认值，否则用户选择 9:16 会在提交前静默回到 1:1。
		// 仅对非 1:1 的显式比例做回填，避免没有动态参数时覆盖工作流自己的 1:1 默认值。
		requested := strings.TrimSpace(input.Config.Size)
		if requested != "" && !strings.EqualFold(workflowAspectRatio(requested), "1:1") {
			value := workflowAspectRatioValue(field, requested)
			if strings.TrimSpace(fmt.Sprint(value)) != "" {
				return value, true, nil
			}
		}
		raw := strings.TrimSpace(workflowOptionString(firstNonNilWorkflowValue(field.FieldValue, field.Value)))
		if raw != "" {
			value := workflowAspectRatioValue(field, raw)
			return value, true, nil
		}
	}
	if source != "" {
		switch strings.ReplaceAll(strings.ReplaceAll(source, "_", ""), "-", "") {
		case "prompt", "text", "positiveprompt", "positive":
			return input.Prompt, strings.TrimSpace(input.Prompt) != "", nil
		case "size", "imagesize":
			return input.Config.Size, strings.TrimSpace(input.Config.Size) != "", nil
		case "resolution":
			if strings.EqualFold(strings.TrimSpace(input.Mode), "video") {
				value := workflowVideoResolutionValue(field, input.Config.VQuality)
				return value, strings.TrimSpace(fmt.Sprint(value)) != "", nil
			}
			return input.Config.Size, strings.TrimSpace(input.Config.Size) != "", nil
		case "aspectratio", "ratio", "imageaspectratio", "imageratio", "videoaspectratio", "videoratio":
			value := workflowAspectRatioValue(field, input.Config.Size)
			return value, value != "", nil
		case "sizewidth", "width", "imagewidth", "videowidth":
			value := workflowDimensionPart(input.Mode, input.Config.Size, input.Config.VQuality, 0)
			return value, value != "", nil
		case "sizeheight", "height", "imageheight", "videoheight":
			value := workflowDimensionPart(input.Mode, input.Config.Size, input.Config.VQuality, 1)
			return value, value != "", nil
		case "quality":
			return input.Config.Quality, strings.TrimSpace(input.Config.Quality) != "", nil
		case "count", "batch", "batchsize":
			return input.Config.Count, strings.TrimSpace(input.Config.Count) != "", nil
		case "videoseconds", "video_seconds", "duration":
			value := workflowVideoDurationValue(field, input.Config.VideoSeconds)
			return value, strings.TrimSpace(fmt.Sprint(value)) != "", nil
		case "vquality", "videoquality", "video_quality":
			value := workflowVideoResolutionValue(field, input.Config.VQuality)
			return value, strings.TrimSpace(fmt.Sprint(value)) != "", nil
		case "videogenerateaudio", "video_generate_audio", "generateaudio":
			return input.Config.VideoGenerateAudio, strings.TrimSpace(input.Config.VideoGenerateAudio) != "", nil
		case "videowatermark", "video_watermark", "watermark":
			return input.Config.VideoWatermark, strings.TrimSpace(input.Config.VideoWatermark) != "", nil
		case "audioformat", "audio_format":
			return input.Config.AudioFormat, strings.TrimSpace(input.Config.AudioFormat) != "", nil
		case "systemprompt", "system_prompt":
			return input.Config.SystemPrompt, strings.TrimSpace(input.Config.SystemPrompt) != "", nil
		case "transparentbackground", "transparent_background":
			return input.Config.TransparentBackground, strings.TrimSpace(input.Config.TransparentBackground) != "", nil
		case "audiovoice", "audio_voice", "voice":
			return input.Config.AudioVoice, strings.TrimSpace(input.Config.AudioVoice) != "", nil
		case "audiospeed", "audio_speed":
			return input.Config.AudioSpeed, strings.TrimSpace(input.Config.AudioSpeed) != "", nil
		case "audioinstructions", "audio_instructions":
			return input.Config.AudioInstructions, strings.TrimSpace(input.Config.AudioInstructions) != "", nil
		}
		index := field.SourceIndex
		if field.ImageOrder > 0 {
			index = field.ImageOrder - 1
		}
		var media providerMedia
		switch strings.ReplaceAll(strings.ReplaceAll(source, "_", ""), "-", "") {
		case "referenceimage", "image", "referenceimages":
			if index < 0 || index >= len(input.ReferenceImages) {
				return nil, false, nil
			}
			media = input.ReferenceImages[index]
		case "referencevideo", "video", "referencevideos":
			if index < 0 || index >= len(input.ReferenceVideos) {
				return nil, false, nil
			}
			media = input.ReferenceVideos[index]
		case "referenceaudio", "audio", "referenceaudios":
			if index < 0 || index >= len(input.ReferenceAudios) {
				return nil, false, nil
			}
			media = input.ReferenceAudios[index]
		case "mask":
			if input.Mask == nil {
				return nil, false, nil
			}
			media = *input.Mask
		default:
			return nil, false, fmt.Errorf("不支持的工作流字段来源：%s", field.Source)
		}
		name := files[media.ID]
		if name == "" {
			return nil, false, errors.New("工作流参考素材尚未上传")
		}
		return name, true, nil
	}
	if field.RandomEnabled {
		randomMax := field.Max
		if isRunningHubInterface(input.Config.InterfaceType) && isWorkflowSeedField(field.FieldName) {
			// RunningHub 的随机 Seed 按 uint32 传输，不能沿用 JavaScript 安全整数上限。
			const runningHubSeedMax int64 = 1<<32 - 1
			maxValue, err := workflowIntegerBound(field.Max, runningHubSeedMax)
			if err != nil {
				return nil, false, err
			}
			if maxValue > runningHubSeedMax {
				maxValue = runningHubSeedMax
			}
			randomMax = maxValue
		}
		value, err := randomWorkflowInteger(field.Min, randomMax)
		return value, err == nil, err
	}
	if field.FieldValue != nil {
		return field.FieldValue, true, nil
	}
	if field.Value != nil {
		return field.Value, true, nil
	}
	return nil, false, nil
}

func firstNonNilWorkflowValue(values ...interface{}) interface{} {
	for _, value := range values {
		if value != nil {
			return value
		}
	}
	return nil
}

func normalizeWorkflowFieldSource(field WorkflowField) string {
	source := strings.ToLower(strings.TrimSpace(field.Source))
	if source == "" && field.BindPrompt {
		return "prompt"
	}
	if source != "" {
		return source
	}
	if !field.SourceFromUpstream {
		return ""
	}
	fieldName := strings.ToLower(strings.TrimSpace(field.FieldName))
	if fieldName == "prompt" || fieldName == "text" || fieldName == "positive_prompt" || fieldName == "positiveprompt" {
		return "prompt"
	}
	switch strings.ToLower(strings.TrimSpace(field.FieldType)) {
	case "image", "img", "photo", "picture":
		return "referenceimage"
	case "video", "movie":
		return "referencevideo"
	case "audio", "sound", "music", "voice":
		return "referenceaudio"
	default:
		return ""
	}
}

func workflowDimensionPart(mode string, size string, videoQuality string, index int) string {
	if index < 0 || index > 1 {
		return ""
	}
	if dimensions, ok := workflowPixelDimensions(size); ok {
		return strconv.Itoa(dimensions[index])
	}
	if strings.EqualFold(strings.TrimSpace(mode), "video") {
		dimensions, ok := workflowVideoDimensions(size, videoQuality)
		if !ok {
			return ""
		}
		return strconv.Itoa(dimensions[index])
	}
	dimensions, ok := workflowImageDimensions(size)
	if !ok {
		return ""
	}
	return strconv.Itoa(dimensions[index])
}

func workflowPixelDimensions(value string) ([2]int, bool) {
	var result [2]int
	normalized := strings.ToLower(strings.TrimSpace(value))
	if !strings.Contains(normalized, "x") {
		return result, false
	}
	parts := strings.FieldsFunc(normalized, func(r rune) bool { return r == 'x' || r == ' ' || r == ',' })
	if len(parts) != 2 {
		return result, false
	}
	for index, part := range parts {
		parsed, err := strconv.Atoi(strings.TrimSpace(part))
		if err != nil || parsed <= 0 {
			return result, false
		}
		result[index] = parsed
	}
	return result, true
}

func workflowAspectRatio(value string) string {
	normalized := strings.ToLower(strings.TrimSpace(value))
	// RunningHub 的 ResolutionSelector 选项带有展示文案（例如
	// "9:16 (Portrait Widescreen)"），协议比较只需要比例前缀。
	if cut := strings.IndexAny(normalized, " ("); cut >= 0 {
		normalized = strings.TrimSpace(normalized[:cut])
	}
	for _, suffix := range []string{"-1k", "-2k", "-4k"} {
		if strings.HasSuffix(normalized, suffix) {
			normalized = strings.TrimSuffix(normalized, suffix)
			break
		}
	}
	if width, height, ok := workflowRatioParts(normalized); ok {
		divisor := workflowGreatestCommonDivisor(width, height)
		return fmt.Sprintf("%d:%d", width/divisor, height/divisor)
	}
	dimensions, ok := workflowPixelDimensions(normalized)
	if !ok {
		return ""
	}
	ratio := 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}}
	bestDifference := math.MaxFloat64
	best := [2]int{}
	for _, candidate := range known {
		expected := float64(candidate[0]) / float64(candidate[1])
		difference := math.Abs(ratio-expected) / expected
		if difference < bestDifference {
			bestDifference = difference
			best = candidate
		}
	}
	if bestDifference <= 0.03 {
		return fmt.Sprintf("%d:%d", best[0], best[1])
	}
	divisor := workflowGreatestCommonDivisor(dimensions[0], dimensions[1])
	return fmt.Sprintf("%d:%d", dimensions[0]/divisor, dimensions[1]/divisor)
}

func workflowAspectRatioValue(field WorkflowField, value string) string {
	raw := strings.TrimSpace(value)
	if options := workflowFieldAllowedOptions(field); len(options) > 0 {
		requested := workflowAspectRatio(raw)
		for _, option := range options {
			candidate := strings.TrimSpace(workflowOptionString(option))
			if candidate != "" && strings.EqualFold(workflowAspectRatio(candidate), requested) {
				return candidate
			}
		}
		if fallback := workflowFieldConfiguredDefault(field); fallback != "" {
			return fallback
		}
		return raw
	}
	// “auto/adaptive” 是工作流的真实模式，不应被画布当前像素尺寸反推成
	// 一个并不存在的比例；宽高字段仍按工作流自身的默认值或显式尺寸处理。
	if fallback := strings.TrimSpace(workflowFieldConfiguredDefault(field)); strings.EqualFold(fallback, "auto") || strings.EqualFold(fallback, "adaptive") {
		return fallback
	}
	return workflowAspectRatio(raw)
}

func workflowFieldAllowedOptions(field WorkflowField) []interface{} {
	classType := strings.ToLower(strings.ReplaceAll(strings.ReplaceAll(strings.TrimSpace(field.ClassType), "_", ""), "-", ""))
	fieldName := strings.ToLower(strings.ReplaceAll(strings.ReplaceAll(strings.TrimSpace(field.FieldName), "_", ""), "-", ""))
	if classType == "resolutionselector" && fieldName == "aspectratio" {
		// RunningHub 的工作流 API 不返回 object_info；ResolutionSelector 的完整枚举
		// 是节点协议的一部分，通用比例预设（9:16 等）不能直接提交给该节点。
		return []interface{}{
			"1:1 (Square)",
			"2:3 (Portrait Photo)",
			"3:2 (Photo)",
			"3:4 (Portrait Standard)",
			"4:3 (Standard)",
			"9:16 (Portrait Widescreen)",
			"16:9 (Widescreen)",
			"21:9 (Ultrawide)",
		}
	}
	return field.Options
}

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

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

func workflowImageDimensions(value string) ([2]int, bool) {
	normalized := strings.ToLower(strings.TrimSpace(value))
	preset := 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 dimensions, ok := preset[normalized]; ok {
		return dimensions, true
	}
	ratio := workflowAspectRatio(normalized)
	widthRatio, heightRatio, ok := workflowRatioParts(ratio)
	if !ok {
		return [2]int{}, false
	}
	tier := "1k"
	if strings.HasSuffix(normalized, "-2k") {
		tier = "2k"
	} else if strings.HasSuffix(normalized, "-4k") {
		tier = "4k"
	}
	if tier == "1k" {
		if widthRatio >= heightRatio {
			return [2]int{workflowRoundToStep(1024*float64(widthRatio)/float64(heightRatio), 16), 1024}, true
		}
		return [2]int{1024, workflowRoundToStep(1024*float64(heightRatio)/float64(widthRatio), 16)}, true
	}
	longEdge := 2048
	if tier == "4k" {
		longEdge = 3840
	}
	if widthRatio >= heightRatio {
		return [2]int{longEdge, workflowRoundToStep(float64(longEdge)*float64(heightRatio)/float64(widthRatio), 16)}, true
	}
	return [2]int{workflowRoundToStep(float64(longEdge)*float64(widthRatio)/float64(heightRatio), 16), longEdge}, true
}

func workflowVideoDimensions(size string, quality string) ([2]int, bool) {
	ratio := workflowAspectRatio(size)
	widthRatio, heightRatio, ok := workflowRatioParts(ratio)
	shortEdge := workflowVideoResolutionPixels(quality)
	if !ok || shortEdge <= 0 {
		return [2]int{}, false
	}
	if widthRatio >= heightRatio {
		return [2]int{workflowRoundToStep(float64(shortEdge)*float64(widthRatio)/float64(heightRatio), 2), shortEdge}, true
	}
	return [2]int{shortEdge, workflowRoundToStep(float64(shortEdge)*float64(heightRatio)/float64(widthRatio), 2)}, true
}

func workflowRoundToStep(value float64, step int) int {
	if step <= 1 {
		return int(math.Round(value))
	}
	return int(math.Round(value/float64(step))) * step
}

func workflowVideoResolutionPixels(value string) int {
	normalized := strings.ToLower(strings.TrimSpace(value))
	switch normalized {
	case "low":
		return 480
	case "auto", "default", "medium", "high":
		return 720
	case "2k":
		return 1440
	case "4k":
		return 2160
	}
	parsed, err := strconv.Atoi(strings.TrimSuffix(normalized, "p"))
	if err != nil || parsed <= 0 {
		return 0
	}
	return parsed
}

func workflowVideoResolutionValue(field WorkflowField, value string) interface{} {
	raw := strings.TrimSpace(value)
	if raw == "" {
		return ""
	}
	if len(field.Options) > 0 {
		requested := normalizeWorkflowResolutionToken(raw)
		for _, option := range field.Options {
			candidate := strings.TrimSpace(workflowOptionString(option))
			if candidate != "" && normalizeWorkflowResolutionToken(candidate) == requested {
				// nodeInfoList 的 fieldValue 是字符串；对象选项只取其 value/id 等标量。
				return candidate
			}
		}
		// 工作流明确声明了可选项但画布值不在其中时，保留工作流默认值，
		// 不再把 2K/4K/720 等普通模型别名硬塞给工作流。
		if fallback := workflowFieldConfiguredDefault(field); fallback != "" {
			for _, option := range field.Options {
				candidate := strings.TrimSpace(workflowOptionString(option))
				if candidate != "" && normalizeWorkflowResolutionToken(candidate) == normalizeWorkflowResolutionToken(fallback) {
					return candidate
				}
			}
			return fallback
		}
		return raw
	}
	if numeric := workflowNumericResolutionValue(field, raw); numeric != nil {
		return numeric
	}
	if fallback := workflowFieldConfiguredDefault(field); fallback != "" && !workflowResolutionShapeCompatible(fallback, raw) {
		return fallback
	}
	return raw
}

func workflowVideoDurationValue(field WorkflowField, value string) interface{} {
	raw := strings.TrimSpace(value)
	if raw == "" {
		return ""
	}
	if len(field.Options) > 0 {
		requested := normalizeWorkflowDurationToken(raw)
		for _, option := range field.Options {
			candidate := strings.TrimSpace(workflowOptionString(option))
			if candidate != "" && normalizeWorkflowDurationToken(candidate) == requested {
				return candidate
			}
		}
		if fallback := workflowFieldConfiguredDefault(field); fallback != "" {
			for _, option := range field.Options {
				candidate := strings.TrimSpace(workflowOptionString(option))
				if candidate != "" && normalizeWorkflowDurationToken(candidate) == normalizeWorkflowDurationToken(fallback) {
					return candidate
				}
			}
			return fallback
		}
		return raw
	}
	if numeric := workflowNumericResolutionValue(field, raw); numeric != nil {
		return numeric
	}
	if fallback := workflowFieldConfiguredDefault(field); fallback != "" && !workflowResolutionShapeCompatible(fallback, raw) {
		return fallback
	}
	return raw
}

func normalizeWorkflowDurationToken(value string) string {
	return strings.ToLower(strings.TrimSpace(strings.TrimSuffix(strings.TrimSuffix(value, "s"), "秒")))
}

func workflowFieldConfiguredDefault(field WorkflowField) string {
	value := field.FieldValue
	if value == nil {
		value = field.Value
	}
	if value == nil {
		return ""
	}
	return strings.TrimSpace(workflowOptionString(value))
}

func normalizeWorkflowResolutionToken(value string) string {
	return strings.ToLower(strings.TrimSpace(strings.TrimSuffix(strings.TrimSuffix(value, "p"), "P")))
}

func workflowNumericValue(value string) *float64 {
	parsed, err := strconv.ParseFloat(strings.TrimSpace(strings.TrimSuffix(strings.TrimSuffix(value, "p"), "P")), 64)
	if err != nil || math.IsNaN(parsed) || math.IsInf(parsed, 0) {
		return nil
	}
	return &parsed
}

func workflowResolutionShapeCompatible(defaultValue string, requested string) bool {
	defaultNumeric := workflowNumericValue(defaultValue)
	requestedNumeric := workflowNumericValue(requested)
	if defaultNumeric != nil && requestedNumeric != nil {
		return true
	}
	return strings.EqualFold(strings.TrimSpace(defaultValue), strings.TrimSpace(requested))
}

func workflowNumericResolutionValue(field WorkflowField, raw string) interface{} {
	parsed := workflowNumericValue(raw)
	if parsed == nil {
		return nil
	}
	min, minOK := workflowNumericBound(field.Min)
	max, maxOK := workflowNumericBound(field.Max)
	step, stepOK := workflowNumericBound(field.Step)
	if !minOK && !maxOK && !stepOK && !strings.EqualFold(strings.TrimSpace(field.FieldType), "NUMBER") {
		return nil
	}
	value := *parsed
	if minOK && value < min {
		value = min
	}
	if maxOK && value > max {
		value = max
	}
	if stepOK && step > 0 {
		anchor := min
		if !minOK {
			anchor = 0
		}
		value = anchor + math.Round((value-anchor)/step)*step
	}
	if strings.EqualFold(strings.TrimSpace(field.FieldType), "NUMBER") && math.Trunc(value) == value {
		return int64(value)
	}
	return value
}

func workflowNumericBound(value interface{}) (float64, bool) {
	parsed, err := strconv.ParseFloat(strings.TrimSpace(fmt.Sprint(value)), 64)
	return parsed, err == nil && !math.IsNaN(parsed) && !math.IsInf(parsed, 0)
}

func workflowOptionString(value interface{}) string {
	if object, ok := value.(map[string]interface{}); ok {
		for _, key := range []string{"value", "id", "key", "label", "name"} {
			if candidate := strings.TrimSpace(fmt.Sprint(object[key])); candidate != "" && candidate != "<nil>" {
				return candidate
			}
		}
	}
	return fmt.Sprint(value)
}

func runningHubPromptFallback(workflow map[string]interface{}, prompt string) []map[string]any {
	if strings.TrimSpace(prompt) == "" || len(workflow) == 0 {
		return nil
	}
	bestNodeID := ""
	bestFieldName := ""
	bestScore := -1000
	nodeIDs := make([]string, 0, len(workflow))
	for nodeID := range workflow {
		nodeIDs = append(nodeIDs, nodeID)
	}
	sort.Slice(nodeIDs, func(i, j int) bool { return managementNodeIDLess(nodeIDs[i], nodeIDs[j]) })
	for _, nodeID := range nodeIDs {
		node, ok := workflow[nodeID].(map[string]interface{})
		if !ok {
			continue
		}
		inputs, ok := node["inputs"].(map[string]interface{})
		if !ok {
			continue
		}
		fieldNames := make([]string, 0, len(inputs))
		for fieldName := range inputs {
			fieldNames = append(fieldNames, fieldName)
		}
		sort.Strings(fieldNames)
		classType := strings.ToLower(strings.TrimSpace(fmt.Sprint(node["class_type"])))
		metaTitle := strings.ToLower(strings.TrimSpace(fmt.Sprint(workflowNodeMetaTitle(node))))
		for _, fieldName := range fieldNames {
			if !isWorkflowPromptCandidate(fieldName, classType, metaTitle) {
				continue
			}
			if isWorkflowLinkValue(inputs[fieldName]) {
				continue
			}
			score := workflowPromptCandidateScore(fieldName, classType, metaTitle)
			if bestNodeID == "" || score > bestScore {
				bestNodeID = nodeID
				bestFieldName = fieldName
				bestScore = score
			}
		}
	}
	if bestNodeID != "" {
		return []map[string]any{{"nodeId": bestNodeID, "fieldName": bestFieldName, "fieldValue": prompt}}
	}
	return nil
}

func isWorkflowMediaSource(source string) bool {
	normalized := strings.ReplaceAll(strings.ReplaceAll(strings.ToLower(strings.TrimSpace(source)), "_", ""), "-", "")
	switch normalized {
	case "referenceimage", "referenceimages", "image", "referencevideo", "referencevideos", "video", "referenceaudio", "referenceaudios", "audio", "mask":
		return true
	default:
		return false
	}
}

func workflowPromptCandidateScore(fieldName string, classType string, metaTitle string) int {
	descriptor := strings.ToLower(strings.TrimSpace(fieldName + " " + metaTitle))
	score := 0
	for _, marker := range []string{"negative", "neg prompt", "负面", "反向", "负向"} {
		if strings.Contains(descriptor, marker) {
			score -= 100
			break
		}
	}
	for _, marker := range []string{"positive", "正面", "正向"} {
		if strings.Contains(descriptor, marker) {
			score += 20
			break
		}
	}
	if strings.Contains(classType, "cliptextencode") {
		score += 5
	}
	if isWorkflowPromptFieldName(fieldName) {
		score += 2
	}
	return score
}

func randomWorkflowInteger(rawMin interface{}, rawMax interface{}) (int64, error) {
	const defaultMax int64 = 9007199254740991
	minValue, err := workflowIntegerBound(rawMin, 0)
	if err != nil {
		return 0, err
	}
	maxValue, err := workflowIntegerBound(rawMax, defaultMax)
	if err != nil {
		return 0, err
	}
	if maxValue < minValue {
		return 0, errors.New("工作流随机值最大值不能小于最小值")
	}
	rangeSize := new(big.Int).Sub(big.NewInt(maxValue), big.NewInt(minValue))
	rangeSize.Add(rangeSize, big.NewInt(1))
	offset, err := cryptorand.Int(cryptorand.Reader, rangeSize)
	if err != nil {
		return 0, fmt.Errorf("生成工作流随机值失败：%w", err)
	}
	return new(big.Int).Add(offset, big.NewInt(minValue)).Int64(), nil
}

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

func workflowFieldsBindPrompt(fields []WorkflowField) bool {
	for _, field := range fields {
		if field.Enabled != nil && !*field.Enabled || strings.TrimSpace(field.NodeID) == "" || strings.TrimSpace(field.FieldName) == "" {
			continue
		}
		source := strings.ReplaceAll(strings.ReplaceAll(normalizeWorkflowFieldSource(field), "_", ""), "-", "")
		switch source {
		case "prompt", "text", "positiveprompt", "positive":
			return true
		}
	}
	return false
}

func upsertRunningHubNodeInfo(items []map[string]any, overrides []map[string]any) []map[string]any {
	for _, override := range overrides {
		nodeID := strings.TrimSpace(stringValue(override["nodeId"]))
		fieldName := strings.TrimSpace(stringValue(override["fieldName"]))
		replaced := false
		for index, item := range items {
			if strings.TrimSpace(stringValue(item["nodeId"])) == nodeID && strings.TrimSpace(stringValue(item["fieldName"])) == fieldName {
				items[index] = override
				replaced = true
				break
			}
		}
		if !replaced {
			items = append(items, override)
		}
	}
	return items
}

func isWorkflowLinkValue(value interface{}) bool {
	items, ok := value.([]interface{})
	return ok && len(items) == 2 && fmt.Sprint(items[0]) != "" && isIntegerLike(items[1])
}

func isIntegerLike(value interface{}) bool {
	switch item := value.(type) {
	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:
		return true
	case float64:
		return item == float64(int(item))
	case json.Number:
		_, err := strconv.Atoi(string(item))
		return err == nil
	default:
		return false
	}
}

func isWorkflowPromptFieldName(value string) bool {
	normalized := strings.ToLower(strings.NewReplacer("_", "", "-", "", " ", "").Replace(strings.TrimSpace(value)))
	switch normalized {
	case "text", "prompt", "positiveprompt", "positive", "caption", "description":
		return true
	default:
		return false
	}
}

func isWorkflowPromptCandidate(fieldName string, classType string, metaTitle string) bool {
	if isWorkflowPromptFieldName(fieldName) {
		return true
	}
	normalizedField := strings.ToLower(strings.TrimSpace(fieldName))
	if normalizedField != "value" {
		return false
	}
	return strings.Contains(classType, "text") || strings.Contains(classType, "string") || strings.Contains(classType, "prompt") || strings.Contains(metaTitle, "text") || strings.Contains(metaTitle, "prompt") || strings.Contains(metaTitle, "提示词") || strings.Contains(metaTitle, "文本")
}

func workflowNodeMetaTitle(node map[string]interface{}) string {
	meta, _ := node["_meta"].(map[string]interface{})
	return fmt.Sprint(meta["title"])
}

func workflowScalarString(value interface{}) string {
	switch item := value.(type) {
	case string:
		return item
	case nil:
		return ""
	default:
		encoded, err := json.Marshal(item)
		if err == nil {
			return string(encoded)
		}
		return fmt.Sprint(item)
	}
}