// Code generated by hertz generator.

package space

import (
	"allapp/biz/router/middleware"
	"allapp/db"
	"allapp/db/repo"
	"allapp/utils"
	"allapp/utils/errorx"
	"allapp/utils/idgen"
	"allapp/utils/pgtypex"
	"allapp/utils/response"
	"context"

	space "allapp/biz/model/space"

	"github.com/cloudwego/hertz/pkg/app"
	"github.com/cloudwego/hertz/pkg/protocol/consts"
)

// CreateSpace .
// @router /space/create [POST]
func CreateSpace(ctx context.Context, c *app.RequestContext) {
	var err error
	var req space.CreateSpaceParams
	err = c.BindAndValidate(&req)
	if err != nil {
		c.String(consts.StatusBadRequest, err.Error())
		return
	}

	resp := new(space.CreateSpaceResult)

	userID := middleware.GetUserID(ctx)

	_, err = db.Queries.GetSpaceMember(ctx, userID)

	var isExist = true

	if err != nil {
		if errorx.IsNotFound(err) {
			isExist = false
		} else {
			errorx.AddError(c, err)
			return
		}
	}

	if isExist {
		response.Fail(c).Message("请先退出所在空间").Send()
		return
	}

	// 生成邀请码
	var inviteCode string

	for {
		// 生成邀请码
		code := utils.GenerateCode(6)

		// 检查数据库是否存在
		_, err = db.Queries.FindSpaceByInviteCode(ctx, code)
		if err != nil {
			if errorx.IsNotFound(err) {
				// 不存在，唯一，直接使用
				inviteCode = code
				break
			} else {
				// 系统错误
				errorx.AddError(c, err)
				return
			}
		}

		// 如果存在，继续循环重新生成
	}

	spaceId := idgen.NextId()

	// 创建空间
	err = db.WithTx(ctx, func(q *repo.Queries) error {
		// 创建空间
		params := repo.InsertSpaceParams{
			ID:         spaceId,
			Name:       pgtypex.StringToText(req.Name),
			InviteCode: inviteCode,
		}

		err = q.InsertSpace(ctx, params)

		if err != nil {
			return err
		}
		// 将创建用户默认添加到该空间内
		userParams := repo.InsertSpaceMemberParams{
			ID:      idgen.NextId(),
			SpaceID: spaceId,
			UserID:  userID,
			Role:    0,
		}
		err := q.InsertSpaceMember(ctx, userParams)

		if err != nil {
			return err
		}

		return nil
	})

	if err != nil {
		errorx.AddError(c, err)
		return
	}

	resp.SpaceId = spaceId
	resp.InviteCode = inviteCode

	response.Success(c).Data(resp).Send()
}

// DissolveSpace .
// @router /space/dissolve [POST]
func DissolveSpace(ctx context.Context, c *app.RequestContext) {
	var err error
	var req space.DissolveSpaceParams
	err = c.BindAndValidate(&req)
	if err != nil {
		c.String(consts.StatusBadRequest, err.Error())
		return
	}

	resp := new(space.DissolveSpaceResult)

	spaceID := req.GetSpaceId()
	userID := middleware.GetUserID(ctx)

	// 检查权限
	hasPermission, err := hasSpacePermission(ctx, userID, spaceID)

	if err != nil {
		errorx.AddError(c, err)
		return
	}

	if !hasPermission {
		response.Fail(c).Message("无权限操作该空间").Send()
		return
	}

	// 解散空间
	err = db.WithTx(ctx, func(q *repo.Queries) error {
		err2 := q.DeleteSpace(ctx, spaceID)
		if err2 != nil {
			return err2
		}

		err2 = q.DeleteSpaceMembersBySpaceID(ctx, spaceID)
		if err2 != nil {
			return err2
		}

		return nil
	})

	if err != nil {
		errorx.AddError(c, err)
		return
	}

	response.Success(c).Data(resp).Send()
}

// ExitSpace .
// @router /space/exit [POST]
func ExitSpace(ctx context.Context, c *app.RequestContext) {
	var err error
	var req space.ExitSpaceParams
	err = c.BindAndValidate(&req)
	if err != nil {
		c.String(consts.StatusBadRequest, err.Error())
		return
	}

	resp := new(space.ExitSpaceResult)

	exitSpaceId := req.SpaceId

	userID := middleware.GetUserID(ctx)

	spaceUser, err := db.Queries.GetSpaceMember(ctx, userID)

	if err != nil {
		if errorx.IsNotFound(err) {
			response.Success(c).Data(resp).Send()
		} else {
			errorx.AddError(c, err)
			return
		}
	}

	if spaceUser.SpaceID != exitSpaceId {
		response.Success(c).Data(resp).Send()
		return
	}

	if spaceUser.Role == 0 {
		response.Fail(c).Message("请选择解散空间").Send()
		return
	}

	err = db.WithTx(ctx, func(q *repo.Queries) error {
		err2 := q.DeleteSpaceMemberByUserID(ctx, userID)
		if err2 != nil {
			return err2
		}
		return nil
	})

	if err != nil {
		errorx.AddError(c, err)
		return
	}

	response.Success(c).Data(resp).Send()
}

