package handlers
 
 import (
 	"net/http"
 	"strconv"
 
 	"github.com/gin-gonic/gin"
 	"github.com/inchstep/server/internal/middleware"
 	"github.com/inchstep/server/internal/models"
 	"github.com/inchstep/server/internal/services"
 )
 
 type SocialHandler struct {
 	socialSvc *services.SocialService
 }
 
 func NewSocialHandler(svc *services.SocialService) *SocialHandler {
 	return &SocialHandler{socialSvc: svc}
 }
 
 // ---------- 好友 ----------
 
 type friendReq struct {
 	FriendID string `json:"friendId" binding:"required"`
 }
 
 func (h *SocialHandler) SendFriendRequest(c *gin.Context) {
 	userID := middleware.GetUserID(c)
 	var req friendReq
 	if err := c.ShouldBindJSON(&req); err != nil {
 		middleware.Error(c, http.StatusBadRequest, 400, "参数格式错误")
 		return
 	}
 	if err := h.socialSvc.SendFriendRequest(userID, req.FriendID); err != nil {
 		middleware.Error(c, http.StatusBadRequest, 400, err.Error())
 		return
 	}
 	middleware.Success(c, nil)
 }
 
 func (h *SocialHandler) AcceptFriendRequest(c *gin.Context) {
 	userID := middleware.GetUserID(c)
 	var req friendReq
 	if err := c.ShouldBindJSON(&req); err != nil {
 		middleware.Error(c, http.StatusBadRequest, 400, "参数格式错误")
 		return
 	}
 	if err := h.socialSvc.AcceptFriendRequest(userID, req.FriendID); err != nil {
 		middleware.Error(c, http.StatusInternalServerError, 500, err.Error())
 		return
 	}
 	middleware.Success(c, nil)
 }
 
 func (h *SocialHandler) RemoveFriend(c *gin.Context) {
 	userID := middleware.GetUserID(c)
 	friendID := c.Param("userId")
 	if err := h.socialSvc.RemoveFriend(userID, friendID); err != nil {
 		middleware.Error(c, http.StatusInternalServerError, 500, err.Error())
 		return
 	}
 	middleware.Success(c, nil)
 }
 
 func (h *SocialHandler) ListFriends(c *gin.Context) {
 	userID := middleware.GetUserID(c)
 	friends, err := h.socialSvc.GetFriends(userID)
 	if err != nil {
 		middleware.Error(c, http.StatusInternalServerError, 500, err.Error())
 		return
 	}
 	middleware.Success(c, friends)
 }
 
 // ---------- 动态 ----------
 
 type createPostReq struct {
 	Content *string `json:"content,omitempty"`
 	Images  *string `json:"images,omitempty"`
 	Privacy int     `json:"privacy"`
 }
 
 func (h *SocialHandler) CreatePost(c *gin.Context) {
 	userID := middleware.GetUserID(c)
 	var req createPostReq
 	if err := c.ShouldBindJSON(&req); err != nil {
 		middleware.Error(c, http.StatusBadRequest, 400, "参数格式错误")
 		return
 	}
 	post := &models.Post{
 		UserID:  userID,
 		Content: req.Content,
 		Images:  req.Images,
 		Privacy: req.Privacy,
 	}
 	if err := h.socialSvc.CreatePost(post); err != nil {
 		middleware.Error(c, http.StatusInternalServerError, 500, err.Error())
 		return
 	}
 	middleware.Success(c, post)
 }
 
 func (h *SocialHandler) GetFeed(c *gin.Context) {
 	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
 	pageSize, _ := strconv.Atoi(c.DefaultQuery("pageSize", "20"))
 	if page < 1 {
 		page = 1
 	}
 	if pageSize < 1 || pageSize > 100 {
 		pageSize = 20
 	}
 	posts, total, err := h.socialSvc.GetFeed(page, pageSize)
 	if err != nil {
 		middleware.Error(c, http.StatusInternalServerError, 500, err.Error())
 		return
 	}
 	middleware.Success(c, gin.H{
 		"list":  posts,
 		"total": total,
 		"page":  page,
 	})
 }
 
 func (h *SocialHandler) LikePost(c *gin.Context) {
 	postID := c.Param("id")
 	if err := h.socialSvc.LikePost(postID); err != nil {
 		middleware.Error(c, http.StatusInternalServerError, 500, err.Error())
 		return
 	}
 	middleware.Success(c, nil)
 }
 
 func (h *SocialHandler) CommentPost(c *gin.Context) {
 	postID := c.Param("id")
 	if err := h.socialSvc.CommentPost(postID); err != nil {
 		middleware.Error(c, http.StatusInternalServerError, 500, err.Error())
 		return
 	}
 	middleware.Success(c, nil)
 }
 
 // ---------- 小组 ----------
 
 func (h *SocialHandler) CreateGroup(c *gin.Context) {
 	userID := middleware.GetUserID(c)
 	var group models.Group
 	if err := c.ShouldBindJSON(&group); err != nil {
 		middleware.Error(c, http.StatusBadRequest, 400, "参数格式错误")
 		return
 	}
 	if err := h.socialSvc.CreateGroup(userID, &group); err != nil {
 		middleware.Error(c, http.StatusInternalServerError, 500, err.Error())
 		return
 	}
 	middleware.Success(c, group)
 }
 
 func (h *SocialHandler) JoinGroup(c *gin.Context) {
 	userID := middleware.GetUserID(c)
 	groupID := c.Param("id")
 	if err := h.socialSvc.JoinGroup(groupID, userID); err != nil {
 		middleware.Error(c, http.StatusInternalServerError, 500, err.Error())
 		return
 	}
 	middleware.Success(c, nil)
 }
 
 func (h *SocialHandler) LeaveGroup(c *gin.Context) {
 	userID := middleware.GetUserID(c)
 	groupID := c.Param("id")
 	if err := h.socialSvc.LeaveGroup(groupID, userID); err != nil {
 		middleware.Error(c, http.StatusInternalServerError, 500, err.Error())
 		return
 	}
 	middleware.Success(c, nil)
 }
 
 func (h *SocialHandler) GetGroupMembers(c *gin.Context) {
 	groupID := c.Param("id")
 	members, err := h.socialSvc.GetGroupMembers(groupID)
 	if err != nil {
 		middleware.Error(c, http.StatusInternalServerError, 500, err.Error())
 		return
 	}
 	middleware.Success(c, members)
 }
 
 // ---------- 成就 ----------
 
 type AchievementHandler struct {
 	pointsSvc *services.PointsService
 }
 
 func NewAchievementHandler(ps *services.PointsService) *AchievementHandler {
 	return &AchievementHandler{pointsSvc: ps}
 }
 
 func (h *AchievementHandler) ListAll(c *gin.Context) {
 	list, err := h.pointsSvc.GetAllAchievements()
 	if err != nil {
 		middleware.Error(c, http.StatusInternalServerError, 500, err.Error())
 		return
 	}
 	middleware.Success(c, list)
 }
 
 func (h *AchievementHandler) ListUserAchievements(c *gin.Context) {
 	userID := middleware.GetUserID(c)
 	list, err := h.pointsSvc.GetUserAchievements(userID)
 	if err != nil {
 		middleware.Error(c, http.StatusInternalServerError, 500, err.Error())
 		return
 	}
 	middleware.Success(c, list)
 }