backend/internal/handler/user_handler.go

package handler

import (
	"carrotskin/internal/container"
	"carrotskin/internal/model"
	"carrotskin/internal/service"
	"carrotskin/internal/types"

	"github.com/gin-gonic/gin"
	"go.uber.org/zap"
)

// UserHandler 用户处理器（依赖注入版本）
type UserHandler struct {
	container *container.Container
	logger    *zap.Logger
}

// NewUserHandler 创建UserHandler实例
func NewUserHandler(c *container.Container) *UserHandler {
	return &UserHandler{
		container: c,
		logger:    c.Logger,
	}
}

// GetProfile 获取用户信息
// @Summary 获取用户信息
// @Description 获取当前登录用户的详细信息
// @Tags user
// @Accept json
// @Produce json
// @Security BearerAuth
// @Success 200 {object} model.Response{data=types.UserInfo} "获取成功"
// @Failure 404 {object} model.ErrorResponse "用户不存在"
// @Router /api/v1/user/profile [get]
func (h *UserHandler) GetProfile(c *gin.Context) {
	userID, ok := GetUserIDFromContext(c)
	if !ok {
		return
	}

	user, err := h.container.UserService.GetByID(c.Request.Context(), userID)
	if err != nil || user == nil {
		h.logger.Error("获取用户信息失败",
			zap.Int64("user_id", userID),
			zap.Error(err),
		)
		RespondNotFound(c, "用户不存在")
		return
	}

	RespondSuccess(c, UserToUserInfo(user))
}

// UpdateProfile 更新用户信息
// @Summary 更新用户信息
// @Description 更新用户资料（密码、头像URL），如需上传头像请使用上传接口
// @Tags user
// @Accept json
// @Produce json
// @Security BearerAuth
// @Param request body types.UpdateUserRequest true "更新信息"
// @Success 200 {object} model.Response{data=types.UserInfo} "更新成功"
// @Failure 400 {object} model.ErrorResponse "参数错误"
// @Failure 404 {object} model.ErrorResponse "用户不存在"
// @Router /api/v1/user/profile [put]
func (h *UserHandler) UpdateProfile(c *gin.Context) {
	userID, ok := GetUserIDFromContext(c)
	if !ok {
		return
	}

	var req types.UpdateUserRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		RespondBadRequest(c, "请求参数错误", err)
		return
	}

	user, err := h.container.UserService.GetByID(c.Request.Context(), userID)
	if err != nil || user == nil {
		RespondNotFound(c, "用户不存在")
		return
	}

	// 处理密码修改
	if req.NewPassword != "" {
		if req.OldPassword == "" {
			RespondBadRequest(c, "修改密码需要提供原密码", nil)
			return
		}

		if err := h.container.UserService.ChangePassword(c.Request.Context(), userID, req.OldPassword, req.NewPassword); err != nil {
			h.logger.Error("修改密码失败", zap.Int64("user_id", userID), zap.Error(err))
			RespondBadRequest(c, err.Error(), nil)
			return
		}

		h.logger.Info("用户修改密码成功", zap.Int64("user_id", userID))
	}

	// 更新头像
	if req.Avatar != "" {
		if err := h.container.UserService.ValidateAvatarURL(c.Request.Context(), req.Avatar); err != nil {
			RespondBadRequest(c, err.Error(), nil)
			return
		}
		user.Avatar = req.Avatar
		if err := h.container.UserService.UpdateInfo(c.Request.Context(), user); err != nil {
			h.logger.Error("更新用户信息失败", zap.Int64("user_id", user.ID), zap.Error(err))
			RespondServerError(c, "更新失败", err)
			return
		}
	}

	// 重新获取更新后的用户信息
	updatedUser, err := h.container.UserService.GetByID(c.Request.Context(), userID)
	if err != nil || updatedUser == nil {
		RespondNotFound(c, "用户不存在")
		return
	}

	RespondSuccess(c, UserToUserInfo(updatedUser))
}