// JoinSpace .
// @router /space/join [POST]
func JoinSpace(ctx context.Context, c *app.RequestContext) {
	var err error
	var req space.JoinSpaceParams
	err = c.BindAndValidate(&req)
	if err != nil {
		c.String(consts.StatusBadRequest, err.Error())
		return
	}

	resp := new(space.JoinSpaceResult)

	userID := middleware.GetUserID(ctx)

	_, err = db.Queries.GetSpaceMember(ctx, userID)

	if err != nil {
		if errorx.IsNotFound(err) {
		} else {
			errorx.AddError(c, err)
			return
		}
	} else {
		response.Fail(c).Message("请先退出已加入的空间").Send()
		return
	}

	inviteCode := req.GetInviteCode()

	spaceByInviteCode, err := db.Queries.FindSpaceByInviteCode(ctx, inviteCode)

	if err != nil {
		if errorx.IsNotFound(err) {
			response.Fail(c).Message("邀请码无效或过期").Send()
			return
		} else {
			errorx.AddError(c, err)
			return
		}
	}

	err = db.WithTx(ctx, func(q *repo.Queries) error {
		err2 := q.InsertSpaceMember(ctx, repo.InsertSpaceMemberParams{
			ID:      idgen.NextId(),
			UserID:  userID,
			SpaceID: spaceByInviteCode.ID,
			Role:    1,
		})

		if err2 != nil {
			return err2
		}

		return nil
	})

	if err != nil {
		errorx.AddError(c, err)
		return
	}

	resp.SpaceId = spaceByInviteCode.ID
	resp.SpaceName = spaceByInviteCode.Name.String

	response.Success(c).Data(resp).Send()
}

// ListSpaceMembers .
// @router /space/members [POST]
func ListSpaceMembers(ctx context.Context, c *app.RequestContext) {
	var err error
	var req space.ListSpaceMembersParams
	if err = c.BindAndValidate(&req); err != nil {
		c.String(consts.StatusBadRequest, err.Error())
		return
	}

	resp := new(space.ListSpaceMembersResult)

	members, err := db.Queries.ListSpaceMembers(ctx, req.SpaceId)
	if err != nil {
		c.String(consts.StatusInternalServerError, err.Error())
		return
	}

	resp.Members = make([]*space.SpaceMember, 0, len(members))

	for _, u := range members {
		resp.Members = append(resp.Members, &space.SpaceMember{
			Id:            u.UserID,
			Username:      u.UserName,
			Avatar:        u.UserAvatar,
			Role:          u.Role,
			LastLoginTime: pgtypex.TimestamptzToMillis(u.LastLoginTime),
		})
	}

	response.Success(c).Data(resp).Send()
}

// RemoveSpaceMember .
// @router /space/remove [POST]
func RemoveSpaceMember(ctx context.Context, c *app.RequestContext) {
	var err error
	var req space.RemoveSpaceMemberParams
	err = c.BindAndValidate(&req)
	if err != nil {
		c.String(consts.StatusBadRequest, err.Error())
		return
	}

	resp := new(space.RemoveSpaceMemberResult)

	userID := middleware.GetUserID(ctx)
	spaceID := req.SpaceId

	// 检查权限
	hasPermission, err := hasSpacePermission(ctx, userID, spaceID)

	if err != nil {
		errorx.AddError(c, err)
		return
	}

	if !hasPermission {
		response.Fail(c).Message("无权限操作该空间").Send()
		return
	}

	// 移除
	err = db.WithTx(ctx, func(q *repo.Queries) error {
		err2 := q.DeleteSpaceMemberBySpaceIDAndUserID(ctx, repo.DeleteSpaceMemberBySpaceIDAndUserIDParams{
			SpaceID: spaceID,
			UserID:  req.UserId,
		})

		if err2 != nil {
			return err2
		}

		return nil
	})

	if err != nil {
		errorx.AddError(c, err)
		return
	}

	response.Success(c).Data(resp).Send()
}

// UpdateSpaceMemberRole .
// @router /space/updateRole [POST]
func UpdateSpaceMemberRole(ctx context.Context, c *app.RequestContext) {
	var err error
	var req space.UpdateSpaceMemberRoleParams
	err = c.BindAndValidate(&req)
	if err != nil {
		c.String(consts.StatusBadRequest, err.Error())
		return
	}

	resp := new(space.UpdateSpaceMemberRoleResult)

	userID := middleware.GetUserID(ctx)
	spaceID := req.SpaceId
	updateUserID := req.UserId

	hasPermission, err := hasSpacePermission(ctx, userID, spaceID)

	if err != nil {
		errorx.AddError(c, err)
		return
	}

	if !hasPermission {
		response.Fail(c).Message("无权限操作该空间").Send()
		return
	}

	// 检查是否在该空间
	updateSpaceUser, err := db.Queries.GetSpaceMember(ctx, updateUserID)

	if err != nil {
		if errorx.IsNotFound(err) {
			response.Fail(c).Message("授权失败，该用户不在该空间").Send()
			return
		}
		errorx.AddError(c, err)
		return
	}

	if updateSpaceUser.SpaceID != spaceID {
		response.Fail(c).Message("授权失败，该用户不在该空间").Send()
		return
	}

	// 更新
	err = db.WithTx(ctx, func(q *repo.Queries) error {
		err2 := q.UpdateSpaceMemberRole(ctx, repo.UpdateSpaceMemberRoleParams{
			Role:    1,
			SpaceID: spaceID,
			UserID:  userID,
		})

		if err2 != nil {
			return err2
		}

		err2 = q.UpdateSpaceMemberRole(ctx, repo.UpdateSpaceMemberRoleParams{
			Role:    0,
			SpaceID: spaceID,
			UserID:  updateUserID,
		})

		if err2 != nil {
			return err2
		}

		return nil
	})

	if err != nil {
		errorx.AddError(c, err)
		return
	}

	response.Success(c).Data(resp).Send()
}

func hasSpacePermission(ctx context.Context, userID int64, spaceID int64) (bool, error) {
	user, err := db.Queries.GetSpaceMember(ctx, userID)

	if err != nil {
		if errorx.IsNotFound(err) {
			return false, nil
		}
		return false, err
	}

	if user.SpaceID != spaceID {
		return false, nil
	}

	return user.Role == 0, nil
}