package controllers

import (
	"WorldEpcho/src/config"
	database "WorldEpcho/src/datasource"
	"WorldEpcho/src/models"
	"WorldEpcho/src/service"
	"WorldEpcho/src/utils"
	"fmt"
	"github.com/gin-gonic/gin"
	"log"
	"net/http"
	"strconv"
)

//创建应用组群接口
func CreateApplicationGroup(ctx *gin.Context) {
	/*
	   判断用户是否登录
	*/
	uid, isLogin := service.IsUserLoggedIn(ctx)
	if !isLogin {
		log.Println("用户未登录")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户未登录"})
		return
	}
	/*
	  创建应用群组结构体
	*/
	appId := ctx.PostForm("app_id")
	app_id, err := strconv.ParseInt(appId, 10, 64)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "Invalid app Id"})
		return
	}
	groupName := ctx.PostForm("group_name")
	visibility := ctx.PostForm("visibility")
	// 生成组群号
	newGroupNo := utils.GenerateInviteCode(uid)
	GroupMemIds := []int64{uid} // 创建一个包含uid的数组

	newGroup := &models.AppGroup{
		No:         newGroupNo,
		AppId:      app_id,
		CreatorId:  uid,
		GroupName:  groupName,
		GroupMem:   GroupMemIds,
		Visibility: visibility,
	}
	// 在数据库中创建应用
	// 调用创建函数
	err = models.CreateAppGroup(newGroup)
	if err != nil {
		fmt.Printf("Error creating app group: %s\n", err)
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "创建应用群组失败!"})
	} else {
		fmt.Printf("App group created successfully: %#v\n", newGroup)
		ctx.JSON(http.StatusOK, gin.H{"code": 1, "message": "创建应用群组成功!"})
	}

}

//添加用户到应用组群
func AddUserToAppGroup(ctx *gin.Context) {
	/*
	   判断用户是否登录
	*/
	_, isLogin := service.IsUserLoggedIn(ctx)
	if !isLogin {
		log.Println("用户未登录")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户未登录"})
		return
	}
	//添加用户到应用组群
	groupId := ctx.PostForm("No")
	userId := ctx.PostForm("user_id")
	user_id, err := strconv.ParseInt(userId, 10, 64)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户id转换失败"})
		return
	}

	bol, _, err := models.GetUserExistByID(user_id)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据用户id查询用户失败"})
		return
	}
	if bol == false {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "添加的用户不存在"})
		return
	}
	err = models.AppGroupInviteUser(groupId, user_id)
	if err != nil {
		if err.Error() == "组群不存在" {
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "你添加的组群不存在"})
			return
		} else if err.Error() == "用户已是组群成员" {
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户已是组群成员"})
			return
		} else {
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "添加用户到应用组群失败"})
			return
		}
	} else {
		ctx.JSON(http.StatusOK, gin.H{"code": 1, "message": "添加用户到应用组群成功"})
	}

}

//根据应用组成员id获取可用的应用
func QueryAppGroupsByMemberID(ctx *gin.Context) {
	/*
	   判断用户是否登录
	*/
	_, isLogin := service.IsUserLoggedIn(ctx)
	if !isLogin {
		log.Println("用户未登录")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户未登录"})
		return
	}
	idStr := ctx.PostForm("group_mem")
	groupMem_id, err := strconv.ParseInt(idStr, 10, 64)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "Invalid participator_id"})
		return
	}
	appGroups, err := models.FindAppGroupsByMemberID(groupMem_id)
	if err != nil {
		fmt.Println("根据应用组成员id获取可用应用失败")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据应用组成员id获取可用应用失败"})
		return
	}
	ctx.JSON(http.StatusOK, gin.H{"code": 1, "message": appGroups})
}

