package controllers

import (
	"WorldEpcho/src/config"
	"WorldEpcho/src/config/e"
	database "WorldEpcho/src/datasource"
	"WorldEpcho/src/models"
	"WorldEpcho/src/service"
	"WorldEpcho/src/utils"
	"encoding/json"
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/gorilla/websocket"
	"log"
	"net/http"
	"strconv"
	"strings"
	"time"
)

// Business manager assessment translations 是英文到中文的键名映射
/*
var BusinessManagerAssessmentTranslations = map[string]string{
	"SceneInformation":    "场景信息",
	"location":            "地点",
	"name":                "名称",
	"security":            "有保安",
	"client":              "客户",
	"appearance":          "外观",
	"attitude":            "对用户的态度",
	"personality":         "性格",
	"introduction":        "简介",
	"roleName":            "角色名",
	"opener":              "开场白",
	"promotion":           "推介项目",
	"projectDescription":  "项目介绍",
	"projectName":         "项目名",
	"username":            "用户名",
	"userBackground":      "用户背景信息",
	"CustomTraining":      "定制训练",
	"sceneRulesCustom":    "场景规则定制",
	"ruleOne":             "规则一",
	"ruleTwo":             "规则二",
	"ruleThree":           "规则三",
	"outcomeSet":          "结局集",
	"date":                "date",
	"id":                  "id",
	"result":              "result",
	"difficulty":          "难易程度",
	"AssessmentWeights":   "考核权重",
	"professionalism":     "专业程度",
	"adaptability":        "应变能力",
	"communicationSkills": "沟通能力",
	"socialEtiquette":     "社交礼仪",
}
*/

/*
// 创建中文到英文的逆映射
var reverseTranslations map[string]string

func init() {
	BusinessManagerAssessmentTranslations := config.Conf.BusinessManagerAssessmentConfigTranslations
	reverseTranslations = make(map[string]string)
	for k, v := range BusinessManagerAssessmentTranslations {
		reverseTranslations[v] = k
	}
}*/

// translateKeys 是递归函数，用于转换JSON对象的键从中文到英文
// 中文到英文
func TranslateKeysChineseToEnglish(data interface{}) interface{} {
	ReverseTranslations := config.Conf.ReverseTranslations
	switch obj := data.(type) {
	case map[string]interface{}:
		newMap := make(map[string]interface{})
		for k, v := range obj {
			newKey := k
			if val, ok := ReverseTranslations[k]; ok {
				newKey = val
			}
			newMap[newKey] = TranslateKeysChineseToEnglish(v)
		}
		return newMap
	case []interface{}:
		for i, v := range obj {
			obj[i] = TranslateKeysChineseToEnglish(v)
		}
	}
	return data
}

// translateKeys 是递归函数，用于转换JSON对象的键
// 英文转中文
func TranslateKeysEnglishToChinese(data interface{}) interface{} {
	BusinessManagerAssessmentTranslations := config.Conf.BusinessManagerAssessmentConfigTranslations
	switch obj := data.(type) {
	case map[string]interface{}:
		newMap := make(map[string]interface{})
		for k, v := range obj {
			newKey := k
			if val, ok := BusinessManagerAssessmentTranslations[k]; ok {
				newKey = val
			}
			newMap[newKey] = TranslateKeysEnglishToChinese(v)
		}
		return newMap
	case []interface{}:
		for i, v := range obj {
			obj[i] = TranslateKeysEnglishToChinese(v)
		}
	}
	return data
}

//查询用户与那些世界进行过聊天会话
func QueryUserToWorldConversation(ctx *gin.Context) {
	/*
	   判断用户是否登录
	*/
	uid, isLogin := service.IsUserLoggedIn(ctx)
	if !isLogin {
		log.Println("用户未登录")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户未登录"})
		return
	}
	user, err1 := models.GetUserByID(uid)
	if err1 != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询用户已聊天的数字人会话，获取用户名称失败！"})
		return
	}
	//fmt.Println(user.Username)

	worlds, err := models.GetWorldsByUserID(uid)

	//fmt.Println("根据用户ID查询对应的世界ID和名字: ", worlds)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询用户已聊天的数字人会话，查询失败！"})
		return
	}

	info := models.UserWorldInfo{
		UserID:   uid,
		UserName: user.Username,
		Worlds:   worlds,
	}

	fmt.Println(" UserConversationWorldInfo 获取用户聊天过的世界个数 : ", len(info.Worlds))

	ctx.JSON(http.StatusOK, gin.H{"code": 1, "message": info})

}

//根据用户id和世界id查询该用户与世界聊天的历史记录
func QueryUserAndWorldHistoryChatById(ctx *gin.Context) {
	/*
	   判断用户是否登录
	*/
	uid, isLogin := service.IsUserLoggedIn(ctx)
	if !isLogin {
		log.Println("用户未登录")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户未登录"})
		return
	}
	//从前端获取需世界id
	worldId := ctx.PostForm("id")
	if worldId == "" {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "世界id不能为空"})
		return
	}

	//chatRecordArray, err := database.GetWorldChatHistoryLatest(utils.Strval(uid), worldId)
	chatRecordArray, err := database.GetWorldChatHistoryLatest2(utils.Strval(uid), worldId)
	if err != nil {
		if err == database.ErrNotFound {
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "未找到该用户在世界中的会话聊天记录"})
		} else {
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询失败"})
		}
		return
	}

	/*	var mergeAll bool
		if ctx.PostForm("mergeAll") == "" || ctx.PostForm("mergeAll") == "false" {
			mergeAll = false
		}
		if ctx.PostForm("mergeAll") == "true" {
			mergeAll = true
		}
		chatRecordArray, err := database.GetWorldChatHistoryLatest(utils.Strval(uid), worldId, mergeAll)
		if err != nil {
			if err == database.ErrNotFound {
				ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "未找到该用户与数字人的会话聊天记录"})
			} else {
				ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询失败"})
			}
			return
		}*/
	/*
		worldChatRecordArrays, err := database.QueryAllWorldChatRecordArrays(utils.Strval(uid), worldId)
		if err != nil {
			if err == database.ErrNotFound {
				ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "未找到该用户与数字人的会话聊天记录"})
			} else {
				ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询失败"})
			}
			return
		}*/
	ctx.JSON(http.StatusOK, gin.H{"code": 1, "message": "查询成功!", "worldChatRecordArrays": chatRecordArray})
	fmt.Println(config.ColorGreen, "worldChatRecordArrays query  history chat of successfully: ", chatRecordArray, config.ColorReset)
}

//根据用户ID和世界ID和聊天时间查询历史聊天记录
func QueryUserAndWorldHistoryChatByIdAndChatTime(ctx *gin.Context) {
	/*
	   判断用户是否登录
	*/
	uid, isLogin := service.IsUserLoggedIn(ctx)
	if !isLogin {
		log.Println("用户未登录")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户未登录"})
		return
	}
	//从前端获取需世界id
	worldId := ctx.PostForm("worldId")
	if worldId == "" {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "世界id不能为空"})
		return
	}
	// 开始聊天的时间戳
	startTime := ctx.PostForm("startTime")
	start_Time, err := strconv.ParseInt(startTime, 10, 64)
	if err != nil {
		fmt.Println("时间戳类型转换失败:", err.Error())
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "时间戳类型转换失败!"})
		return
	}

	worldChatRecordArray, err := database.GetChatRecordsByConversationIdAndTimestamp(utils.Strval(uid), worldId, start_Time)
	if err != nil {
		if err == database.ErrNotFound {
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "未找到该用户与数字人的会话聊天记录"})
		} else {
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询失败,未找到时间戳匹配的历史聊天记录"})
		}
		return
	}
	ctx.JSON(http.StatusOK, gin.H{"code": 1, "message": "查询成功!", "worldChatRecordArray": worldChatRecordArray})
	fmt.Println(config.ColorGreen, "worldChatRecordArrays query  history chat of successfully: ", worldChatRecordArray, config.ColorReset)
}