// UploadAvatar 直接上传头像文件
// @Summary 上传头像
// @Description 上传图片文件作为用户头像
// @Tags user
// @Accept multipart/form-data
// @Produce json
// @Security BearerAuth
// @Param file formData file true "头像文件"
// @Success 200 {object} model.Response{data=map[string]interface{}} "上传成功"
// @Failure 400 {object} model.ErrorResponse "参数错误"
// @Failure 404 {object} model.ErrorResponse "用户不存在"
// @Router /api/v1/user/avatar/upload [post]
func (h *UserHandler) UploadAvatar(c *gin.Context) {
	userID, ok := GetUserIDFromContext(c)
	if !ok {
		return
	}

	// 解析multipart表单
	if err := c.Request.ParseMultipartForm(10 << 20); err != nil { // 10MB
		RespondBadRequest(c, "解析表单失败", err)
		return
	}

	// 获取文件
	file, err := c.FormFile("file")
	if err != nil {
		RespondBadRequest(c, "获取文件失败", err)
		return
	}

	// 读取文件内容
	src, err := file.Open()
	if err != nil {
		RespondBadRequest(c, "打开文件失败", err)
		return
	}
	defer src.Close()

	fileData := make([]byte, file.Size)
	if _, err := src.Read(fileData); err != nil {
		RespondBadRequest(c, "读取文件失败", err)
		return
	}

	// 调用服务上传头像
	avatarURL, err := h.container.UserService.UploadAvatar(c.Request.Context(), userID, fileData, file.Filename)
	if err != nil {
		h.logger.Error("上传头像失败",
			zap.Int64("user_id", userID),
			zap.String("file_name", file.Filename),
			zap.Error(err),
		)
		RespondBadRequest(c, err.Error(), nil)
		return
	}

	// 获取更新后的用户信息
	user, err := h.container.UserService.GetByID(c.Request.Context(), userID)
	if err != nil || user == nil {
		RespondNotFound(c, "用户不存在")
		return
	}

	RespondSuccess(c, gin.H{
		"avatar_url": avatarURL,
		"user":       UserToUserInfo(user),
	})
}

// UpdateAvatar 更新头像URL（保留用于外部URL）
// @Summary 更新头像URL
// @Description 更新用户头像为外部URL
// @Tags user
// @Accept json
// @Produce json
// @Security BearerAuth
// @Param avatar_url query string true "头像URL"
// @Success 200 {object} model.Response{data=types.UserInfo} "更新成功"
// @Failure 400 {object} model.ErrorResponse "参数错误"
// @Failure 404 {object} model.ErrorResponse "用户不存在"
// @Router /api/v1/user/avatar [put]
func (h *UserHandler) UpdateAvatar(c *gin.Context) {
	userID, ok := GetUserIDFromContext(c)
	if !ok {
		return
	}

	avatarURL := c.Query("avatar_url")
	if avatarURL == "" {
		RespondBadRequest(c, "头像URL不能为空", nil)
		return
	}

	if err := h.container.UserService.ValidateAvatarURL(c.Request.Context(), avatarURL); err != nil {
		RespondBadRequest(c, err.Error(), nil)
		return
	}

	if err := h.container.UserService.UpdateAvatar(c.Request.Context(), userID, avatarURL); err != nil {
		h.logger.Error("更新头像失败",
			zap.Int64("user_id", userID),
			zap.String("avatar_url", avatarURL),
			zap.Error(err),
		)
		RespondServerError(c, "更新头像失败", err)
		return
	}

	user, err := h.container.UserService.GetByID(c.Request.Context(), userID)
	if err != nil || user == nil {
		RespondNotFound(c, "用户不存在")
		return
	}

	RespondSuccess(c, UserToUserInfo(user))
}