//根据组群id和成员id，将该用户从组群中移除
func DeleteMemberFromGroup(ctx *gin.Context) {
	/*
	   判断用户是否登录
	*/
	uid, isLogin := service.IsUserLoggedIn(ctx)
	if !isLogin {
		log.Println("用户未登录")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户未登录"})
		return
	}
	groupNo := ctx.PostForm("No")
	idStr := ctx.PostForm("group_mem")
	groupMem_id, err := strconv.ParseInt(idStr, 10, 64)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "Invalid participator_id"})
		return
	}
	/*
	  根据成员id和组群id查询用户的组内权限值
	*/

	//开启事务
	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
	}

	UserPermission, _, err := models.GetUserPermission(session, groupNo, uid)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询用户组群权限失败!"})
		fmt.Println("查询用户组群权限失败")
		return
	}
	if uid == groupMem_id || UserPermission == 0 {
		//数据库操作
		err = models.RemoveMemberFromGroup(groupNo, groupMem_id)
		if err != nil {
			if err.Error() == "该用户不存在于组群中" {
				ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "该用户不存在于组群中"})
				return
			} else {
				ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据应用群号和成员id移除用户失败"})
				return
			}
		} else {
			//提交事务
			err = session.Commit()
			if err != nil {
				ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询用户与心理咨询的聊天记录失败"})
				return
			} else {
				ctx.JSON(http.StatusOK, gin.H{"code": 1, "message": "根据应用群号和成员id移除用户成功!"})
				fmt.Println(config.ColorGreen, "根据应用群号和成员id移除用户成功", config.ColorReset)
			}

		}
	}

}

// GetUserAppDataWithPermission 根据用户权限获取组成员的用户应用数据
func GetUserAppDataWithPermission(ctx *gin.Context) {
	/*
	   判断用户是否登录
	*/
	uid, isLogin := service.IsUserLoggedIn(ctx)
	if !isLogin {
		log.Println("用户未登录")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户未登录"})
		return
	}
	groupNo := ctx.PostForm("No")
	idStr := ctx.PostForm("group_mem")
	groupMem_id, err := strconv.ParseInt(idStr, 10, 64)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "Invalid participator_id"})
		return
	}
	dp_Id := ctx.PostForm("DpId")

	/*
	  根据成员id和组群id查询用户的组内权限值
	*/
	//开启事务
	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
	}

	UserPermission, _, err := models.GetUserPermission(session, groupNo, uid)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询用户组群权限失败!"})
		fmt.Println("查询用户组群权限失败")
		return
	}
	_, appGroup, err := models.GetAppGroupByID(session, groupNo)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询组群失败!"})
		fmt.Println("查询组群失败")
		return
	}

	appId := utils.Strval(appGroup.AppId)

	if appGroup.AppId == 10 && ctx.PostForm("appId") != "" {
		appId = ctx.PostForm("appId")
	}
	mergeAll := ctx.PostForm("mergeAll")
	var merge_all bool
	if mergeAll == "" || mergeAll == "false" {
		merge_all = false
	}
	if mergeAll == "true" {
		merge_all = true
	}

	if uid == groupMem_id || UserPermission == 0 {

		chatRecordArray, err := database.GetChatHistoryLatest(utils.Strval(groupMem_id), dp_Id, appId, merge_all)
		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
			}
			return

		} else {
			//提交事务
			err = session.Commit()
			if err != nil {
				ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询用户与心理咨询的聊天记录失败"})
				return
			} else {
				ctx.JSON(http.StatusOK, gin.H{"code": 1, "message": "查询成功!", "chatRecordInfo": chatRecordArray})
				fmt.Println(config.ColorGreen, "查询用户与心理咨询的聊天记录为: ", chatRecordArray, config.ColorReset)
			}

		}
		//
	}

}

