package flow

import (
	"ai-agent/workflow/consts/flow"
	"ai-agent/workflow/consts/node"
	flowDao "ai-agent/workflow/dao/flow"
	"ai-agent/workflow/model/dto"
	flowDto "ai-agent/workflow/model/dto/flow"
	"ai-agent/workflow/model/entity"
	"context"
	"fmt"
	"regexp"
	"strconv"
	"strings"
	"time"

	"gitea.com/red-future/common/utils"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/util/gconv"
)

func getNodeInfo(flowInfo *entity.FlowExecution) (htmlUrl []string, textModelName string, textResultFrom map[string]any, textModelResponse map[string]any, imgModelName string, imgResultFrom map[string]any, imgModelResponse map[string]any) {
	// 查询节点中是否包含结果合并节点
	for _, item := range flowInfo.NodeInputParams {
		if item.NodeCode == node.NodeTypeMerge {
			for _, outputParamsItem := range flowInfo.OutputParams {
				outputParamsMap := gconv.Map(outputParamsItem)
				for _, mapItem := range outputParamsMap {
					if strings.HasSuffix(gconv.String(mapItem), ".html") {
						htmlUrl = append(htmlUrl, gconv.String(mapItem))
					}
				}
			}
		}
		if item.NodeCode == node.NodeTypeTextModel {
			textModelName = item.ModelConfig.ModelName
			textModelResponse = item.ModelConfig.ModelResponse
			for key, modelFormItem := range item.ModelConfig.ModelForm {
				textResultFrom[key] = map[string]any{
					"value": modelFormItem,
				}
			}
		}
		if item.NodeCode == node.NodeTypeImageModel {
			imgModelName = item.ModelConfig.ModelName
			imgModelResponse = item.ModelConfig.ModelResponse
			for key, modelFormItem := range item.ModelConfig.ModelForm {
				imgResultFrom[key] = map[string]any{
					"value": modelFormItem,
				}
			}
		}
	}

	return htmlUrl, textModelName, textResultFrom, textModelResponse, imgModelName, imgResultFrom, imgModelResponse

}

func TextImgModelSingleLambda(ctx context.Context, req *flowDto.ExecuteReq, flowInfo *entity.FlowExecution) (err error) {
	_, textModelName, textResultFrom, textModelResponse, imgModelName, imgResultFrom, imgModelResponse := getNodeInfo(flowInfo)

	resultUserFrom := make(map[string]any)
	resultUserFrom["desc"] = req.Desc

	var textNode []node.NodeFormField
	textNode, err = TextNode(ctx, req.SessionId, textModelName, req.SkillName, textResultFrom, resultUserFrom, textModelResponse, req.FileUrl)
	if err != nil {
		return
	}
	var textContent string
	var textUrl string
	for _, item := range textNode {
		if strings.Contains(item.Field, "text_content") {
			textContent = StripHtmlTags(item.Value)
		}
		if strings.Contains(item.Field, "text_url") {
			textUrl = item.Value
		}
	}

	resultUserFrom["text_content"] = textContent
	var imgNode []node.NodeFormField
	imgNode, err = ImgNode(ctx, req.SessionId, imgModelName, req.SkillName, imgResultFrom, resultUserFrom, imgModelResponse, req.FileUrl)
	if err != nil {
		return
	}
	var imgUrl []string
	for _, item := range imgNode {
		if strings.Contains(item.Field, "img_url") {
			imgUrl = append(imgUrl, item.Value)
		}
	}

	// 生成单条HTML
	htmlContent := BuildHtml(textUrl, imgUrl)
	// 上传OSS（每条独立上传）
	fileName := fmt.Sprintf("item_%d_%d.html", 0, time.Now().UnixMilli())
	var ossResult *dto.UploadFileBytesRes
	ossResult, err = Upload(ctx, &dto.UploadFileBytesReq{
		FileBytes: []byte(htmlContent),
		FileName:  fileName,
	})
	if err != nil {
		return
	}
	fmt.Printf("上传OSS成功：%s", ossResult.FileURL)

	var summaryResult []map[string]interface{}
	for _, outputParamsItem := range flowInfo.OutputParams {
		mapItem := gconv.Map(outputParamsItem)
		for _, mapValue := range mapItem {
			if strings.Contains(req.ResultUrl, gconv.String(mapValue)) {
				// 生成 毫秒时间戳 作为 KEY
				timeKey := strconv.FormatInt(time.Now().UnixMilli(), 10)
				item := make(map[string]interface{})
				item[timeKey] = ossResult.FileURL
				summaryResult = append(summaryResult, item)
				continue
			}
			summaryResult = append(summaryResult, outputParamsItem)
		}
	}
	if !g.IsEmpty(summaryResult) {
		executionReq := flowDto.UpdateFlowExecutionReq{
			Id:           flowInfo.Id,
			Status:       flow.FlowExecutionStatusSuccess.Code(),
			OutputParams: summaryResult,
		}
		_, err = flowDao.FlowExecutionDao.Update(ctx, &executionReq)
	}
	return
}

