package controllers

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

func RegisterGet(c *gin.Context) {
	//返回html
	c.HTML(http.StatusOK, "register.html", gin.H{"title": "注册页"})
}

//插入用户应用数据
func CreateUserAppData(session *xorm.Session, appIds []int64, userId int64, activeCode string) error {
	fmt.Println("appIds => ", appIds)
	appData, err := models.GetAppDataByActiveCode(session, activeCode)
	fmt.Println("appData => ", appData)
	if err != nil {
		//c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据激活码查询应用数据出错"})
		return errors.New(" 根据激活码查询应用数据出错 ")
	}
	splitAppData := strings.Split(appData, "φ")
	fmt.Println("splitAppData => ", splitAppData)
	if len(appIds) != len(splitAppData) {
		//c.JSON(http.StatusOK, gin.H{"code": 0, "message": "默认应用个数与用户应用数据数量不一致"})
		return errors.New(" 默认应用个数与用户应用数据数量不一致! ")
	}
	for i, appId := range appIds {
		err := models.InsertOrUpdateStatusData(appId, userId, splitAppData[i])
		fmt.Println(i, "==> ", splitAppData[i])
		if err != nil {
			//c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据应用id和用户id插入用户应用数据失败"})
			return errors.New(" 根据应用id和用户id插入用户应用数据失败! ")
		}
	}
	return nil
}