//重置世界的神经网络记忆文件
func SoulNeuralFileWorldReset(ctx *gin.Context) {

	/*
	   判断用户是否登录
	*/
	uid, isLogin := service.IsUserLoggedIn(ctx)
	if !isLogin {
		log.Println("用户未登录")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户未登录"})
		return
	}
	fmt.Println(config.ColorPurple, "重置世界的记忆文件 ==> 用户id", uid, config.ColorReset)
	//从前端获取需要重置的数字人Id,根据数字人id查询意识流id;通过参数将意识流Id传给接口
	worldName := ctx.PostForm("worldName")
	BgInfo := ctx.PostForm("BgInfo")
	userInfo := ctx.PostForm("userInfo")
	/*
	  根据用户id和数字人id，查询会话
	*/
	fmt.Println(config.ColorPurple, "world_name:", worldName, config.ColorReset)
	//开启事务
	session := database.Engine.NewSession()
	defer session.Close() //延迟关闭session
	err := session.Begin()
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "开启事务失败!"})
		fmt.Println("开启事务失败")
		return
	}

	world, _, err := models.GetWorldConversationByUidAndWorldName_Tx(session, uid, worldName)
	if world != nil {
		fmt.Println("世界Id：", world.WorldId, "世界名称：", world.WorldName)
	}
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询world会话记录失败！"})
		return
	}
	if world == nil {
		fmt.Println(config.ColorGreen, "重置记忆文件时，查询会话对象失败!", config.ColorReset)
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "重置记忆文件失败，未查询到对应的会话!"})
		return
	}
	SoulUrl := config.Conf.SoulUrl + "/world/neural"

	// 封装请求参数结构体
	request := service.SoulNeuralRequest{
		Auth:    config.Conf.SoulAuth,
		Type:    2, //0下载（离魂） 1上传（还魂） 2实例化（超度）
		ISLIUid: world.IsLiuId,
	}

	err, res_code := service.SoulNeuralFileReset(SoulUrl, request)
	if err != nil {
		log.Println("重置数字人神经网络记忆文件时失败!")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "重置数字人神经网络记忆文件时失败!"})
	}

	//根据世界名称查询世界对象是否存在
	wordInfo, _, err := models.GetWorldInfoByName_Tx(session, worldName)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据世界名称查询世界对象出错!"})
		return
	}
	if wordInfo == nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "重置的世界意识流时，未查询到世界信息!"})
		log.Println(err.Error())
		return
	}

	//响应码为1，记忆文件重置成功
	if res_code == 1 {

		chatRecordArray := database.WorldChatRecordArray{
			ConversationId: utils.Strval(uid) + "_" + utils.Strval(world.WorldId),
			Timestamp:      time.Now().Unix(),
			//存个空的聊天记录数组
			Records: []database.WorldChatRecord{},
		}
		err = database.SaveWorldChatRecord(chatRecordArray)
		if err != nil {
			log.Println("MongoDB数据库插入一条数据，err: ", err)
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "重置世界记忆文件,插入数据失败!"})
			return
		}
		fmt.Println(config.ColorBlue, "SoulNeural reset after WorldChatRecordArray  saved successfully", config.ColorReset)

		/*
		   需要重新NewAI接口世界获取意识流ID,然后修改已存在会话的意识流id
		*/

		worldResp, world_conversation, err := service.CreateVirtualWorldHandler(uid, worldName, BgInfo, userInfo)
		if err != nil {
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "content": "创建世界失败！"})
			return
		}
		fmt.Println(config.ColorPurple, "重置的世界意识流，客户端: ===> ", service.WorldManager.Client[utils.Strval(uid)], config.ColorReset)

		if service.WorldManager.Client[utils.Strval(uid)] == nil {
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "content": "你重置的世界意识流，客户端不存在"})
			return
		}
		service.WorldManager.Client[utils.Strval(uid)].WorldConversations = world_conversation

		/* 创建响应体 */
		HSReplyMsg := service.WorldSoulReplyMsg{
			Code:      worldResp.Code,
			WObj:      worldResp.WObj,
			ISLIU:     worldResp.ISLIU,
			WorldName: worldName,
			//包含意识流ID
			IsLIUId: &worldResp.ISLIUid,
			//加了一个消息状态类型
			MessageStatusType: worldResp.MessageStatusType,
		}
		var write_err error
		msg, _ := json.Marshal(HSReplyMsg)
		if service.WorldManager.Client[utils.Strval(uid)] != nil {
			write_err = service.WorldManager.Client[utils.Strval(uid)].Socket.WriteMessage(websocket.TextMessage, msg)
		}

		if write_err != nil {
			log.Println("返回意识流给客户端时出错! ")
			service.WorldDestroyWs(service.WorldManager.Client[utils.Strval(uid)])
			return
		}
		/* 保存世界的独白到数据库 */
		senderType := "world"
		// 拼接会话Id
		conversation_Id := utils.Strval(service.WorldManager.Client[utils.Strval(uid)].WorldConversations.Uid) + "_" + utils.Strval(service.WorldManager.Client[utils.Strval(uid)].WorldConversations.WorldId)
		_, chatDB_err := database.SaveWorldChatRecordMongoDB(conversation_Id, service.WorldManager.Client[utils.Strval(uid)].WorldConversations.WorldId, service.WorldManager.Client[utils.Strval(uid)].WorldConversations.WorldName, worldResp.ISLIU, worldResp.WObj, senderType)
		// 错误处理
		if chatDB_err != nil {
			log.Println(config.ColorRed, "保存数字人聊天记录至数据库出错!", config.ColorReset)

			errorMsg := service.ErrorMessage{
				Code:    -1,
				Message: "保存数字人聊天记录至数据库出错！",
			}
			errmsg, _ := json.Marshal(errorMsg)
			_ = service.WorldManager.Client[utils.Strval(uid)].Socket.WriteMessage(websocket.TextMessage, errmsg)

			return
		}
		//提交事务
		err = session.Commit()
		if err != nil {
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "创建数字人失败! "})
			return
		}
		ctx.JSON(http.StatusOK, gin.H{"code": 1, "message": "重置世界记忆文件成功!"})
	}
	//重置数字人神经网络记忆文件失败
	if res_code == -1 {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "重置数字人神经网络记忆文件失败!"})
	}

}

// 根据世界名模糊查询所有世界信息
func QueryWorldsByLikeName(ctx *gin.Context) {
	/*
	   判断用户是否登录
	*/
	_, isLogin := service.IsUserLoggedIn(ctx)
	if !isLogin {
		log.Println("用户未登录")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户未登录"})
		return
	}
	worldName := ctx.PostForm("worldName")
	worlds, err := models.QueryWorldsByLikeName2(worldName)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据世界名称模糊查询世界信息报错"})
		return
	}
	var worldInfoAndAsset []models.WorldInfoAndAsset

	for _, world := range worlds {
		if world.ShowHome == "true" {
			worldInfoAndAsset = append(worldInfoAndAsset, world)
		}
	}

	ctx.JSON(http.StatusOK, gin.H{
		"code":              1,
		"message":           "查询世界信息成功",
		"worldInfoAndAsset": worldInfoAndAsset,
	})

}