func ImgModelSingleLambda(ctx context.Context, req *flowDto.ExecuteReq, flowInfo *entity.FlowExecution) (err error) {
	var url string
	url, err = utils.GetFileAddressPrefix(ctx)
	if err != nil {
		return
	}

	htmlUrl, _, _, _, imgModelName, imgResultFrom, imgModelResponse := getNodeInfo(flowInfo)

	resultUserFrom := make(map[string]any)
	resultUserFrom["desc"] = req.Desc

	var imgNode []node.NodeFormField
	imgNode, err = ImgNode(ctx, req.SessionId, imgModelName, req.SkillName, imgResultFrom, resultUserFrom, imgModelResponse, req.FileUrl)
	if err != nil {
		return
	}

	var imgUrl string
	for _, item := range imgNode {
		if strings.Contains(item.Field, "img_url") {
			imgUrl = item.Value
		}
	}

	var htmlContentUrl string
	var oldHtmlUrl string
	if !g.IsEmpty(htmlUrl) {
		for i, item := range htmlUrl {
			var htmlBytes []byte
			htmlBytes, err = GetFileBytesFromURL(url + item)
			if err != nil {
				return
			}
			htmlContent := string(htmlBytes)

			imgSrcFromHtml := GetAllImgSrcFromHtml(htmlContent)
			// 3. 标记是否需要替换
			needReplace := false
			for _, imgSrc := range imgSrcFromHtml {
				if imgSrc == req.ResultUrl {
					needReplace = true
					break // 找到一个就可以替换
				}
			}

			// 4. 如果匹配到，执行替换（把旧的 req.ResultUrl 替换成 新链接）
			if needReplace {
				oldHtmlUrl = url + item
				htmlContent = ReplaceImgSrc(htmlContent, req.ResultUrl, imgUrl)
				// 上传OSS（每条独立上传）
				fileName := fmt.Sprintf("item_%d_%d.html", i, time.Now().UnixMilli())
				var ossResult *dto.UploadFileBytesRes
				ossResult, err = Upload(ctx, &dto.UploadFileBytesReq{
					FileBytes: []byte(htmlContent),
					FileName:  fileName,
				})
				if err != nil {
					return
				}
				fmt.Printf("上传OSS成功：%s", ossResult.FileURL)
				htmlContentUrl = ossResult.FileURL
			}

		}
	}

	var summaryResult []map[string]interface{}
	if !g.IsEmpty(imgUrl) {
		for _, outputParamsItem := range flowInfo.OutputParams {
			mapItem := gconv.Map(outputParamsItem)
			for _, mapValue := range mapItem {
				if strings.Contains(oldHtmlUrl, gconv.String(mapValue)) || strings.Contains(req.ResultUrl, gconv.String(mapValue)) {
					if strings.Contains(oldHtmlUrl, gconv.String(mapValue)) {
						// 生成 毫秒时间戳 作为 KEY
						timeKey := strconv.FormatInt(time.Now().UnixMilli(), 10)
						item := make(map[string]interface{})
						item[timeKey] = htmlContentUrl
						summaryResult = append(summaryResult, item)
					}
					if strings.Contains(req.ResultUrl, gconv.String(mapValue)) {
						// 生成 毫秒时间戳 作为 KEY
						timeKey := strconv.FormatInt(time.Now().UnixMilli(), 10)
						item := make(map[string]interface{})
						item[timeKey] = imgUrl
						summaryResult = append(summaryResult, item)
					}
					continue
				}
				summaryResult = append(summaryResult, outputParamsItem)
			}

		}
	}
	if !g.IsEmpty(summaryResult) {
		executionReq := flowDto.UpdateFlowExecutionReq{
			Id:           flowInfo.Id,
			Status:       flow.FlowExecutionStatusSuccess.Code(),
			OutputParams: summaryResult,
		}
		_, err = flowDao.FlowExecutionDao.Update(ctx, &executionReq)
	}
	return
}