// 亲子咨询接口
func ParentChildConsult(ctx *gin.Context) {
	/*
	   判断用户是否登录
	*/
	uid, isLogin := service.IsUserLoggedIn(ctx)
	if !isLogin {
		log.Println("用户未登录")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户未登录"})
		return
	}
	//groupName := ctx.PostForm("groupName")
	app_id := ctx.PostForm("app_id")
	appName := ctx.PostForm("appName")

	// 传父母
	tester := ctx.PostForm("tester")
	appId, err := strconv.ParseInt(app_id, 10, 64)
	if err != nil {
		fmt.Println("应用id类型转换失败")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "应用id类型转换失败"})
		return
	}

	//开启事务
	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
	}
	/* 根据应用id和组成员的用户ID，且用户权限为0的条件查询应用组群*/
	permission := 0
	appGroup, Group_exist, err := models.GetAppGroupsByAppIDAndContainMemberUserID(10, uid, permission)
	if err != nil {
		fmt.Println("根据用户id和应用id查询组群出错")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据用户id和应用id查询组群出错"})
		return
	}
	if !Group_exist {
		ctx.JSON(http.StatusOK, gin.H{"code": 2, "message": "你未绑定子女账号,亲子组群不存在"})
		return
	}

	// 查询父母详情信息
	UserInfo, err := models.GetUserInfo(uid)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据用户id查询应用失败"})
		return
	}

	userIds, err := models.GetMembersWithUserPermission9(session, appGroup)
	if err != nil {
		log.Println("根据组群名称查询组成员权限为9的用户出错")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据组群名称查询组成员权限为9的用户出错"})
		return
	}
	fmt.Println("userIds ==> : ", userIds)
	if len(userIds) == 0 {
		log.Println("不存在群组成员权限为9的用户")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "不存在群组成员权限为9的用户"})
		return
	}
	childId := ctx.PostForm("childId")
	var child_Id int64
	if childId != "" {
		child_Id, err = strconv.ParseInt(childId, 10, 64)
		if err != nil {
			fmt.Println("孩子id类型转换失败")
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "孩子id类型转换失败"})
			return
		}
	} else {
		child_Id = userIds[0]
	}

	//判断孩子的Id是否包含在父母的孩子成员中
	if !utils.ContainsUserID(userIds, child_Id) {
		log.Println("孩子不是父母的亲子账号")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "孩子不是父母的亲子账号"})
		return
	}
	// 查询子女关于父母EMBU测量的。最近一次评估结果
	//summary, _, err := models.QueryLatestSummary(10, userIds[0])

	summary, _, err := models.QueryLatestSummary(10, child_Id)
	if err != nil {
		log.Println("根据组群名称查询组成员权限为9的用户出错")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据组群名称查询组成员权限为9的用户出错"})
		return
	}
	fmt.Println(" summary ===> ", summary)
	if summary == nil {
		log.Println(config.ColorYellow, "该用户子女无EMBU测量记录", config.ColorReset)
		ctx.JSON(http.StatusOK, gin.H{"code": 2, "message": "该用户子女无EMBU测量记录"})
		return
	}
	/*
	  根据应用id和应用名称查询应用配置信息
	*/
	configData, err := models.GetConfigDataByAppInfo(10, "EMBU量表")
	if err != nil {
		fmt.Printf("根据应用id和应用名称查询应用的配置信息失败")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据应用id和应用名称查询应用的配置信息失败"})
		return
	}
	//fmt.Println("configData: ", configData)
	//访问map中的DpId键的值
	DpId, ok := configData["DpId"]
	if !ok {
		fmt.Println("Key 为DpId的键在map中未发现")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "Key 为DpId的键在map中未发现"})
		return
	}
	DpIdStr, ok := DpId.(string)
	if !ok {
		fmt.Println("Dp_id is not a string")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "Dp_id不是一个字符串"})
		return
	}
	dp_id, err := strconv.ParseInt(DpIdStr, 10, 64)
	if err != nil {
		fmt.Println("从configData中获取的数字人id类型转换失败")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "数字人id类型转换失败"})
		return
	}

	fmt.Println("UserInfo: ", UserInfo)
	// 定义MHT量表单次录入用户请求的uuid
	var EMBU_UUID = utils.GenerateUUID()

	//缓存添加应用名称和应用id
	service.AppCache[EMBU_UUID] = &service.CacheApp{
		AppName:  appName,
		AppID:    appId,
		DpId:     dp_id,
		UUID_Val: EMBU_UUID,
	}

	//从configData中获取用户信息模板
	if tester == "Father" {
		FatherInfoTemplate, ok := configData["FatherInfoTemplate"]
		if !ok {
			fmt.Println("Key 'FatherInfoTemplate' not found in the map")
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "Key 'FatherInfoTemplate' not found in the map"})
			return
		}
		// 断言 userInfoTemplate 为字符串类型
		FatherInfoTemplateStr, ok := FatherInfoTemplate.(string)
		if !ok {
			fmt.Println("userInfoTemplate is not a string")
			return
		}
		// 打印 userInfoTemplate 的值
		fmt.Println("userInfoTemplate: ", FatherInfoTemplateStr)
		/* */
		values := []string{
			UserInfo.UserName,
			summary.FatherEvaluateResult["Emotional"],
			summary.FatherEvaluateResult["OverProtection"],
			summary.FatherEvaluateResult["Overreach"],
			summary.FatherEvaluateResult["Preferred"],
			summary.FatherEvaluateResult["Punishment"],
			summary.FatherEvaluateResult["RejectDeny"],
		}
		/*
		   填充用户信息模板字符串中的占位符
		*/
		FatherInfoTemplateStr, err := utils.FillUserInfoTemplate(FatherInfoTemplateStr, values)
		if err != nil {
			fmt.Println(" 填充用户信息模板字符串失败!")
			return
		}
		fmt.Println(" FatherInfoTemplateStr ==>  ", FatherInfoTemplateStr)
		//将用户信息模板字符串保存至缓存中
		service.AppCache[EMBU_UUID].UserInfoTemplate = FatherInfoTemplateStr
		//提交事务
		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":   "获取EMBU量表测评数据成功!",
			"UserId":    uid,
			"EMBU_UUID": EMBU_UUID,
			"DpId":      dp_id,
		})
	}

	if tester == "Mother" {
		MotherInfoTemplate, ok := configData["MotherInfoTemplate"]
		if !ok {
			fmt.Println("Key 'MotherInfoTemplate' not found in the map")
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "Key 'MotherInfoTemplate' not found in the map"})
			return
		}
		// 断言 userInfoTemplate 为字符串类型
		MotherInfoTemplateStr, ok := MotherInfoTemplate.(string)
		if !ok {
			fmt.Println("userInfoTemplate is not a string")
			return
		}
		// 打印 userInfoTemplate 的值
		fmt.Println("userInfoTemplate: ", MotherInfoTemplateStr)
		/* */
		values := []string{
			UserInfo.UserName,
			summary.MotherEvaluateResult["Emotional"],
			summary.FatherEvaluateResult["Overreach"],
			summary.FatherEvaluateResult["Preferred"],
			summary.FatherEvaluateResult["Punishment"],
			summary.FatherEvaluateResult["RejectDeny"],
		}
		/*
		   填充用户信息模板字符串中的占位符
		*/
		MotherInfoTemplateStr, err := utils.FillUserInfoTemplate(MotherInfoTemplateStr, values)
		if err != nil {
			fmt.Println(" 填充用户信息模板字符串失败!")
			return
		}
		fmt.Println(" MotherInfoTemplateStr ==>  ", MotherInfoTemplateStr)
		//将用户信息模板字符串保存至缓存中
		service.AppCache[EMBU_UUID].UserInfoTemplate = MotherInfoTemplateStr

		//提交事务
		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":   "获取EMBU量表测评数据成功!",
			"UserId":    uid,
			"EMBU_UUID": EMBU_UUID,
			"DpId":      dp_id,
		})
	}

}