//更新世界信息
func EditWorldInfo(ctx *gin.Context) {
	/*
	   判断用户是否登录
	*/
	userID, isLogin := service.IsUserLoggedIn(ctx)
	if !isLogin {
		//userID = 1
		log.Println("用户未登录")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户未登录"})
		return
	}

	worldId := ctx.PostForm("worldId")
	//digital_PersonId = "4"
	/**
	  转换数字人Id为int类型, 方便后面数字人信息从数据库中查询获取
	*/
	world_id, err := strconv.ParseInt(worldId, 10, 64)
	if err != nil {
		fmt.Println("世界id类型转换失败:", err.Error())
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "世界id类型转换失败!"})
		return
	}

	//开启事务
	session := database.Engine.NewSession()
	defer session.Close() //延迟关闭session
	err1 := session.Begin()
	if err1 != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "开启事务失败!"})
		fmt.Println("开启事务失败")
		return
	}
	/*
	  先根据前端传过来的数字人id获取数字人对象
	*/
	worldInfoAndAsset, err := models.GetWorldInfoAndAssetByID_Tx(session, world_id)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询世界信息失败"})
		log.Println("查询世界信息失败 ==> ", err.Error())
		return
	}
	fmt.Println("worldInfoAndAsset ==> ", worldInfoAndAsset)

	//根据数字人id查询到创作者id
	authorId := worldInfoAndAsset.Creator
	//判断该用户是否拥有该数字人,并获取用户的权限等级值
	level, err := models.GetUserLevel(userID)
	if err != nil {
		log.Println("修改数字人时获取用户权限失败")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "更新时获取数字人信息时，获取用户权限失败!"})
		return
	}

	if !(userID == authorId || level == 0) {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "对不起,当前用户无权限修改世界信息"})
		return
	}
	/*
	   用户id为当前世界的创作者id，或者用户的level为0的超级管理员可以进行世界的修改
	*/
	worldName := ctx.PostForm("worldName")
	description := ctx.PostForm("description")
	role := ctx.PostForm("role")
	background := ctx.PostForm("background")
	tags := ctx.PostForm("tags")
	tagsArr := []string{}
	// 分割字符串，得到单独的数值字符串
	if tags != "" {
		tagsSplit := strings.Split(tags, ",")
		for _, tagStr := range tagsSplit {
			// 将转换后的数值添加到数组
			tagsArr = append(tagsArr, tagStr)
		}
	}

	showHome := ctx.PostForm("showHome")             //是否主页显示
	worldHeader := ctx.PostForm("worldHeader")       //世界副标题
	worldParameter := ctx.PostForm("worldParameter") //世界参量
	//修改数字人信息
	var world = models.WorldInfo{
		ID:       world_id,
		Name:     worldName,
		Role:     role,
		Tags:     tagsArr,
		ShowHome: showHome,
	}
	if description != "" {
		world.Description = description
	}
	if background != "" {
		world.Background = background
	}
	if worldHeader != "" {
		world.WorldHeader = worldHeader
	}
	if worldParameter != "" {
		world.WorldParameter = worldParameter
	}
	ip := utils.ReadUserIP(ctx.Request)
	fmt.Println("|| =============================== 编辑世界信息操作 ======================================== || ")
	log.Printf(config.ColorYellow+"时间为:%s , 用户主机IP:%s, 用户ID为: %d的用户, 修改了世界信息: %s的信息。"+config.ColorReset, utils.GetNormalTimeString(time.Now()), ip, userID, world.Name)

	fmt.Println("|| ====================================================================================== || ")

	/*
	   操作数据库更新数字人相关信息
	*/
	err = models.UpdateWorld(session, &world)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "更新世界信息失败"})
		return
	}

	// 世界资产
	/*	voiceGroups := ctx.PostForm("voiceGroups")
		worldLines := ctx.PostForm("worldLines")
		worldRules := ctx.PostForm("worldRules")
	*/
	// 处理世界资产
	/*
		var worldAsset models.WorldAsset
		if err := ctx.ShouldBindJSON(&worldAsset); err != nil {
			log.Println("解析世界资产失败:", err)
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": err.Error()})
			return
		}
		if worldInfoAndAsset.WorldAsset.WorldID == 0 {
			// 创建新世界资产
			var worldAsset = models.WorldAsset{
				WorldID: worldInfoAndAsset.WorldAsset.WorldID,
			}

			worldAsset.CreatedAt = time.Now().Unix()
			worldAsset.UpdatedAt = time.Now().Unix()
			if err := models.CreateWorldAsset(session, &worldAsset); err != nil {
				log.Println("保存世界资产失败:", err)
				ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "保存世界资产失败"})
				return
			}
		} else {
			// 更新现有世界资产
			worldAsset.WorldID = worldInfoAndAsset.WorldAsset.WorldID
			if err := models.UpdateWorldAsset(session, worldAsset.WorldID, &worldAsset); err != nil {
				log.Println("更新世界资产失败:", err)
				ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "更新世界资产失败"})
				return
			}
		}
	*/
	assetWorldId := worldInfoAndAsset.WorldInfo.ID
	var worldAsset = models.WorldAsset{
		WorldID:   assetWorldId,
		WorldName: worldName,
		CreatedAt: time.Now().Unix(),
		UpdatedAt: time.Now().Unix(),
	}

	// 从PostForm获取JSON形式的字符串
	voiceGroupsStr := ctx.PostForm("voiceGroups")
	worldLinesStr := ctx.PostForm("worldLines")
	worldRules := ctx.PostForm("worldRules")

	// 解析声线组
	if voiceGroupsStr != "" {
		if err := json.Unmarshal([]byte(voiceGroupsStr), &worldAsset.VoiceGroups); err != nil {
			log.Println("解析声线组失败:", err)
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "解析声线组失败"})
			return
		}
	}

	// 解析世界线
	if worldLinesStr != "" {
		if err := json.Unmarshal([]byte(worldLinesStr), &worldAsset.WorldLines); err != nil {
			log.Println("解析世界线失败:", err)
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "解析世界线失败"})
			return
		}
	}

	if worldInfoAndAsset.WorldAsset.WorldID == 0 {
		if worldRules != "" {
			worldAsset.WorldRules = worldRules
		}
		if err := models.CreateWorldAsset(session, &worldAsset); err != nil {
			log.Println("保存世界资产失败:", err)
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "保存世界资产失败"})
			return
		}

	} else {
		// 更新现有世界资产
		worldAsset.WorldID = worldInfoAndAsset.WorldAsset.WorldID
		if err := models.UpdateWorldAsset(session, worldAsset.WorldID, &worldAsset); err != nil {
			log.Println("更新世界资产失败:", err)
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "更新世界资产失败"})
			return
		}

	}

	//提交事务
	err = session.Commit()
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "修改世界信息失败"})
		return
	}
	log.Println("修改世界信息成功!")
	ctx.JSON(http.StatusOK, gin.H{"code": 1, "message": "修改世界信息成功"})

}

// 根据世界名模糊查询所有世界对象
func QueryWorldInfoAndAssetById(ctx *gin.Context) {
	/*
	   判断用户是否登录
	*/
	_, isLogin := service.IsUserLoggedIn(ctx)
	if !isLogin {
		log.Println("用户未登录")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户未登录"})
		return
	}
	// 世界id
	worldId := ctx.PostForm("worldId")
	world_id, err := strconv.ParseInt(worldId, 10, 64)
	if err != nil {
		fmt.Println("世界id类型转换失败:", err.Error())
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "世界id类型转换失败!"})
		return
	}
	worldInfoAndAsset, err := models.GetWorldInfoAndAssetByID(world_id)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询世界信息失败"})
		log.Println("查询世界信息失败 ==> ", err.Error())
		return
	}
	fmt.Println("worldInfoAndAsset ==> ", worldInfoAndAsset)

	ctx.JSON(http.StatusOK, gin.H{
		"code":              1,
		"message":           "查询世界信息和世界资产成功",
		"worldInfoAndAsset": worldInfoAndAsset,
	})

}

//业务经理考核系统面板
func CreateBusinessManagerAssessmentSystem(ctx *gin.Context) {
	//鉴权
	/*
	   判断用户是否登录
	*/
	_, isLogin := service.IsUserLoggedIn2(ctx)
	if !isLogin {
		log.Println("用户未登录")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户未登录"})
		return
	}
	worldName := ctx.PostForm("worldName")
	description := ctx.PostForm("description")
	fmt.Println("worldName =>", worldName, "description =>", description)
	if worldName == "" {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "世界名称不能为空."})
		fmt.Println("世界名称不能为空")
		return
	}
	if description == "" {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "世界描述信息不能为空."})
		fmt.Println("世界描述信息不能为空")
		return
	}
	//role := ctx.PostForm("role")
	background := ctx.PostForm("background")   //背景信息
	showHome := ctx.PostForm("showHome")       //是否主页显示
	worldHeader := ctx.PostForm("worldHeader") //世界副标题
	//worldParameter := ctx.PostForm("worldParameter") //世界参量
	// 服务商id获取
	var SP *models.ServiceProvider
	var err error
	ServiceProviderId := ctx.PostForm("AuthId")
	if ServiceProviderId == "" {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "服务商id不能为空"})
		return
	}
	if ServiceProviderId != "" {
		SP, err = models.GetServiceProviderById(ServiceProviderId)
		if err != nil {
			fmt.Println("根据服务商id查询出错:", err)
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据服务商id查询服务商出错"})
			return
		}
		if SP == nil {
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "非法的服务商"})
			return
		}
	}
	//世界标签
	Tags := ctx.PostForm("tags")
	if Tags == "" {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "世界标签不能为空!"})
		fmt.Println("世界标签不能为空")
		return
	}

	//可以访问的标签
	//TagsArr := []string{}
	// 创建一个空切片存储匹配的标签
	matchingTags := []string{}

	// 分割字符串，得到单独的字符串
	tagsSplit := strings.Split(Tags, ",")
	for _, tagStr := range tagsSplit {
		/*TagsArr = append(TagsArr, tagStr)
		if !ContainsString(TagsArr, SP.AccessibleTags) {
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "不包含该服务商可访问的世界标签!"})
			fmt.Println("不包含该服务商可访问的世界标签")
			return
		}*/
		//如果包含服务商可访问的世界标签，则遍历将包含的标签放入数组
		// 检查每个用户标签是否被服务商允许
		if ContainsString(SP.AccessibleTags, tagStr) {
			matchingTags = append(matchingTags, tagStr)
		}

	}
	// 如果没有任何匹配的标签，则返回错误信息
	if len(matchingTags) == 0 {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "不包含该服务商可访问的世界标签!"})
		fmt.Println("不包含该服务商可访问的世界标签")
		return
	}
	configData := ctx.PostForm("configData") //配置信息 json字符串
	if configData == "" {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "业务经理考核系统配置信息不能为空."})
		fmt.Println("业务经理考核系统配置信息不能为空")
		return
	}
	fmt.Println("configData => ", configData)
	if background == "" {
		background = "AI智能推演系统"
	}
	/*	tagsArr := []string{}
		if tags == "" {
			tagsArr = append(tagsArr, "业务经理考核")

		}*/
	if showHome == "" {
		showHome = "false"
	}
	if worldHeader == "" {
		worldHeader = "AI智能考核系统"
	}
	//开启事务
	session := database.Engine.NewSession()
	defer session.Close() //延迟关闭session
	err = session.Begin()
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "开启事务失败!"})
		fmt.Println("开启事务失败")
		return
	}
	_, exist, err := models.GetWorldInfoByName_Tx(session, worldName)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据世界名称查询世界信息出错!"})
		fmt.Println("根据世界名称查询世界信息出错")
		return
	}
	if exist {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "世界名称已存在，请更换世界名称."})
		fmt.Println("世界名称已存在，请更换世界名称")
		return
	}
	/*
		worldInfo, err := models.GetWorld(session, 4)
		if err != nil {
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询世界信息出错!"})
			fmt.Println("查询世界信息出错")
			return
		}
		if worldInfo == nil {
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "未查询到世界相关信息!"})
			fmt.Println("未查询到世界相关信息")
			return
		}

		var panel models.AssessmentCustomizationPanel
		if err := ctx.BindJSON(&panel); err != nil {
			ctx.JSON(http.StatusOK, gin.H{"error": err.Error()})
			return
		}

		configDataBytes, err := json.Marshal(panel)
		if err != nil {
			ctx.JSON(http.StatusOK, gin.H{
				"code":    0,
				"message": "配置信息数据解析失败",
			})
			return
		}
	*/

	worldInfo := &models.WorldInfo{
		Name:        worldName,
		Description: description,
		Background:  background,
		Tags:        matchingTags,
		ShowHome:    showHome,
		WorldHeader: worldHeader,
		ConfigData:  configData,
	}

	_, err = models.AddWorldInfo(session, worldInfo)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "创建业务经理考核系统世界推演出错"})
		return
	}

	//提交事务
	err = session.Commit()
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "创建业务经理考核系统世界推演失败"})
		return
	}

	ctx.JSON(http.StatusOK, gin.H{
		"code":    1,
		"message": "创建业务经理考核系统世界推演成功",
	})

}