// ChangeEmail 更换邮箱
// @Summary 更换邮箱
// @Description 更换用户绑定的邮箱，需要验证码
// @Tags user
// @Accept json
// @Produce json
// @Security BearerAuth
// @Param request body types.ChangeEmailRequest true "更换邮箱请求"
// @Success 200 {object} model.Response{data=types.UserInfo} "更换成功"
// @Failure 400 {object} model.ErrorResponse "参数错误"
// @Failure 404 {object} model.ErrorResponse "用户不存在"
// @Router /api/v1/user/change-email [post]
func (h *UserHandler) ChangeEmail(c *gin.Context) {
	userID, ok := GetUserIDFromContext(c)
	if !ok {
		return
	}

	var req types.ChangeEmailRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		RespondBadRequest(c, "请求参数错误", err)
		return
	}

	if err := h.container.VerificationService.VerifyCode(c.Request.Context(), req.NewEmail, req.VerificationCode, service.VerificationTypeChangeEmail); err != nil {
		h.logger.Warn("验证码验证失败", zap.String("new_email", req.NewEmail), zap.Error(err))
		RespondBadRequest(c, err.Error(), nil)
		return
	}

	if err := h.container.UserService.ChangeEmail(c.Request.Context(), userID, req.NewEmail); err != nil {
		h.logger.Error("更换邮箱失败",
			zap.Int64("user_id", userID),
			zap.String("new_email", req.NewEmail),
			zap.Error(err),
		)
		RespondBadRequest(c, err.Error(), nil)
		return
	}

	user, err := h.container.UserService.GetByID(c.Request.Context(), userID)
	if err != nil || user == nil {
		RespondNotFound(c, "用户不存在")
		return
	}

	RespondSuccess(c, UserToUserInfo(user))
}

// ResetYggdrasilPassword 重置Yggdrasil密码
// @Summary 重置Yggdrasil密码
// @Description 重置用户的Yggdrasil API认证密码
// @Tags user
// @Accept json
// @Produce json
// @Security BearerAuth
// @Success 200 {object} model.Response{data=map[string]string} "重置成功"
// @Failure 500 {object} model.ErrorResponse "服务器错误"
// @Router /api/v1/user/yggdrasil-password/reset [post]
func (h *UserHandler) ResetYggdrasilPassword(c *gin.Context) {
	userID, ok := GetUserIDFromContext(c)
	if !ok {
		return
	}

	newPassword, err := h.container.YggdrasilService.ResetYggdrasilPassword(c.Request.Context(), userID)
	if err != nil {
		h.logger.Error("重置Yggdrasil密码失败", zap.Error(err), zap.Int64("userId", userID))
		RespondServerError(c, "重置Yggdrasil密码失败", nil)
		return
	}

	h.logger.Info("Yggdrasil密码重置成功", zap.Int64("userId", userID))
	RespondSuccess(c, gin.H{"password": newPassword})
}

// GetPublicInfo 获取用户公开信息
// @Summary 获取用户公开信息
// @Description 根据用户名或用户ID获取用户的公开信息（不包含敏感信息如邮箱）
// @Tags user
// @Accept json
// @Produce json
// @Param username query string false "用户名"
// @Param id query int false "用户ID"
// @Success 200 {object} model.Response{data=types.PublicUserInfo} "获取成功"
// @Failure 400 {object} model.ErrorResponse "参数错误"
// @Failure 404 {object} model.ErrorResponse "用户不存在"
// @Router /api/v1/users/public [get]
func (h *UserHandler) GetPublicInfo(c *gin.Context) {
	username := c.Query("username")
	idStr := c.Query("id")

	// 至少需要提供一个参数
	if username == "" && idStr == "" {
		RespondBadRequest(c, "必须提供用户名或用户ID", nil)
		return
	}

	var user *model.User
	var err error

	// 优先使用用户名查询
	if username != "" {
		user, err = h.container.UserService.GetByUsername(c.Request.Context(), username)
	} else {
		// 使用用户ID查询
		id := parseIntWithDefault(idStr, 0)
		if id == 0 {
			RespondBadRequest(c, "无效的用户ID", nil)
			return
		}
		user, err = h.container.UserService.GetByID(c.Request.Context(), int64(id))
	}

	if err != nil || user == nil {
		RespondNotFound(c, "用户不存在")
		return
	}

	// 检查用户状态
	if user.Status != 1 {
		RespondNotFound(c, "用户不可用")
		return
	}

	RespondSuccess(c, UserToPublicUserInfo(user))
}