func TextModelSingleLambda(ctx context.Context, req *flowDto.ExecuteReq, flowInfo *entity.FlowExecution) (err error) {
	var url string
	url, err = utils.GetFileAddressPrefix(ctx)
	if err != nil {
		return
	}
	htmlUrl, textModelName, textResultFrom, textModelResponse, _, _, _ := getNodeInfo(flowInfo)

	resultUserFrom := make(map[string]any)
	resultUserFrom["desc"] = req.Desc

	var textNode []node.NodeFormField
	textNode, err = TextNode(ctx, req.SessionId, textModelName, req.SkillName, textResultFrom, resultUserFrom, textModelResponse, req.FileUrl)
	if err != nil {
		return
	}
	var textUrl string
	for _, item := range textNode {
		if strings.Contains(item.Field, "text_url") {
			textUrl = item.Value
		}
	}

	var htmlContentUrl string
	var oldHtmlUrl string
	if !g.IsEmpty(htmlUrl) {
		for i, item := range htmlUrl {
			var htmlBytes []byte
			htmlBytes, err = GetFileBytesFromURL(url + item)
			if err != nil {
				return
			}
			htmlContent := string(htmlBytes)

			// 1) 匹配出 incUrl 的值
			incRegex := regexp.MustCompile(`incUrl\s*=\s*"([^"]+)"`)
			match := incRegex.FindStringSubmatch(htmlContent)
			// 2) 获取模板里原来的 incUrl
			oldIncUrl := ""
			if len(match) >= 2 {
				oldIncUrl = match[1] // 这是模板里的旧链接
			}
			// 3) 对比：不一样才替换
			if oldIncUrl == req.ResultUrl {
				oldHtmlUrl = url + item
				// 替换成新的链接
				htmlContent = incRegex.ReplaceAllString(htmlContent, fmt.Sprintf(`incUrl = "%s"`, url+textUrl))
				// 上传OSS（每条独立上传）
				fileName := fmt.Sprintf("item_%d_%d.html", i, time.Now().UnixMilli())
				var ossResult *dto.UploadFileBytesRes
				ossResult, err = Upload(ctx, &dto.UploadFileBytesReq{
					FileBytes: []byte(htmlContent),
					FileName:  fileName,
				})
				if err != nil {
					return
				}
				fmt.Printf("上传OSS成功：%s", ossResult.FileURL)
				htmlContentUrl = ossResult.FileURL
			}
		}
	}

	var summaryResult []map[string]interface{}
	if !g.IsEmpty(textUrl) {
		for _, outputParamsItem := range flowInfo.OutputParams {
			mapItem := gconv.Map(outputParamsItem)
			for _, mapValue := range mapItem {
				if strings.Contains(oldHtmlUrl, gconv.String(mapValue)) || strings.Contains(req.ResultUrl, gconv.String(mapValue)) {
					if strings.Contains(oldHtmlUrl, gconv.String(mapValue)) {
						// 生成 毫秒时间戳 作为 KEY
						timeKey := strconv.FormatInt(time.Now().UnixMilli(), 10)
						item := make(map[string]interface{})
						item[timeKey] = htmlContentUrl
						summaryResult = append(summaryResult, item)
					}
					if strings.Contains(req.ResultUrl, gconv.String(mapValue)) {
						// 生成 毫秒时间戳 作为 KEY
						timeKey := strconv.FormatInt(time.Now().UnixMilli(), 10)
						item := make(map[string]interface{})
						item[timeKey] = textUrl
						summaryResult = append(summaryResult, item)
					}
					continue
				}
				summaryResult = append(summaryResult, outputParamsItem)
			}
		}
	}
	if !g.IsEmpty(summaryResult) {
		executionReq := flowDto.UpdateFlowExecutionReq{
			Id:           flowInfo.Id,
			Status:       flow.FlowExecutionStatusSuccess.Code(),
			OutputParams: summaryResult,
		}
		_, err = flowDao.FlowExecutionDao.Update(ctx, &executionReq)
	}
	return
}