//处理注册
func RegisterPost(c *gin.Context) {
	//获取表单信息
	userName := c.PostForm("username")
	phone := c.PostForm("phone")
	//注册之前先判断该用户名是否已经被注册，如果已经注册，返回错误
	//fmt.Println(user.Username, user.Password, user.Phone)

	id, err := models.QueryUserWithUsernameAndPhone(userName, phone)
	if err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据用户名和手机号查询数据错误!"})
		return
	}
	fmt.Println("id:", id)
	if id > 0 {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户名已经存在，该手机已注册!"})
		return
	}

	sms_code := c.PostForm("sms_code")
	smsCode, bol := config.WorldLoginCacheCode.Get(phone)
	codeStr := utils.Strval(smsCode)
	fmt.Println("smsCode: ", codeStr)
	//判断表单中获取的验证码和缓存中的验证码是否相等
	if !bol && codeStr != sms_code {
		c.JSON(http.StatusOK, gin.H{
			"code":    0,
			"message": "验证码不存在或验证码错误!",
		})
		return
	}
	password := c.PostForm("password")
	fmt.Println("用户名: ", userName, "用户加密前密码: ", password, "手机号:", phone, "手机验证码: ", sms_code)
	//注册用户名和密码
	//存储的密码是md5后的数据，那么在登录的验证的时候，也是需要将用户的密码md5之后和数据库里面的密码进行判断
	fmt.Println("=== md5后: ===", utils.MD5(password))
	/*
	   调用工具类的MD5加盐的函数
	*/
	salt := config.Conf.Md5Salt
	md5String, err := utils.MD5BySalf(password, salt)
	if err != nil {
		log.Println("密码加盐失败！")
	}
	fmt.Println("用户密码加盐后：", md5String)
	// 处理邀请码逻辑
	inviteCode := c.PostForm("invite_code")
	//激活码
	activeCode := c.PostForm("active_code")
	if inviteCode == "" && activeCode == "" {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "邀请码或者激活码为空!"})

		return
	}
	//判断是否存在邀请码
	//code := c.PostForm("invite_code")

	//开启事务
	session := database.Engine.NewSession()
	defer session.Close() //延迟关闭session
	err1 := session.Begin()
	if err1 != nil {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "开启事务失败!"})
		fmt.Println("开启事务失败")
		return
	}
	/*邀请码不为空的处理，走邀请码注册的用户*/
	if inviteCode != "" {

		//根据邀请码查询邀请人用户
		inviter, err := models.QueryInviterIDByInviteCode(session, inviteCode)
		if err != nil {
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "邀请码无效!"})
			return
		}
		NewUser := models.User{
			Username:   userName,
			Phone:      phone,
			Password:   md5String,
			Status:     0,
			Createtime: time.Now().Unix(),
			Level:      inviter.Level + 1,
		}
		//添加用户
		rows, user_id, err := models.AddUser(session, &NewUser)
		if err != nil {
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "注册失败"})
			log.Println(err.Error())
			return
		}
		if rows <= 0 {
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "注册失败"})
			fmt.Println("用户注册失败！")
			return
		}

		/*
		 添加用户详情信息, 根据注册用户id，查询注册用户的详细信息是否已经在详细信息表中
		*/
		_, exist, err := models.GetUserInfoByPhone(session, phone)
		if err != nil {
			fmt.Println("根据手机号查询用户是否存在，查询失败")
			c.JSON(http.StatusInternalServerError, gin.H{"code": 0, "message": "根据手机查询用户详情信息是否存在出错"})
			return
		}
		//创建用户详情信息
		UserSex := "不详"
		userinfoName := "不详"
		userinfo := &models.UserInfo{
			UserName: userinfoName,
			UserSex:  UserSex,
			Phone:    phone,
		}
		userinfo.UserId = user_id
		if !exist {
			//用户详情信息表操作
			err = models.FindOrCreateOrUpdateUserInfoByPhone(session, userinfo)
			if err != nil {
				fmt.Printf("向用户信息表添加用户数据失败")
				c.JSON(http.StatusInternalServerError, gin.H{"code": 0, "message": err.Error()})
				return
			}
		}

		// 保存邀请关系到用户邀请关系表
		err = models.SaveInvitationRelationship(session, inviter.Id, user_id)
		if err != nil {
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "保存用户邀请关系数据失败!"})
			return
		}

	}

	if activeCode != "" {

		/* 查询激活码是否存在 */
		exist, activationCode, err := models.GetActivationCode_Tx(session, activeCode)
		if err != nil {
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询激活码出错"})
			return
		}
		if !exist {
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "激活码不存在或激活码无效"})
			return
		}
		if activationCode.ActivateTime > 0 {
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "激活码已经使用,无法重复激活"})
			return
		}
		NewUser := models.User{
			Username:   userName,
			Phone:      phone,
			Password:   md5String,
			Createtime: time.Now().Unix(),
			Level:      10,
		}
		// 保存用户的初始灵感值
		if activationCode.InitialInspiration != 0 {
			NewUser.InitialInspiration = activationCode.InitialInspiration
		}

		apps := activationCode.DefaultApps
		if utils.Contains(apps, 1) {
			NewUser.Status = 1
		}

		if utils.Contains(apps, 2) || utils.Contains(apps, 6) || utils.Contains(apps, 9) || utils.Contains(apps, 12) {
			NewUser.Status = 2
		}

		/*
			for _, appID := range apps {
					// 根据应用ID进行判断并设置用户状态
					switch appID {
					case 2, 6, 9:
						NewUser.Status = 2
					default:
						NewUser.Status = 0
					}
				}
		*/

		//用户注册表，添加用户
		rows, user_id, err := models.AddUser(session, &NewUser)
		if err != nil {
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "注册失败"})
			log.Println(err.Error())
			return
		}
		if rows <= 0 {
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "注册失败"})
			fmt.Println("用户注册失败！")
			return
		}
		fmt.Println("新注册的用户的 user_id: ", user_id)

		/*
		 添加用户详情信息, 根据注册用户id，查询注册用户的详细信息是否已经在详细信息表中
		*/
		_, userInfo_exist, err := models.GetUserInfoByPhone(session, phone)
		if err != nil {
			fmt.Println("根据手机号查询用户是否存在，查询失败")
			c.JSON(http.StatusInternalServerError, gin.H{"code": 0, "message": "根据手机查询用户详情信息是否存在出错"})
			return
		}
		//创建用户详情信息
		UserSex := "不详"
		userinfoName := "不详"
		userinfo := &models.UserInfo{
			UserName: userinfoName,
			UserSex:  UserSex,
			Phone:    phone,
		}
		userinfo.UserId = user_id
		if !userInfo_exist {
			//用户详情信息表操作
			err = models.FindOrCreateOrUpdateUserInfoByPhone(session, userinfo)
			if err != nil {
				fmt.Printf("向用户信息表添加用户数据失败")
				c.JSON(http.StatusInternalServerError, gin.H{"code": 0, "message": err.Error()})
				return
			}
		}

		/*  把默认应用添加到应用的参与者数组中*/
		appIds := activationCode.DefaultApps
		err = models.AddParticipants(session, appIds, user_id)
		if err != nil {
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "添加新用户到应用参与者出错"})
			fmt.Println("添加新用户到应用参与者出错！")
			return
		}
		//激活时间
		activationCode.ActivateTime = time.Now().Unix()                        // 获取当前时间的 Unix 时间戳
		durationSeconds := activationCode.DurationHours * 3600                 // 将小时转换为秒数
		expireTimeUnix := activationCode.ActivateTime + int64(durationSeconds) // 计算过期时间的 Unix 时间戳秒数
		fmt.Println("activationCode expireTime: ", expireTimeUnix)
		//过期时间赋值
		activationCode.ExpireTime = expireTimeUnix
		//激活码创建者Id和使用者用户id
		activationCode.UseingId = user_id

		err = models.UpdateActivationCode(session, activationCode)
		if err != nil {
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "更新激活码失败"})
			fmt.Println("更新激活码失败！")
			return
		}
		// 根据激活码的灵感月限度额和初始额度
		usageInspirationSumLog := &models.UserSummaryInspirationUsageLog{
			UserId: user_id,
		}

		fmt.Println(" activationCode.InitialInspiration ==> ", activationCode.InitialInspiration)

		if activationCode.MonthLimitAmount != 0 && activationCode.InitialInspiration != 0 {
			usageInspirationSumLog.MonthLimitAmount = activationCode.MonthLimitAmount
			usageInspirationSumLog.InitialInspiration = activationCode.InitialInspiration
		}

		logRow, err := models.InsertUserSummaryInspirationUsageLog_Tx(session, usageInspirationSumLog)
		if err != nil {
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "添加用户灵感消耗汇总记录出错"})
			fmt.Println("添加用户灵感消耗汇总记录出错！")
			return
		}
		if logRow <= 0 {
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "添加用户灵感消耗汇总记录失败"})
			fmt.Println("添加用户灵感消耗汇总记录失败！")
			return
		}
		/* 根据应用id和userid，插入用户应用数据*/
		err = CreateUserAppData(session, appIds, user_id, activeCode)
		if err != nil {
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据应用id和用户id，插入用户应用数据出错"})
			fmt.Printf("根据应用id和用户id，插入用户应用数据出错！")
			log.Printf("根据应用id和用户id，插入用户应用数据出错: %v", err.Error())
			return
		}
	}
	//提交事务
	err = session.Commit()
	if err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "注册失败"})
		return
	} else {
		c.JSON(http.StatusOK, gin.H{"code": 1, "message": "注册成功!"})
	}

}