//创建考核系统-世界请求参数结构体
type CreateWorldRequest struct {
	WorldName         string `json:"worldName"`
	Description       string `json:"description"`
	Background        string `json:"background,omitempty"`
	ShowHome          string `json:"showHome,omitempty"`
	WorldHeader       string `json:"worldHeader,omitempty"`
	ServiceProviderId string `json:"authId"`
	Tags              string `json:"tags"`
	ConfigData        string `json:"configData"`
}

//咪咕 业务经理考核系统创建
func MiGuCreateBusinessManagerAssessmentSystem1(ctx *gin.Context) {
	//鉴权
	/*
	   判断用户是否登录
	*/
	_, isLogin := service.IsUserLoggedIn(ctx)
	if !isLogin {
		log.Println("用户未登录")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户未登录"})
		return
	}
	worldName := ctx.PostForm("worldName")
	description := ctx.PostForm("description")
	fmt.Println("worldName =>", worldName, "description =>", description)
	if worldName == "" {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "世界名称不能为空."})
		fmt.Println("世界名称不能为空")
		return
	}
	if description == "" {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "世界描述信息不能为空."})
		fmt.Println("世界描述信息不能为空")
		return
	}
	//role := ctx.PostForm("role")
	background := ctx.PostForm("background")   //背景信息
	showHome := ctx.PostForm("showHome")       //是否主页显示
	worldHeader := ctx.PostForm("worldHeader") //世界副标题
	//worldParameter := ctx.PostForm("worldParameter") //世界参量
	// 服务商id获取
	var SP *models.ServiceProvider
	var err error
	ServiceProviderId := ctx.PostForm("AuthId")
	if ServiceProviderId == "" {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "服务商id不能为空"})
		return
	}
	if ServiceProviderId != "" {
		SP, err = models.GetServiceProviderById(ServiceProviderId)
		if err != nil {
			fmt.Println("根据服务商id查询出错:", err)
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据服务商id查询服务商出错"})
			return
		}
		if SP == nil {
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "非法的服务商"})
			return
		}
	}
	//世界标签
	Tags := ctx.PostForm("tags")
	if Tags == "" {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "世界标签不能为空!"})
		fmt.Println("世界标签不能为空")
		return
	}

	//可以访问的标签
	//TagsArr := []string{}
	// 创建一个空切片存储匹配的标签
	matchingTags := []string{}

	// 分割字符串，得到单独的字符串
	tagsSplit := strings.Split(Tags, ",")
	for _, tagStr := range tagsSplit {
		/*TagsArr = append(TagsArr, tagStr)
		if !ContainsString(TagsArr, SP.AccessibleTags) {
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "不包含该服务商可访问的世界标签!"})
			fmt.Println("不包含该服务商可访问的世界标签")
			return
		}*/
		//如果包含服务商可访问的世界标签，则遍历将包含的标签放入数组
		// 检查每个用户标签是否被服务商允许
		if ContainsString(SP.AccessibleTags, tagStr) {
			matchingTags = append(matchingTags, tagStr)
		}

	}
	// 如果没有任何匹配的标签，则返回错误信息
	if len(matchingTags) == 0 {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "不包含该服务商可访问的世界标签!"})
		fmt.Println("不包含该服务商可访问的世界标签")
		return
	}
	configData := ctx.PostForm("configData") //配置信息 json字符串
	if configData == "" {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "业务经理考核系统配置信息不能为空."})
		fmt.Println("业务经理考核系统配置信息不能为空")
		return
	}
	/* configData 英文键转换为中文 */
	var data map[string]interface{}
	err = json.Unmarshal([]byte(configData), &data)
	if err != nil {
		fmt.Println("Error parsing JSON:", err)
		return
	}

	// 转换键名
	translatedData := TranslateKeysEnglishToChinese(data)
	translatedJSON, err := json.MarshalIndent(translatedData, "", "    ")
	if err != nil {
		fmt.Println("Error marshalling JSON:", err)
		return
	}

	fmt.Println(" configData translatedJSON ==> ", string(translatedJSON))

	//fmt.Println("configData => ", configData)
	if background == "" {
		background = "AI智能推演系统"
	}
	/*	tagsArr := []string{}
		if tags == "" {
			tagsArr = append(tagsArr, "业务经理考核")

		}*/
	if showHome == "" {
		showHome = "false"
	}
	if worldHeader == "" {
		worldHeader = "AI智能考核系统"
	}
	//开启事务
	session := database.Engine.NewSession()
	defer session.Close() //延迟关闭session
	err = session.Begin()
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "开启事务失败!"})
		fmt.Println("开启事务失败")
		return
	}
	_, exist, err := models.GetWorldInfoByName_Tx(session, worldName)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据世界名称查询世界信息出错!"})
		fmt.Println("根据世界名称查询世界信息出错")
		return
	}
	if exist {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "世界名称已存在，请更换世界名称."})
		fmt.Println("世界名称已存在，请更换世界名称")
		return
	}
	/*
		worldInfo, err := models.GetWorld(session, 4)
		if err != nil {
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询世界信息出错!"})
			fmt.Println("查询世界信息出错")
			return
		}
		if worldInfo == nil {
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "未查询到世界相关信息!"})
			fmt.Println("未查询到世界相关信息")
			return
		}

		var panel models.AssessmentCustomizationPanel
		if err := ctx.BindJSON(&panel); err != nil {
			ctx.JSON(http.StatusOK, gin.H{"error": err.Error()})
			return
		}

		configDataBytes, err := json.Marshal(panel)
		if err != nil {
			ctx.JSON(http.StatusOK, gin.H{
				"code":    0,
				"message": "配置信息数据解析失败",
			})
			return
		}
	*/

	worldInfo := &models.WorldInfo{
		Name:        worldName,
		Description: description,
		Background:  background,
		Tags:        matchingTags,
		ShowHome:    showHome,
		WorldHeader: worldHeader,
		ConfigData:  configData,
	}

	_, err = models.AddWorldInfo(session, worldInfo)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "创建业务经理考核系统世界推演出错"})
		return
	}

	//提交事务
	err = session.Commit()
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "创建业务经理考核系统世界推演失败"})
		return
	}

	ctx.JSON(http.StatusOK, gin.H{
		"code":    1,
		"message": "创建业务经理考核系统世界推演成功",
	})

}