func TextNode(ctx context.Context, sessionId, modelName, skillName string, form, userForm, modelResponse map[string]any, fileUrl []string) ([]node.NodeFormField, error) {
	contentStr := "你是专业内容生成助手，请严格按以下规则输出内容：1、输出标准 HTML 片段，不要 Markdown，不要 ``` 符号，不要多余解释，2、整体用 <div class='report-container'> 包裹，3、主标题使用 <h2 class='title'>，4、章节标题使用 <h3 class='section-title'>，5、正文段落使用 <p class='paragraph'>，6、列表使用 <ul class='list'><li>...</li></ul>，7、重点内容使用 <strong> 加粗，8、段落之间清晰分隔，结构规整，9、如果生成多条文案，每条文案独立用 <div class='content-item' id='content-{序号}'> 包裹（序号从1开始），10、每条文案内部必须在最上方添加一行固定格式：<p class='image-count'>需要配图：N 张</p> N 是这条文案需要的图片数量，只能是数字，不能是其他文字，11、只输出 HTML 结构，不输出任何额外文字"
	userForm["prompt"] = contentStr

	mapTaskResult, err := GetModelResult(ctx, modelName, skillName, form, userForm, fileUrl, sessionId, "文案生成")
	if err != nil {
		return nil, err
	}

	resultContent := ""
	for key, _ := range modelResponse {
		resultContent = gconv.String(mapTaskResult[key])
	}

	// 拆分多条文案
	contentList := SplitMultiContents(resultContent)

	outputRes := make([]node.NodeFormField, 0)
	for i, contentItem := range contentList {
		outputRes = append(outputRes, node.NodeFormField{
			Field:  fmt.Sprintf("text_content_%d", i),
			Value:  contentItem,
			Label:  fmt.Sprintf("文案内容_%d", i),
			Type:   "string",
			Expand: ExtractImageCount(contentItem),
		})

		// 1. 构建html文本
		plainText := BuildText(contentItem)
		// 2. 上传纯文本到 OSS
		textFileName := fmt.Sprintf("ai_text_%d_%d.inc", time.Now().UnixMilli(), i)
		var textUrl *dto.UploadFileBytesRes
		textUrl, err = Upload(ctx, &dto.UploadFileBytesReq{
			FileBytes: []byte(plainText),
			FileName:  textFileName,
		})
		if err != nil {
			return nil, err
		}
		// 3. 把纯文本地址存入输出
		outputRes = append(outputRes, node.NodeFormField{
			Field:  fmt.Sprintf("text_url:%d", i),
			Value:  textUrl.FileURL,
			Label:  fmt.Sprintf("文案纯文本_txt_%d", i),
			Type:   "string",
			Expand: ExtractImageCount(contentItem),
		})
	}
	return outputRes, nil
}

func ImgNode(ctx context.Context, sessionId, modelName, skillName string, form, userForm, modelResponse map[string]any, fileUrl []string) ([]node.NodeFormField, error) {

	mapTaskResult, err := GetModelResult(ctx, modelName, skillName, form, userForm, fileUrl, sessionId, "图片生成")
	if err != nil {
		return nil, err
	}

	var resultContent []string
	for key, _ := range modelResponse {
		resultContent = gconv.Strings(mapTaskResult[key])
	}

	var images []string
	for _, item := range resultContent {
		mapItem := gconv.Map(item)
		for _, value := range mapItem {
			values, ok := value.(string)
			if !ok {
				return nil, fmt.Errorf("图片地址类型错误")
			}
			// 下载官方临时图片
			var imgBytes []byte
			imgBytes, err = GetFileBytesFromURL(values)
			if err != nil {
				return nil, fmt.Errorf("下载图片失败: %w", err)
			}
			// 构造文件名
			fileName := fmt.Sprintf("ai_image_%d.png", time.Now().UnixMilli())
			// 上传到你的OSS（你项目已有的Upload方法）
			var upResp *dto.UploadFileBytesRes
			upResp, err = Upload(ctx, &dto.UploadFileBytesReq{
				FileName:  fileName,
				FileBytes: imgBytes,
			})
			if err != nil {
				return nil, fmt.Errorf("上传OSS失败: %w", err)
			}
			images = append(images, upResp.FileURL)
		}
	}

	var url string
	url, err = utils.GetFileAddressPrefix(ctx)
	if err != nil {
		return nil, err
	}
	outputRes := make([]node.NodeFormField, 0)

	for i, item := range images {
		// 图片：image_0, image_1, image_2...
		outputRes = append(outputRes, node.NodeFormField{
			Field: fmt.Sprintf("image_%d", i),
			Value: fmt.Sprintf("%s%s", url, item),
			Label: fmt.Sprintf("图片_%d", i),
			Type:  "string",
		})
		// 额外存储关联关系
		outputRes = append(outputRes, node.NodeFormField{
			Field: fmt.Sprintf("img_url:%d", i),
			Value: fmt.Sprintf("%s%s", url, item),
			Label: fmt.Sprintf("图片_img_%d关联文案ID", i),
			Type:  "string",
		})
	}

	return outputRes, nil
}