//服务商用户注册接口
func ServiceProviderRegisterPost(c *gin.Context) {
	//获取表单信息
	userName := c.PostForm("username") //MiGu
	phone := c.PostForm("phone")       //手机号
	AuthId := c.PostForm("AuthId")     //服务商Id

	//开启事务
	session := database.Engine.NewSession()
	defer session.Close() //延迟关闭session
	err1 := session.Begin()
	if err1 != nil {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "开启事务失败!"})
		fmt.Println("开启事务失败")
		return
	}
	//用户角色标签
	Tags := c.PostForm("tags")
	if Tags == "" {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户角色标签不能为空!"})
		fmt.Println("用户角色标签不能为空")
		return
	}
	//可以访问的标签
	TagsArr := []string{}
	// 分割字符串，得到单独的字符串
	tagsSplit := strings.Split(Tags, ",")
	for _, tagStr := range tagsSplit {
		// 将转换后的字符串添加到数组
		TagsArr = append(TagsArr, tagStr)
	}

	var SP *models.ServiceProvider
	var err error

	if AuthId != "" {
		SP, err = models.GetServiceProviderById_Tx(session, AuthId)
		if err != nil {
			fmt.Println("根据服务商id查询出错:", err)
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据服务商id查询服务商出错"})
			return
		}
		fmt.Println("SP ===>", SP)
		if SP == nil {
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "非法的服务商"})
			return
		}
	} else {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "服务商ID不能为空"})
		return
	}

	//注册之前先判断该用户名是否已经被注册，如果已经注册，返回错误
	id, err := models.QueryUserWithUsernameAndPhone(userName, phone)
	if err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据用户名和手机号查询数据错误!"})
		return
	}
	fmt.Println("id:", id)
	if id > 0 {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户名已经存在，该手机已注册!"})
		return
	}

	/*	sms_code := c.PostForm("sms_code")
			smsCode, bol := config.LoginCacheCode.Get(phone)
			codeStr := utils.Strval(smsCode)
			fmt.Println("smsCode: ", codeStr)
			//判断表单中获取的验证码和缓存中的验证码是否相等
			if !bol && codeStr != sms_code {
				c.JSON(http.StatusOK, gin.H{
					"code":    0,
					"message": "验证码不存在或验证码错误!",
				})
				return
			}
		   fmt.Println("用户名: ", userName, "用户加密前密码: ", password, "手机号:", phone, "手机验证码: ", sms_code)
	*/
	password := c.PostForm("password")
	fmt.Println("用户名: ", userName, "用户加密前密码: ", password, "手机号:", phone)

	//注册用户名和密码
	//存储的密码是md5后的数据，那么在登录的验证的时候，也是需要将用户的密码md5之后和数据库里面的密码进行判断
	fmt.Println("=== md5后: ===", utils.MD5(password))
	/*
	   调用工具类的MD5加盐的函数
	*/
	salt := config.Conf.Md5Salt
	md5String, err := utils.MD5BySalf(password, salt)
	if err != nil {
		log.Println("密码加盐失败！")
	}
	fmt.Println("用户密码加盐后：", md5String)

	//判断是否存在邀请码
	//code := c.PostForm("invite_code")

	NewUser := models.User{
		Username:         userName,
		Phone:            phone,
		Password:         md5String,
		Status:           0,
		Createtime:       time.Now().Unix(),
		Level:            9,
		RegisteredSource: SP.Name,
		Tags:             TagsArr,
	}

	//添加用户
	rows, user_id, err := models.AddUser(session, &NewUser)
	if err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "注册失败"})
		log.Println(err.Error())
		return
	}
	if rows <= 0 {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "注册失败"})
		fmt.Println("用户注册失败！")
		return
	}

	/*
	 添加用户详情信息, 根据注册用户id，查询注册用户的详细信息是否已经在详细信息表中
	*/
	_, exist, err := models.GetUserInfoByPhone(session, phone)
	if err != nil {
		fmt.Println("根据手机号查询用户是否存在，查询失败")
		c.JSON(http.StatusInternalServerError, gin.H{"code": 0, "message": "根据手机查询用户详情信息是否存在出错"})
		return
	}
	//创建用户详情信息
	UserSex := "不详"
	userinfoName := "不详"
	userinfo := &models.UserInfo{
		UserName: userinfoName,
		UserSex:  UserSex,
		Phone:    phone,
	}
	userinfo.UserId = user_id
	if !exist {
		//用户详情信息表操作
		err = models.FindOrCreateOrUpdateUserInfoByPhone(session, userinfo)
		if err != nil {
			fmt.Printf("向用户信息表添加用户数据失败")
			c.JSON(http.StatusInternalServerError, gin.H{"code": 0, "message": err.Error()})
			return
		}
	}

	//提交事务
	err = session.Commit()
	if err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "注册失败"})
		return
	} else {
		c.JSON(http.StatusOK, gin.H{"code": 1, "message": "注册成功!"})
	}

}