// 获取子女EMBU结果接口
func QueryChildEMBUEvaluateResult(c *gin.Context) {
	/*
	   判断用户是否登录
	*/
	uid, isLogin := service.IsUserLoggedIn(c)
	if !isLogin {
		log.Println("用户未登录")
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户未登录"})
		return
	}
	//开启事务
	session := database.Engine.NewSession()
	defer session.Close() //延迟关闭session
	err := session.Begin()
	if err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "开启事务失败!"})
		fmt.Println("开启事务失败")
		return
	}
	/* 根据应用id和组成员的用户ID，且用户权限为0的条件查询应用组群*/
	permission := 0
	appGroup, Group_exist, err := models.GetAppGroupsByAppIDAndContainMemberUserID(10, uid, permission)
	if err != nil {
		fmt.Println("根据用户id和应用id查询组群出错")
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据用户id和应用id查询组群出错"})
		return
	}
	if !Group_exist {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "你未绑定自己的孩子账号,亲子组群不存在"})
		return
	}
	userIds, err := models.GetMembersWithUserPermission9(session, appGroup)
	if err != nil {
		log.Println("根据组群名称查询组成员权限为9的用户出错")
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据组群名称查询组成员权限为9的用户出错"})
		return
	}
	fmt.Println("userIds 学生id ==> : ", userIds)

	// 查询子女关于父母EMBU测量的。最近一次评估结果
	summary, embuEvaluateResult, err := models.QueryLatestSummary(10, userIds[0])
	if err != nil {
		log.Println("根据组群名称查询组成员权限为9的用户出错")
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据组群名称查询组成员权限为9的用户出错"})
		return
	}
	fmt.Println(" summary ==> ", summary)
	if summary == nil {
		log.Printf("用户id为:%d 没有EMBU测量记录", userIds[0])
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "无该用户EMBU测量记录"})
		return
	}
	//提交事务
	err = session.Commit()
	if err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "提交事务失败! "})
		return
	}
	c.JSON(http.StatusOK, gin.H{
		"code":               1,
		"message":            "获取EMBU量表测评数据成功!",
		"EMBUEvaluateResult": embuEvaluateResult,
	})

}