func BuildParam(nodeInput *flowDto.NodeExecutionInput) (skillName string, resultFrom, resultUserFrom map[string]any) {
	// 1. 直接用你原来的方法（返回两个 map）
	inputMap, outputMap, modelMap := GetNodeContextContent(nodeInput.Global, nodeInput.Config)
	var outputResult []node.NodeFormField
	for _, valueAny := range inputMap {
		if field, ok := valueAny.(node.NodeFormField); ok {
			outputResult = append(outputResult, field)
		}
	}

	resultUserFrom = make(map[string]any)
	for _, valueAny := range outputMap {
		if field, ok := valueAny.(node.NodeFormField); ok {
			if !strings.Contains(field.Field, "text_url") && !strings.Contains(field.Field, "img_url") {
				if strings.Contains(field.Field, "text_content") {
					field.Value = StripHtmlTags(field.Value)
				}
				resultUserFrom[field.Label] = field
			}
		}
	}
	for _, valueAny := range modelMap {
		if field, ok := valueAny.(node.NodeFormField); ok {
			outputResult = append(outputResult, field)
		}
	}
	if !nodeInput.Global.IsDialogue {
		for _, item := range outputResult {
			resultUserFrom[item.Label] = item
		}
		for _, item := range nodeInput.Config.FormConfig {
			resultUserFrom[item.Label] = item
		}
	}
	if !g.IsEmpty(nodeInput.Global.Desc) {
		resultUserFrom["desc"] = node.NodeFormField{
			Value: nodeInput.Global.Desc,
			Field: "desc",
			Label: "描述",
			Type:  "text",
		}
	}

	resultFrom = make(map[string]any)
	for key, item := range nodeInput.Config.ModelConfig.ModelForm {
		resultFrom[key] = map[string]any{
			"value": item,
		}
	}
	skillName = nodeInput.Config.SkillName
	if g.IsEmpty(nodeInput.Config.SkillName) {
		skillName = nodeInput.Global.SkillName
	}

	return skillName, resultFrom, resultUserFrom
}

func GetNodeContextContent(execInput *flowDto.FlowExecutionInput, node *entity.FlowNode) (map[string]any, map[string]any, map[string]any) {
	input := make(map[string]any)
	output := make(map[string]any)
	model := make(map[string]any)
	// 1. 有引用 → 取引用节点的字段值
	if len(node.InputSource) > 0 {
		for _, source := range node.InputSource {
			refNodeID := source.NodeId
			isQuoteOutput := source.QuoteOutput
			fields := source.Field

			refNode, ok := execInput.ConfigMap[refNodeID]
			if !ok {
				continue
			}

			inputMap := buildInputMap(refNode)
			outputMap := mergeOutput(refNode.OutputResult)
			modelMap := mergeModel(refNode.ModelConfig)
			if isQuoteOutput {
				for k, v := range outputMap {
					output[k] = v
				}
			}
			if len(fields) > 0 {
				// 取指定字段
				for _, f := range fields {

					if v, ok := inputMap[f]; ok {
						input[f] = v
					}
					if v, ok := modelMap[f]; ok {
						model[f] = v
					}
				}
			} else {
				// 取全部
				for k, v := range inputMap {
					input[k] = v
				}
				for k, v := range modelMap {
					model[k] = v
				}
			}
		}
	}
	return input, output, model
}

// buildInputMap 从 FormConfig 构造输入map
func buildInputMap(node *entity.FlowNode) map[string]any {
	m := make(map[string]any)
	for _, item := range node.FormConfig {
		m[item.Label] = item
	}
	return m
}

// mergeOutput 合并节点输出 []map → 单map
func mergeOutput(output []node.NodeFormField) map[string]any {
	m := make(map[string]any)
	for _, item := range output {
		m[item.Label] = item
	}
	return m
}

// mergeOutput 合并节点输出 []map → 单map
func mergeModel(output node.ModelItem) map[string]any {
	m := make(map[string]any)
	// 遍历 output.ModelForm 里的每一个 key 和原始值
	for key, rawValue := range output.ModelForm {
		// 包装成 { "value": 原始值 }
		m[key] = map[string]any{
			"value": rawValue,
		}
	}
	return m
}