//服务商批量生成用户账号
func ServiceProviderBatchAccount(c *gin.Context) {
	/*
	   判断用户是否登录
	*/
	userID, isLogin := service.IsUserLoggedIn(c)
	if !isLogin {
		log.Println("用户未登录")
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户未登录"})
		return
	}
	//判断用户的权限level是否小于5
	level, err1 := models.GetUserLevel(userID)
	if err1 != nil {
		log.Println("查询用户权限出错")
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询用户权限出错"})
		return
	}
	if level > 5 {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户权限不足"})
		return
	}
	//获取表单信息
	AuthId := c.PostForm("AuthId")
	// 批量创建激活码的个数
	accountNums := c.PostForm("accountNums")
	// 将 activeCodeNums 转换为 int 类型
	accountNumsInt, err := strconv.Atoi(accountNums)
	if err != nil {
		// 转换失败，处理错误
		fmt.Println("转换失败:", err)
	} else {
		// 转换成功，activeCodeNumsInt 现在是 int 类型
		fmt.Println("转换成功:", accountNumsInt)
	}
	if accountNumsInt > 7 {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "批量生成账号的数量不能超过7个!"})
		fmt.Println("批量生成账号的数量不能超过7个")
		return
	}
	//用户角色标签
	Tags := c.PostForm("tags")
	if Tags == "" {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户角色标签不能为空!"})
		fmt.Println("用户角色标签不能为空")
		return
	}
	//可以访问的标签
	TagsArr := []string{}
	// 分割字符串，得到单独的字符串
	tagsSplit := strings.Split(Tags, ",")
	for _, tagStr := range tagsSplit {
		// 将转换后的字符串添加到数组
		TagsArr = append(TagsArr, tagStr)
	}

	var successfulUserAccounts []string // 存储成功注册的用户名数组

	//开启事务
	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
	}
	var SP *models.ServiceProvider

	if AuthId != "" {
		SP, err = models.GetServiceProviderById_Tx(session, AuthId)
		if err != nil {
			fmt.Println("根据服务商id查询出错:", err)
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据服务商id查询服务商出错"})
			return
		}
		fmt.Println("SP ===>", SP)
		if SP == nil {
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "非法的服务商"})
			return
		}
	} else {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "服务商ID不能为空"})
		return
	}

	for i := 0; i < accountNumsInt; i++ {

		//注册之前先判断该用户名是否已经被注册，如果已经注册，返回错误
		//随机生成用户名，规则是用户名MiGu@ + 随机字符串
		var userName, userUUID, phone string
		userUUID = utils.GenerateServiceProviderCode()
		userName = "MiGu@" + userUUID
		// 获取当前时间的 Unix 时间戳
		timestamp := time.Now().UnixMilli()
		// 将 int64 类型的时间戳转换为字符串
		timestampStr := strconv.FormatInt(timestamp, 10)
		phone = userName + timestampStr
		fmt.Println("phone ==> ", phone)
		_, exist, err := models.GetUserByName_Tx(session, userName)
		if err != nil {
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据用户名查询用户信息出误!"})
			return
		}
		_, has, err := models.GetUserByPhone(session, phone)
		if err != nil {
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据用户手机查询用户信息出误!"})
			return
		}
		if exist || has {
			userUUID = utils.GenerateServiceProviderCode()
			userName = "MiGu@" + userUUID
			// 获取当前时间的 Unix 时间戳
			timestamp2 := time.Now().UnixMilli()
			// 将 int64 类型的时间戳转换为字符串
			timestampStr = strconv.FormatInt(timestamp2, 10)
			phone = userName + timestampStr
		}

		/*id, err := models.QueryUserWithUsernameAndPhone_Tx(session,userName, phone)
		if err != nil {
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据用户名和手机号查询数据错误!"})
			return
		}
		fmt.Println("id:", id)
		if id > 0 {
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户名已经存在，该手机已注册!"})
			return
		}*/

		/*	sms_code := c.PostForm("sms_code")
				smsCode, bol := config.LoginCacheCode.Get(phone)
				codeStr := utils.Strval(smsCode)
				fmt.Println("smsCode: ", codeStr)
				//判断表单中获取的验证码和缓存中的验证码是否相等
				if !bol && codeStr != sms_code {
					c.JSON(http.StatusOK, gin.H{
						"code":    0,
						"message": "验证码不存在或验证码错误!",
					})
					return
				}
			   fmt.Println("用户名: ", userName, "用户加密前密码: ", password, "手机号:", phone, "手机验证码: ", sms_code)
		*/
		//password := c.PostForm("password")
		password := "88888888abc"
		fmt.Println("用户名: ", userName, "用户加密前密码: ", password, "手机号:", phone)

		//注册用户名和密码
		//存储的密码是md5后的数据，那么在登录的验证的时候，也是需要将用户的密码md5之后和数据库里面的密码进行判断
		fmt.Println("=== md5后: ===", utils.MD5(password))
		/*
		   调用工具类的MD5加盐的函数
		*/
		salt := config.Conf.Md5Salt
		md5String, err := utils.MD5BySalf(password, salt)
		if err != nil {
			log.Println("密码加盐失败！")
		}
		fmt.Println("用户密码加盐后：", md5String)

		//判断是否存在邀请码
		//code := c.PostForm("invite_code")

		NewUser := models.User{
			Username:         userName,
			Phone:            phone,
			Password:         md5String,
			Status:           0,
			Createtime:       time.Now().Unix(),
			Level:            9,
			RegisteredSource: SP.Name,
			Tags:             TagsArr,
		}

		//添加用户
		rows, user_id, err := models.AddUser(session, &NewUser)
		if err != nil {
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "注册失败"})
			log.Println(err.Error())
			return
		}
		/*	if rows <= 0 {
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "注册失败"})
			fmt.Println("用户注册失败！")
			return
		}*/
		if rows > 0 {
			// 如果用户成功注册，只添加用户名到成功用户名数组中
			successfulUserAccounts = append(successfulUserAccounts, userName)
		} else {
			fmt.Println("用户注册失败！")
			continue // 注册失败时跳过
		}

		/*
		 添加用户详情信息, 根据注册用户id，查询注册用户的详细信息是否已经在详细信息表中
		*/
		_, exist, err = models.GetUserInfoByPhone(session, phone)
		if err != nil {
			fmt.Println("根据手机号查询用户是否存在，查询失败")
			c.JSON(http.StatusInternalServerError, gin.H{"code": 0, "message": "根据手机查询用户详情信息是否存在出错"})
			return
		}
		//创建用户详情信息
		UserSex := "不详"
		userinfoName := "不详"
		userinfo := &models.UserInfo{
			UserName: userinfoName,
			UserSex:  UserSex,
			Phone:    phone,
		}
		userinfo.UserId = user_id
		if !exist {
			//用户详情信息表操作
			err = models.FindOrCreateOrUpdateUserInfoByPhone(session, userinfo)
			if err != nil {
				fmt.Printf("向用户信息表添加用户数据失败")
				c.JSON(http.StatusInternalServerError, gin.H{"code": 0, "message": err.Error()})
				return
			}
		}

	}

	// 提交事务
	err = session.Commit()
	if err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "注册失败"})
		return
	} else {
		if len(successfulUserAccounts) > 0 {
			c.JSON(http.StatusOK, gin.H{"code": 1, "message": "批量注册账号成功!", "accounts": successfulUserAccounts})
		} else {
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "无账号注册成功"})
		}
	}

}