//咪咕 业务经理考核系统创建
func MiGuCreateBusinessManagerAssessmentSystem(ctx *gin.Context) {

	var request CreateWorldRequest
	if err := ctx.ShouldBindJSON(&request); err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": e.InvalidParams, "data": nil, "message": "请求数据不正确"})
		return
	}

	// 从请求头 Authorization 中提取令牌
	tokenString := ctx.GetHeader("Token")
	if tokenString != "" {
		// 解析并验证 JWT 令牌
		isValid, err := service.IsValidMiGuToken(tokenString)
		if err != nil || !isValid {
			ctx.JSON(http.StatusOK, gin.H{"code": e.InvalidToken, "data": nil, "message": "无效或已过期的令牌"})
			return
		}
	} else {
		ctx.JSON(http.StatusOK, gin.H{"code": e.UnauthorizedStatus, "data": nil, "message": "请求头中无token,或未授权的token访问"})
		return
	}

	if request.WorldName == "" || request.Description == "" {
		ctx.JSON(http.StatusOK, gin.H{"code": e.EmptyParamsError, "data": nil, "message": "世界名称和描述信息不能为空"})
		return
	}

	if request.ServiceProviderId == "" {
		ctx.JSON(http.StatusOK, gin.H{"code": e.EmptyParamsError, "data": nil, "message": "服务商id不能为空"})
		return
	}

	sp, err := models.GetServiceProviderById(request.ServiceProviderId)
	if err != nil || sp == nil {
		ctx.JSON(http.StatusOK, gin.H{"code": e.NotFound, "data": nil, "message": "根据服务商id查询服务商出错或服务商不存在", "error": err.Error()})
		return
	}

	//可以访问的标签
	// 创建一个空切片存储匹配的标签
	matchingTags := []string{}

	// 分割字符串，得到单独的字符串
	tagsSplit := strings.Split(request.Tags, ",")
	for _, tagStr := range tagsSplit {
		/*TagsArr = append(TagsArr, tagStr)
		if !ContainsString(TagsArr, SP.AccessibleTags) {
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "不包含该服务商可访问的世界标签!"})
			fmt.Println("不包含该服务商可访问的世界标签")
			return
		}*/
		//如果包含服务商可访问的世界标签，则遍历将包含的标签放入数组
		// 检查每个用户标签是否被服务商允许
		if ContainsString(sp.AccessibleTags, tagStr) {
			matchingTags = append(matchingTags, tagStr)
		}

	}
	// 如果没有任何匹配的标签，则返回错误信息
	if len(matchingTags) == 0 {
		ctx.JSON(http.StatusOK, gin.H{"code": e.NotFound, "data": nil, "message": "不包含该服务商可访问的世界标签!"})
		fmt.Println("不包含该服务商可访问的世界标签")
		return
	}

	if request.ConfigData == "" {
		ctx.JSON(http.StatusOK, gin.H{"code": e.EmptyParamsError, "data": nil, "message": "业务经理考核系统配置信息不能为空"})
		return
	}

	/* configData 英文键转换为中文 */
	var data map[string]interface{}
	if err := json.Unmarshal([]byte(request.ConfigData), &data); err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": e.ParamParseError, "data": nil, "message": "解析配置数据出错"})
		return
	}
	// 转换键名
	translatedData := TranslateKeysEnglishToChinese(data)
	translatedJSON, err := json.MarshalIndent(translatedData, "", "    ")
	if err != nil {
		fmt.Println("Error marshalling JSON:", err)
		ctx.JSON(http.StatusOK, gin.H{"code": e.ParamParseError, "data": nil, "message": "解析配置数据出错"})
		return
	}
	fmt.Println(" configData translatedJSON ==> ", string(translatedJSON))

	// 设置默认值
	if request.Background == "" {
		request.Background = "AI智能推演系统"
	}
	if request.ShowHome == "" {
		request.ShowHome = "false"
	}
	if request.WorldHeader == "" {
		request.WorldHeader = "AI智能考核系统"
	}

	session := database.Engine.NewSession()
	defer session.Close()
	if err := session.Begin(); err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": e.InternalError, "data": nil, "message": "开启事务失败"})
		return
	}

	_, exist, err := models.GetWorldInfoByName_Tx(session, request.WorldName)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": e.ErrorDatabase, "data": nil, "message": "根据世界名称查询世界信息出错"})
		return
	}
	if exist {
		ctx.JSON(http.StatusOK, gin.H{"code": e.ErrorDatabase, "data": nil, "message": "世界名称已存在，请更换世界名称"})
		return
	}

	worldInfo := &models.WorldInfo{
		Name:        request.WorldName,
		Description: request.Description,
		Background:  request.Background,
		Tags:        matchingTags,
		ShowHome:    request.ShowHome,
		WorldHeader: request.WorldHeader,
		ConfigData:  string(translatedJSON),
	}
	var newWorldInfo *models.WorldInfo
	if newWorldInfo, err = models.CreateWorldInfo(session, worldInfo); err != nil {
		session.Rollback()
		ctx.JSON(http.StatusOK, gin.H{"code": e.ErrorDatabase, "data": nil, "message": "创建业务经理考核系统世界出错"})
		return
	}

	if err := session.Commit(); err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": e.InternalError, "data": nil, "message": "事务提交失败"})
		return
	}

	ctx.JSON(http.StatusOK, gin.H{"code": e.SUCCESS, "data": gin.H{"newWorldInfo": newWorldInfo}, "message": "创建业务经理考核系统世界推演成功"})

}

//创建世界信息
func CreateWorldInfo(ctx *gin.Context) {
	/*
	   判断用户是否登录
	*/
	userID, isLogin := service.IsUserLoggedIn(ctx)
	if !isLogin {
		//userID = 1
		log.Println("用户未登录")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户未登录"})
		return
	}
	//判断该用户是否拥有该数字人,并获取用户的权限等级值
	level, err := models.GetUserLevel(userID)
	if err != nil {
		log.Println("修改数字人时获取用户权限失败")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "更新时获取数字人信息时，获取用户权限失败!"})
		return
	}
	if level > 0 {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "对不起,当前用户无权限创建世界信息"})
		return
	}

	worldName := ctx.PostForm("worldName")
	description := ctx.PostForm("description")
	background := ctx.PostForm("background")
	tags := ctx.PostForm("tags")
	tagsArr := []string{}
	// 分割字符串，得到单独的数值字符串
	if tags != "" {
		tagsSplit := strings.Split(tags, ",")
		for _, tagStr := range tagsSplit {
			// 将转换后的数值添加到数组
			tagsArr = append(tagsArr, tagStr)
		}
	}

	showHome := ctx.PostForm("showHome")       //是否主页显示
	worldHeader := ctx.PostForm("worldHeader") //世界副标题
	//开启事务
	session := database.Engine.NewSession()
	defer session.Close() //延迟关闭session
	err1 := session.Begin()
	if err1 != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "开启事务失败!"})
		fmt.Println("开启事务失败")
		return
	}

	worldInfo := &models.WorldInfo{
		Name:        worldName,
		Description: description,
		Background:  background,
		Tags:        tagsArr,
		ShowHome:    showHome,
		WorldHeader: worldHeader,
		Creator:     userID,
	}
	_, err = models.AddWorldInfo(session, worldInfo)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "创建世界信息出错"})
		return
	}
	//提交事务
	err = session.Commit()
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "创建世界信息出错"})
		return
	}
	ctx.JSON(http.StatusOK, gin.H{
		"code":    1,
		"message": "创建世界信息成功",
	})

}