// 获取指定的子女EMBU测评结果接口
func QueryChildEMBUEvaluateResultByChildUID(c *gin.Context) {
	/*
	   判断用户是否登录
	*/
	uid, isLogin := service.IsUserLoggedIn(c)
	if !isLogin {
		log.Println("用户未登录")
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户未登录"})
		return
	}
	//开启事务
	session := database.Engine.NewSession()
	defer session.Close() //延迟关闭session
	err := session.Begin()
	if err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "开启事务失败!"})
		fmt.Println("开启事务失败")
		return
	}
	/* 根据应用id和组成员的用户ID，且用户权限为0的条件查询应用组群*/
	permission := 0
	_, Group_exist, err := models.GetAppGroupsByAppIDAndContainMemberUserID(10, uid, permission)
	if err != nil {
		fmt.Println("根据用户id和应用id查询组群出错")
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据用户id和应用id查询组群出错"})
		return
	}
	/*
		if !Group_exist {
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "你未绑定自己的孩子账号,亲子组群不存在"})
			return
		}
	*/

	childUId := c.PostForm("childId")
	child_Uid, err := strconv.ParseInt(childUId, 10, 64)
	if err != nil {
		fmt.Println("亲子账号的孩子id")
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "数字人id类型转换失败"})
		return
	}

	// 父母和自身可以查看EMBU测量结果
	if Group_exist || child_Uid == uid {
		// 查询子女关于父母EMBU测量的。最近一次评估结果
		summary, emuEvaluateResult, err := models.QueryLatestSummary(10, child_Uid)
		if err != nil {
			log.Println("根据组群名称查询组成员权限为9的用户出错")
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据组群名称查询组成员权限为9的用户出错"})
			return
		}
		fmt.Println(" summary ==> ", summary)
		if summary == nil {
			log.Printf("用户id为:%d 没有EMBU测量记录", child_Uid)
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "无该用户EMBU测量记录"})
			return
		}

		//提交事务
		err = session.Commit()
		if err != nil {
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "提交事务失败! "})
			return
		}
		c.JSON(http.StatusOK, gin.H{
			"code":               1,
			"message":            "根据孩子id,获取EMBU量表测评数据成功!",
			"EMBUEvaluateResult": emuEvaluateResult,
		})

	} else {
		c.JSON(http.StatusOK, gin.H{
			"code":    0,
			"message": "无查询EMBU的权限!",
		})

	}

}