//更新业务经理考核系统面板的参数
func EditBusinessManagerAssessmentSystem(ctx *gin.Context) {
	/*
	   判断用户是否登录
	*/
	userID, isLogin := service.IsUserLoggedIn(ctx)
	if !isLogin {
		//userID = 1
		log.Println("用户未登录")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户未登录"})
		return
	}
	//判断该用户是否拥有该数字人,并获取用户的权限等级值
	level, err := models.GetUserLevel(userID)
	if err != nil {
		log.Println("更新业务经理考核系统面板信息时，获取用户权限失败")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "更新业务经理考核系统面板信息时，获取用户权限失败!"})
		return
	}
	if level > 9 {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "更新业务经理考核系统面板信息时，用户权限不足"})
		return
	}

	worldId := ctx.PostForm("worldId")

	//digital_PersonId = "4"
	/**
	  转换数字人Id为int类型, 方便后面数字人信息从数据库中查询获取
	*/
	world_id, err := strconv.ParseInt(worldId, 10, 64)
	if err != nil {
		fmt.Println("世界id类型转换失败:", err.Error())
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "世界id类型转换失败!"})
		return
	}
	configData := ctx.PostForm("configData") //配置信息 json字符串
	if configData == "" {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "业务经理考核系统配置信息不能为空."})
		fmt.Println("业务经理考核系统配置信息不能为空")
		return
	}

	//开启事务
	session := database.Engine.NewSession()
	defer session.Close() //延迟关闭session
	err1 := session.Begin()
	if err1 != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "开启事务失败!"})
		fmt.Println("开启事务失败")
		return
	}
	worldInfo, err := models.GetWorld(session, world_id)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询世界信息出错!"})
		fmt.Println("查询世界信息出错")
		return
	}
	if worldInfo == nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "未查询到世界相关信息!"})
		fmt.Println("未查询到世界相关信息")
		return
	}

	/*	var panel models.AssessmentCustomizationPanel
		if err := ctx.BindJSON(&panel); err != nil {
			ctx.JSON(http.StatusOK, gin.H{"error": err.Error()})
			return
		}

		configDataBytes, err := json.Marshal(panel)
		if err != nil {
			ctx.JSON(http.StatusOK, gin.H{
				"code":    0,
				"message": "无法解析配置数据",
			})
			return
		}

		worldInfo.ConfigData = string(configDataBytes)
	*/
	//世界配置信息
	worldInfo.ConfigData = configData
	//修改世界信息
	err = models.UpdateWorld(session, worldInfo)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "更新业务经理考核系统操作面板信息失败"})
		return
	}

	//提交事务
	err = session.Commit()
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "更新业务经理考核系统操作面板信息失败"})
		return
	}

	ctx.JSON(http.StatusOK, gin.H{
		"code":    1,
		"message": "更新业务经理考核面板信息成功",
	})

}

//查询业务经理考核系统面板参数接口
func QueryBusinessManagerAssessmentSystemConfigData(ctx *gin.Context) {
	/*
	   判断用户是否登录
	*/
	_, isLogin := service.IsUserLoggedIn(ctx)
	if !isLogin {
		//userID = 1
		log.Println("用户未登录")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户未登录"})
		return
	}
	worldName := ctx.PostForm("worldName")
	tags := ctx.PostForm("tags")
	tagsArr := []string{}
	// 分割字符串，得到单独的数值字符串
	if tags != "" {
		tagsSplit := strings.Split(tags, ",")
		for _, tagStr := range tagsSplit {
			// 将转换后的数值添加到数组
			tagsArr = append(tagsArr, tagStr)
		}
	}
	world, _, err := models.FindWorldsByTagAndName3(worldName, tagsArr)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询业务经理考核系统操作面板信息失败"})
		return
	}
	if world != nil {
		ctx.JSON(http.StatusOK, gin.H{
			"code":      1,
			"worldInfo": world,
		})
	} else {
		ctx.JSON(http.StatusOK, gin.H{
			"code":    0,
			"message": "未查到世界信息",
		})
	}

}

//查询最近一次的世界推演结果
func QueryWorldDeductionResultsByWorldAndUserLastTime(ctx *gin.Context) {
	/*
	   判断用户是否登录
	*/
	uid, isLogin := service.IsUserLoggedIn(ctx)
	if !isLogin {
		//userID = 1
		log.Println("用户未登录")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户未登录"})
		return
	}

	worldName := ctx.PostForm("worldName")

	// 服务商id获取
	var SP *models.ServiceProvider
	var err error
	ServiceProviderId := ctx.PostForm("AuthId")
	if ServiceProviderId == "" {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "服务商id不能为空"})
		return
	}
	if ServiceProviderId != "" {
		SP, err = models.GetServiceProviderById(ServiceProviderId)
		if err != nil {
			fmt.Println("根据服务商id查询出错:", err)
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据服务商id查询服务商出错"})
			return
		}
		if SP == nil {
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "非法的服务商"})
			return
		}
	}

	worldinfo, err := models.GetWorldInfoByName(worldName)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据世界名称查询世界信息出错"})
		return
	}

	if !ContainsStrArray(worldinfo.Tags, SP.AccessibleTags) {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "所查询的世界信息不包含服务商允许的世界标签"})
		return
	}

	lastTimeDeductionResult, err := models.GetWorldDeductionResultsByWorldNameAndUserLastTime(worldName, uid)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "获取最近一次的世界推演结果出错"})
		return
	}
	if lastTimeDeductionResult == nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "该用户不存在世界推演结局信息"})
		return
	}
	ctx.JSON(http.StatusOK, gin.H{
		"code":                    1,
		"lastTimeDeductionResult": lastTimeDeductionResult,
	})

}

//查询所有的世界推演结果
func QueryWorldDeductionResults(ctx *gin.Context) {
	/*
	   判断用户是否登录
	*/
	uid, isLogin := service.IsUserLoggedIn(ctx)
	if !isLogin {
		//userID = 1
		log.Println("用户未登录")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户未登录"})
		return
	}
	//worldName := ctx.PostForm("worldName")
	// 服务商id获取
	var SP *models.ServiceProvider
	var err error
	ServiceProviderId := ctx.PostForm("AuthId")
	if ServiceProviderId == "" {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "服务商id不能为空"})
		return
	}
	if ServiceProviderId != "" {
		SP, err = models.GetServiceProviderById(ServiceProviderId)
		if err != nil {
			fmt.Println("根据服务商id查询出错:", err)
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据服务商id查询服务商出错"})
			return
		}
		if SP == nil {
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "非法的服务商"})
			return
		}
	}

	/*	worldinfo, err := models.GetWorldInfoByName(worldName)
		if err != nil {
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据世界名称查询世界信息出错"})
			return
		}

		if !ContainsStrArray(worldinfo.Tags, SP.AccessibleTags) {
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "所查询的世界信息不包含服务商允许的世界标签"})
			return
		}*/

	worldDeductionResults, err := models.GetWorldDeductionResultsByWorldNameAndUserId(uid)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "获取最近一次的世界推演结果出错"})
		return
	}
	if len(worldDeductionResults) == 0 {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "该用户不存在世界推演结局信息"})
		return
	}
	ctx.JSON(http.StatusOK, gin.H{
		"code":                  1,
		"worldDeductionResults": worldDeductionResults,
	})

}

//查询用户与那些世界进行过聊天会话
func QueryUserToWorldIsExistConversation(ctx *gin.Context) {
	/*
	   判断用户是否登录
	*/
	uid, isLogin := service.IsUserLoggedIn(ctx)
	if !isLogin {
		log.Println("用户未登录")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户未登录"})
		return
	}
	worldName := ctx.PostForm("worldName")
	worldConversation, exist, err := models.GetWorldConversationByUidAndWorldName(uid, worldName)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询用户与世界名称，是否存在会话信息！"})
		return
	}

	if !exist {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "不存在当前用户与该世界的会话信息！"})
		return
	}

	ctx.JSON(http.StatusOK, gin.H{"code": 1, "message": "存在当前用户与该世界的会话信息", "worldConversation": worldConversation})

}

//查询业务经理考核相关的世界信息接口
func QueryBusinessManagerWorldInfo(ctx *gin.Context) {
	/*
	   判断用户是否登录
	*/
	_, isLogin := service.IsUserLoggedIn(ctx)
	if !isLogin {
		//userID = 1
		log.Println("用户未登录")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户未登录"})
		return
	}
	worldName := ctx.PostForm("worldName")
	tags := ctx.PostForm("tags")
	tagsArr := []string{}
	// 分割字符串，得到单独的数值字符串
	if tags != "" {
		tagsSplit := strings.Split(tags, ",")
		for _, tagStr := range tagsSplit {
			// 将转换后的数值添加到数组
			tagsArr = append(tagsArr, tagStr)
		}
	}
	worldinfo, err := models.FindWorlds2(worldName, tagsArr)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询世界信息信息失败"})
		return
	}
	if worldinfo != nil {
		ctx.JSON(http.StatusOK, gin.H{
			"code":      1,
			"worldInfo": worldinfo,
		})
	} else {
		ctx.JSON(http.StatusOK, gin.H{
			"code":    0,
			"message": "未查到世界信息",
		})
	}

}

// 定义查询业务经理考核系统世界信息的请求参数的结构体
type RequestParams struct {
	WorldName string `json:"worldName"`
	Tags      string `json:"tags"`
}

// 查询业务经理考核相关的世界信息接口2
func MiGuQueryBusinessManagerWorldInfo(ctx *gin.Context) {
	var params RequestParams

	// 从请求体解析 JSON 参数
	if err := ctx.BindJSON(&params); err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": e.ParamParseError, "data": nil, "message": "参数解析错误"})
		return
	}

	// 从请求头 Authorization 中提取令牌
	tokenString := ctx.GetHeader("Token")
	if tokenString == "" {
		ctx.JSON(http.StatusOK, gin.H{"code": e.UnauthorizedStatus, "data": nil, "message": "请求头中无token,或未授权的token访问"})
		return
	}

	// 解析并验证 JWT 令牌
	isValid, err := service.IsValidMiGuToken(tokenString)
	if err != nil || !isValid {
		ctx.JSON(http.StatusOK, gin.H{"code": e.InvalidToken, "data": nil, "message": "无效或已过期的令牌"})
		return
	}

	tagsArr := []string{}
	// 分割字符串，得到单独的标签数组
	if params.Tags != "" {
		tagsSplit := strings.Split(params.Tags, ",")
		tagsArr = append(tagsArr, tagsSplit...)
	}

	worldInfo, err := models.FindWorlds2(params.WorldName, tagsArr)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": e.ErrorDatabase, "data": nil, "message": "查询世界信息失败"})
		return
	}
	/*
	  转换世界配置信息中的英文字段
	*/
	var data map[string]interface{}

	for i, world_info := range worldInfo {
		if err := json.Unmarshal([]byte(world_info.ConfigData), &data); err != nil {
			ctx.JSON(http.StatusOK, gin.H{"code": e.ParamParseError, "data": nil, "message": "解析配置数据出错"})
			return
		}
		// 转换键名
		translatedData := TranslateKeysChineseToEnglish(data)
		translatedJSON, err := json.MarshalIndent(translatedData, "", "    ")
		if err != nil {
			fmt.Println("Error marshalling JSON:", err)
			ctx.JSON(http.StatusOK, gin.H{"code": e.ParamParseError, "data": nil, "message": "解析配置数据出错"})
			return
		}
		worldInfo[i].ConfigData = string(translatedJSON)
		fmt.Println(" configData translatedJSON ==> ", string(translatedJSON))
	}

	if worldInfo != nil {
		ctx.JSON(http.StatusOK, gin.H{
			"code":    e.SUCCESS,
			"data":    gin.H{"worldsInfo": worldInfo},
			"message": "查询世界信息成功",
		})
	} else {
		ctx.JSON(http.StatusOK, gin.H{
			"code":    e.NotFound,
			"data":    nil,
			"message": "未查到世界信息",
		})
	}
}

//查询用户与那些世界进行过聊天会话
func QueryUserIsWorldConversation(ctx *gin.Context) {
	/*
	   判断用户是否登录
	*/
	uid, isLogin := service.IsUserLoggedIn(ctx)
	if !isLogin {
		log.Println("用户未登录")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户未登录"})
		return
	}
	user, err1 := models.GetUserByID(uid)
	if err1 != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询用户已聊天的世界会话，获取用户名称失败！"})
		return
	}
	//fmt.Println(user.Username)
	worldName := ctx.PostForm("worldName")
	worlds, err := models.GetWorldConversationsByUser(uid, worldName)

	//fmt.Println("根据用户ID查询对应的世界ID和名字: ", worlds)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询用户已聊天的世界会话，查询失败！"})
		return
	}
	if len(worlds) == 0 {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "未查询到该用户与世界的会话记录"})
		return
	}

	info := models.UserWorldInfo{
		UserID:   uid,
		UserName: user.Username,
		Worlds:   worlds,
	}

	fmt.Println(" UserConversationWorldInfo 获取用户聊天过的世界个数 : ", len(info.Worlds))

	ctx.JSON(http.StatusOK, gin.H{"code": 1, "message": info})

}

// containsAny 检查字符串数组 slice1 是否包含字符串数组 slice2 中的任何一个元素
func ContainsStrArray(slice1, slice2 []string) bool {
	for _, item1 := range slice1 {
		for _, item2 := range slice2 {
			if item1 == item2 {
				return true
			}
		}
	}
	return false
}

// ContainsString 检查字符串数组是否包含一个特定的字符串
func ContainsString(slice []string, item string) bool {
	for _, elem := range slice {
		if elem == item {
			return true
		}
	}
	return false
}