//查询登陆的用户是否为亲子账号
func QueryParentAndChildUserID(c *gin.Context) {
	/*
	   判断用户是否登录
	*/
	uid, isLogin := service.IsUserLoggedIn(c)
	if !isLogin {
		log.Println("用户未登录")
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户未登录"})
		return
	}
	//开启事务
	session := database.Engine.NewSession()
	defer session.Close() //延迟关闭session
	err := session.Begin()
	if err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "开启事务失败!"})
		fmt.Println("开启事务失败")
		return
	}
	/* 根据应用id和组成员的用户ID，且用户权限为0的条件查询应用组群*/
	permission := 0
	appGroup, Group_exist, err := models.GetAppGroupsByAppIDAndContainMemberUserID(10, uid, permission)
	if err != nil {
		fmt.Println("根据用户id和应用id查询组群出错")
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据用户id和应用id查询组群出错"})
		return
	}
	if !Group_exist {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户未绑定孩子账号,亲子组群不存在"})
		return
	}
	var groupNo string
	var ParentId int64
	var ParentUser models.UserInfo
	//var childenIds []int64
	var childens []models.UserInfo

	if Group_exist {
		groupNo = appGroup.No
		appGroupMasterId, err := models.GetAppGroupMaster(session, appGroup.No)
		if err != nil {
			log.Println("根据组群查询应用群组的群主ID出错")
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询应用群组的群主ID出错"})
			return
		}
		ParentId = appGroupMasterId
		userInfo, exist, err := models.GetUserInfoById(session, ParentId)
		if err != nil {
			log.Println("根据父母ID查询父母信息出错")
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询父母信息出错"})
			return
		}
		if exist {
			ParentUser = *userInfo
		}

	}
	userIds, err := models.GetMembersWithUserPermission9(session, appGroup)
	if err != nil {
		log.Println("根据组群名称查询组成员权限为9的用户出错")
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据组群名称查询组成员权限为9的用户出错"})
		return
	}
	//childenIds = append(childenIds, userIds...)
	for _, id := range userIds {
		userInfo, exist, err := models.GetUserInfoById(session, id)
		if err != nil {
			log.Println("根据孩子ID查询孩子信息出错")
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询孩子信息出错"})
			return
		}
		if exist {
			childens = append(childens, *userInfo)
		}
	}
	//提交事务
	err = session.Commit()
	if err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "提交事务失败! "})
		return
	}
	c.JSON(http.StatusOK, gin.H{
		"code":               1,
		"childens":           childens,
		"parentId":           ParentId,
		"ParentUser":         ParentUser,
		"parentChildGroupNo": groupNo,
	})

}