//重置世界的神经网络记忆文件
func MiGuWorldResetNeuralFile(c *gin.Context) {

	startTime := time.Now()                                                                               // 记录函数开始时间
	fmt.Println(config.ColorBlue, "请求收到时间: ", startTime.Format("2006-01-02 15:04:05"), config.ColorReset) // 格式化输出
	fmt.Println(config.ColorYellow, "收到请求时间戳: ", startTime.Unix(), config.ColorReset)                     // 输出Unix时间戳

	// 从请求头 Authorization 中提取令牌
	tokenString := c.GetHeader("Token")
	if tokenString != "" {
		// 解析并验证 JWT 令牌
		isValid, err := service.IsValidMiGuToken(tokenString)
		if err != nil || !isValid {
			c.JSON(http.StatusOK, gin.H{"code": e.InvalidToken, "data": nil, "message": "无效或已过期的令牌"})
			return
		}
	} else {
		c.JSON(http.StatusOK, gin.H{"code": e.UnauthorizedStatus, "data": nil, "message": "请求头中无token,或未授权的token访问"})
		return
	}
	//构造重置意识流的请求参数结构体
	type Request struct {
		Uid     string `json:"uid"`
		WorldId string `json:"worldId"`
	}

	var req Request
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusOK, gin.H{"code": e.ParamParseError, "data": nil, "message": "请求参数错误: " + err.Error()})
		return
	}
	if req.Uid == "" || req.WorldId == "" {
		c.JSON(http.StatusOK, gin.H{"code": e.EmptyParamsError, "data": nil, "message": "必需的参数 uid 或 worldId 缺失"})
		return
	}

	uid, err := strconv.ParseInt(req.Uid, 10, 64)
	if err != nil {
		fmt.Println("用户ID类型转换失败:", err.Error())
		c.JSON(http.StatusOK, gin.H{"code": e.InvalidParams, "data": nil, "message": "用户ID类型转换出错"})
		return
	}

	wid, err := strconv.ParseInt(req.WorldId, 10, 64)
	if err != nil {
		fmt.Println("世界ID类型转换失败:", err.Error())
		c.JSON(http.StatusOK, gin.H{"code": e.InvalidParams, "data": nil, "message": "世界ID类型转换出错"})
		return
	}

	//BgInfo := c.PostForm("BgInfo")
	//user_info := c.PostForm("userInfo")

	var world *models.WorldInfo
	var userInfo string

	/*
	  根据用户id和数字人id，查询会话
	*/

	//开启事务
	session := database.Engine.NewSession()
	defer session.Close() //延迟关闭session
	err = session.Begin()
	if err != nil {
		c.JSON(http.StatusOK, gin.H{"code": e.InternalError, "data": nil, "message": "开启事务失败!"})
		fmt.Println("开启事务失败")
		return
	}
	world, _, err = models.GetWorldInfoById_Tx(session, wid)
	if err != nil {
		log.Println("根据世界名称，查询世界信息失败")
		c.JSON(http.StatusOK, gin.H{"code": e.ErrorDatabase, "data": nil, "message": "根据世界名称，查询世界信息失败"})
		return
	}
	if world == nil {
		log.Println("世界信息不存在")
		c.JSON(http.StatusOK, gin.H{"code": e.NotFound, "data": nil, "message": "世界信息不存在"})
		return
	}
	fmt.Println(config.ColorPurple, "world_name:", world.Name, config.ColorReset)
	// 世界背景信息、世界名称赋值，下面需要使用
	worldName := world.Name
	BgInfo := world.Background

	// 创建 Wrapper 实例并将 JSON 字符串封装

	wrapper := service.Wrapper{ConfigData: make(map[string]interface{})}
	// 将 JSON 字符串解析为 map[string]interface{}
	err = json.Unmarshal([]byte(world.ConfigData), &wrapper.ConfigData)
	if err != nil {
		log.Printf("Error parsing JSON: %v", err)
		c.JSON(http.StatusOK, gin.H{"code": e.ParamParseError, "data": nil, "message": "json序列化错误"})
		return
	}

	// 打印解析后的数据
	//fmt.Printf("Wrapper ConfigData: %+v\n", wrapper.ConfigData)

	// 序列化 Wrapper 实例以生成所需的最终 JSON 输出
	finalJSON, err := json.Marshal(wrapper)
	if err != nil {
		fmt.Println("Error marshaling final JSON: ", err)
		c.JSON(http.StatusOK, gin.H{"code": e.ParamParseError, "data": nil, "message": "业务经理考核系统配置信息json解析失败"})
		return
	}

	fmt.Println("ConfigData ===>", string(finalJSON))
	//userInfo = string(finalJSON)
	userInfo = string(finalJSON)

	/*worldConversation, _, err := models.GetWorldConversationByUidAndWorldName_Tx(session, uid, worldName)
	if worldConversation != nil {
		fmt.Println("worldConversation 世界Id：", worldConversation.WorldId, "世界名称：", worldConversation.WorldName)
	}*/

	worldConversation, _, err := models.GetWorldConversationByUidAndWorldId_Tx(session, uid, wid)
	if err != nil {
		c.JSON(http.StatusOK, gin.H{"code": e.ErrorDatabase, "data": nil, "message": "查询world会话记录失败！"})
		return
	}
	if worldConversation == nil {
		fmt.Println(config.ColorGreen, "重置记忆文件时，查询会话对象失败!", config.ColorReset)
		c.JSON(http.StatusOK, gin.H{"code": e.NotFound, "data": nil, "message": "重置记忆文件失败，未查询到对应的会话!"})
		return
	}
	if worldConversation != nil {
		fmt.Println("worldConversation 世界Id：", worldConversation.WorldId, "世界名称：", worldConversation.WorldName)
	}

	SoulUrl := config.Conf.SoulUrl + "/world/neural"

	// 封装请求参数结构体
	request := service.SoulNeuralRequest{
		Auth:    config.Conf.SoulAuth,
		Type:    2, //0下载（离魂） 1上传（还魂） 2实例化（超度）
		ISLIUid: worldConversation.IsLiuId,
	}

	if service.WorldManager.Client[utils.Strval(uid)] == nil {
		// 定义响应内容
		response := gin.H{
			"code":    e.NotFound, // 假设这是一个预先定义的错误码
			"data":    nil,
			"content": "你重置的世界意识流，用户socket客户端不存在",
		}

		// 打印响应内容到控制台
		fmt.Println(config.ColorRed, " response ==> ", response, config.ColorReset)

		// 返回JSON响应
		c.JSON(http.StatusOK, response)
		//c.JSON(http.StatusOK, gin.H{"code": e.NotFound, "data": nil, "content": "你重置的世界意识流，用户socket客户端不存在"})
		return
	}
	preSoulNeuralTime := time.Now() // 记录 SoulNeuralFileReset 调用模型服务端接口执行前的时间

	err, res_code := service.SoulNeuralFileReset(SoulUrl, request)
	if err != nil {
		log.Println("重置数字人神经网络记忆文件时失败!")
		c.JSON(http.StatusOK, gin.H{"code": e.InternalError, "data": nil, "message": "重置数字人神经网络记忆文件时失败!"})
		return
	}
	soulNeuralDuration := time.Since(preSoulNeuralTime) // 计算 SoulNeuralFileReset 函数执行时间
	totalDuration := time.Since(startTime)              // 计算整个函数执行的总时间

	// 打印时间统计
	log.Printf("调用接口 SoulNeuralFileReset 执行前耗费时间: %s\n", soulNeuralDuration.String())
	log.Printf("调用接口 SoulNeuralFileReset 耗费时间: %s\n", soulNeuralDuration.String())
	log.Printf("SoulNeuralFileReset 神经网络记忆文件重置接口耗费总时间: %s\n", totalDuration.String())

	//根据世界id查询世界对象是否存在
	wordInfo, _, err := models.GetWorldInfoById_Tx(session, wid)
	if err != nil {
		c.JSON(http.StatusOK, gin.H{"code": e.ErrorDatabase, "data": nil, "message": "根据世界名称查询世界对象出错!"})
		return
	}
	if wordInfo == nil {
		c.JSON(http.StatusOK, gin.H{"code": e.NotFound, "data": nil, "message": "重置的世界意识流时，未查询到世界信息!"})
		log.Println(config.ColorRed, "重置的世界意识流时，未查询到世界信息!", config.ColorReset)
		return
	}

	//响应码为1，记忆文件重置成功
	if res_code == 1 {
		processStart := time.Now() // 记录分支开始时间

		// MongoDB插入一条空的历史聊天记录信息
		chatRecordArray := database.WorldChatRecordArray{
			ConversationId: utils.Strval(uid) + "_" + utils.Strval(worldConversation.WorldId),
			Timestamp:      time.Now().Unix(),
			//存个空的聊天记录数组
			Records: []database.WorldChatRecord{},
		}
		err = database.SaveWorldChatRecord(chatRecordArray)
		if err != nil {
			log.Println("MongoDB数据库插入一条数据，err: ", err)
			c.JSON(http.StatusOK, gin.H{"code": e.ErrorDatabase, "data": nil, "message": "重置世界记忆文件,插入数据失败!"})
			return
		}
		fmt.Println(config.ColorBlue, "SoulNeural reset after WorldChatRecordArray  saved successfully", config.ColorReset)

		/*
		   需要重新NewAI接口世界获取意识流ID,然后修改已存在会话的意识流id
		*/

		worldResp, world_conversation, err := service.MiGuCreateVirtualWorldHandler(uid, wid, BgInfo, userInfo)
		if err != nil {
			c.JSON(http.StatusOK, gin.H{"code": e.ErrorDatabase, "data": nil, "content": "创建世界失败！"})
			return
		}
		fmt.Println(config.ColorPurple, "重置的世界意识流，客户端: ===> ", service.WorldManager.Client[utils.Strval(uid)], config.ColorReset)

		service.WorldManager.Client[utils.Strval(uid)].WorldConversations = world_conversation

		/* 创建响应体 */
		HSReplyMsg := service.WorldSoulReplyMsg{
			Code:      worldResp.Code,
			WObj:      worldResp.WObj,
			ISLIU:     worldResp.ISLIU,
			WorldName: worldName,
			//加上了意识流ID和消息状态类型
			IsLIUId:           &worldResp.ISLIUid,
			MessageStatusType: worldResp.MessageStatusType,
		}

		msg, _ := json.Marshal(HSReplyMsg)
		if service.WorldManager.Client[utils.Strval(uid)] == nil {
			c.JSON(http.StatusOK, gin.H{"code": e.NotFound, "data": nil, "content": "你重置的世界意识流，客户端不存在"})
			return
		}
		var write_err error
		if service.WorldManager.Client[utils.Strval(uid)] != nil {
			write_err = service.WorldManager.Client[utils.Strval(uid)].Socket.WriteMessage(websocket.TextMessage, msg)
		}

		if write_err != nil {
			log.Println("返回意识流给客户端时出错! ")
			service.WorldDestroyWs(service.WorldManager.Client[utils.Strval(uid)])
			return
		}
		/* 保存世界的独白到数据库 */
		senderType := "world"
		// 拼接会话Id
		conversation_Id := utils.Strval(service.WorldManager.Client[utils.Strval(uid)].WorldConversations.Uid) + "_" + utils.Strval(service.WorldManager.Client[utils.Strval(uid)].WorldConversations.WorldId)
		_, chatDB_err := database.SaveWorldChatRecordMongoDB(conversation_Id, service.WorldManager.Client[utils.Strval(uid)].WorldConversations.WorldId, service.WorldManager.Client[utils.Strval(uid)].WorldConversations.WorldName, worldResp.ISLIU, worldResp.WObj, senderType)
		// 错误处理
		if chatDB_err != nil {
			log.Println(config.ColorRed, "保存数字人聊天记录至数据库出错!", config.ColorReset)

			errorMsg := service.ErrorMessage{
				Code:    -1,
				Message: "保存数字人聊天记录至数据库出错！",
			}
			errmsg, _ := json.Marshal(errorMsg)
			_ = service.WorldManager.Client[utils.Strval(uid)].Socket.WriteMessage(websocket.TextMessage, errmsg)

			return
		}
		//提交事务
		err = session.Commit()
		if err != nil {
			c.JSON(http.StatusOK, gin.H{"code": e.ErrorDatabase, "data": nil, "message": "创建数字人失败! "})
			return
		}
		processDuration := time.Since(processStart) // 计算当前分支的执行时间
		totalDuration2 := time.Since(startTime)     // 计算整个函数的执行时间

		// 打印每个阶段的执行时间
		log.Printf("重置记忆文件成功响应 res_code == 1 耗费的时间: %s\n", processDuration.String())
		log.Printf("整个函数耗费时间: %s\n", totalDuration2.String())

		c.JSON(http.StatusOK, gin.H{"code": e.SUCCESS, "data": gin.H{"newIsLiuId": world_conversation.IsLiuId}, "message": "重置世界记忆文件成功!"})
	}
	//重置数字人神经网络记忆文件失败
	if res_code == -1 {
		c.JSON(http.StatusOK, gin.H{"code": e.InternalError, "data": nil, "message": "重置数字人神经网络记忆文件失败!"})
	}

}