//教师获取学生MHT无感测评
func TeacherGetStudentAIWithHistoryChatMHT(ctx *gin.Context) {
	/*
	   判断用户是否登录
	*/
	uid, isLogin := service.IsUserLoggedIn(ctx)
	if !isLogin {
		log.Println("用户未登录")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户未登录"})
		return
	}
	//学校编号
	schoolNo := ctx.PostForm("schoolNo")
	classNo := ctx.PostForm("classNo")
	studentId := ctx.PostForm("studentId")
	student_Id, err := strconv.ParseInt(studentId, 10, 64)
	if err != nil {
		fmt.Println("studentId转换失败:", err)
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "studentId类型转换失败"})
		return
	}

	dp_Id := ctx.PostForm("dpId")
	app_id := ctx.PostForm("appId")
	appId, err := strconv.ParseInt(app_id, 10, 64)
	if err != nil {
		fmt.Println("appId 转换失败:", err)
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "appId类型转换失败"})
		return
	}
	// 用户权限限制
	level, err := models.GetUserLevel(uid)
	if err != nil {
		log.Println("查询用户权限出错")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询用户权限出错"})
		return
	}
	if level > 3 {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户权限不足"})
		return
	}
	teacherClasss, _, err := models.QueryClassByLeader2(uid)
	if err != nil {
		log.Println("根据登陆用户ID查询班级信息出错! ")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据登陆用户ID查询班级信息出错!"})
		return
	}
	if teacherClasss == nil {
		log.Println("登陆用户不是教师或管理员，无权限查看学生MHT测量结果! ")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "登陆用户不是教师或管理员，无权限查看学生MHT测量结果!"})
		return
	}

	// 根据学校编号查询学校信息
	exist, school, err := models.GetSchoolByNo(schoolNo)
	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
	}
	ob, err := models.IsAllowOb(schoolNo)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询学校是否允许教师查看学生MHT测量结果出错!"})
		fmt.Println("查询学校是否允许教师查看学生MHT测量结果出错")
		return
	}
	// 查询学校是否允许教师查看学生的MHT测量结果
	if !ob {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "学校不允许教师查看学生MHT测量结果!"})
		fmt.Println("学校不允许教师查看学生MHT测量结果")
		return
	}
	// 根据班级编号查询班级信息
	class, err := models.GetClassByNo(classNo)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据班级编号查询班级信息出错!"})
		fmt.Println("根据班级编号查询班级信息出错")
		return
	}
	// 拼接班级组群名称
	groupName := school.SchoolName + "_" + class.ClassNo + "_" + class.ClassName

	/*
	  根据成员id和组群id查询用户的组内权限值
	*/
	//开启事务
	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, 组群名称和群主权限permission为0,查询组群
	permission := 0
	appGroup, Group_exist, err := models.GetAppGroupsByGroupNameAndUserId(session, appId, uid, groupName, permission)
	if err != nil {
		fmt.Println("根据应用名称，教师用户id，班级群名称，以及教师权限，查询班级组群出错")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据应用名称，教师用户id，查询班级组群出错"})
		return
	}
	if !Group_exist {
		ctx.JSON(http.StatusOK, gin.H{"code": 2, "message": "你查询的班级应用组群不存在"})
		return
	}
	userIds, err := models.GetMembersWithUserPermission9(session, appGroup)
	if err != nil {
		log.Println("根据组群名称查询组成员权限为9的用户出错")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据组群名称查询组成员权限为9的用户出错"})
		return
	}
	fmt.Println("班级组群学生 userIds ==> : ", userIds)

	UserPermission, _, err := models.GetUserPermission(session, appGroup.No, uid)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询用户组群权限失败!"})
		fmt.Println("查询用户组群权限失败")
		return
	}

	// 判断学生是否在班级组群中
	if !utils.ContainsUserID(userIds, student_Id) {
		log.Println("查询的学生不在班级群组中")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询的学生不在班级群组中"})
		return
	}

	mergeAll := ctx.PostForm("mergeAll")
	var merge_all bool
	if mergeAll == "" || mergeAll == "false" {
		merge_all = false
	}
	if mergeAll == "true" {
		merge_all = true
	}

	if uid == student_Id || UserPermission == 0 {

		chatRecordArray, err := database.GetChatHistoryLatest(utils.Strval(student_Id), dp_Id, utils.Strval(appId), merge_all)
		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
			}
			return

		} else {
			//提交事务
			err = session.Commit()
			if err != nil {
				ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询用户与心理咨询的聊天记录失败"})
				return
			} else {
				ctx.JSON(http.StatusOK, gin.H{"code": 1, "message": "查询成功!", "chatRecordInfo": chatRecordArray})
				fmt.Println(config.ColorGreen, "查询用户与心理咨询的聊天记录为: ", chatRecordArray, config.ColorReset)
			}

		}

	}

}

// 根据组群编号查询组群信息 GetAppGroupByID
func QueryAppGroupByNo(ctx *gin.Context) {
	/*
	   判断用户是否登录
	*/
	_, isLogin := service.IsUserLoggedIn(ctx)
	if !isLogin {
		log.Println("用户未登录")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户未登录"})
		return
	}
	AppGroupNo := ctx.PostForm("groupNo")
	exist, group, err := models.GetAppGroupByNo(AppGroupNo)
	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
	}
	ctx.JSON(http.StatusOK,
		gin.H{
			"code":     1,
			"AppGroup": group,
		})

}
