a301_server/internal/auth/handler.go

package auth

import (
	"log"
	"regexp"
	"strconv"
	"strings"

	"github.com/gofiber/fiber/v2"
)

// usernameRe allows alphanumeric, underscore, hyphen (3-50 chars).
var usernameRe = regexp.MustCompile(`^[a-z0-9_-]{3,50}$`)

type Handler struct {
	svc *Service
}

func NewHandler(svc *Service) *Handler {
	return &Handler{svc: svc}
}

func (h *Handler) Register(c *fiber.Ctx) error {
	var req struct {
		Username string `json:"username"`
		Password string `json:"password"`
	}
	if err := c.BodyParser(&req); err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "잘못된 요청입니다"})
	}
	req.Username = strings.ToLower(strings.TrimSpace(req.Username))
	if req.Username == "" || req.Password == "" {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "아이디와 비밀번호를 입력해주세요"})
	}
	if !usernameRe.MatchString(req.Username) {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "아이디는 3~50자의 영문 소문자, 숫자, _, -만 사용 가능합니다"})
	}
	if len(req.Password) < 6 {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "비밀번호는 6자 이상이어야 합니다"})
	}
	if len(req.Password) > 72 {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "비밀번호는 72자 이하여야 합니다"})
	}
	if err := h.svc.Register(req.Username, req.Password); err != nil {
		if strings.Contains(err.Error(), "이미 사용 중") {
			return c.Status(fiber.StatusConflict).JSON(fiber.Map{"error": err.Error()})
		}
		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": "회원가입에 실패했습니다"})
	}
	return c.Status(fiber.StatusCreated).JSON(fiber.Map{"message": "회원가입이 완료되었습니다"})
}

func (h *Handler) Login(c *fiber.Ctx) error {
	var req struct {
		Username string `json:"username"`
		Password string `json:"password"`
	}
	if err := c.BodyParser(&req); err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "잘못된 요청입니다"})
	}
	req.Username = strings.ToLower(strings.TrimSpace(req.Username))
	if req.Username == "" || req.Password == "" {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "아이디와 비밀번호를 입력해주세요"})
	}
	if len(req.Username) > 50 {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "아이디 또는 비밀번호가 올바르지 않습니다"})
	}
	if len(req.Password) > 72 {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "아이디 또는 비밀번호가 올바르지 않습니다"})
	}

	accessToken, refreshToken, user, err := h.svc.Login(req.Username, req.Password)
	if err != nil {
		log.Printf("Login failed (username=%s): %v", req.Username, err)
		return c.Status(fiber.StatusUnauthorized).JSON(fiber.Map{"error": "아이디 또는 비밀번호가 올바르지 않습니다"})
	}

	c.Cookie(&fiber.Cookie{
		Name:     "refresh_token",
		Value:    refreshToken,
		HTTPOnly: true,
		Secure:   true,
		SameSite: "Strict",
		Path:     "/api/auth/refresh",
		MaxAge:   7 * 24 * 60 * 60, // 7 days
	})
	return c.JSON(fiber.Map{
		"token":    accessToken,
		"username": user.Username,
		"role":     user.Role,
	})
}

func (h *Handler) Refresh(c *fiber.Ctx) error {
	refreshTokenStr := c.Cookies("refresh_token")
	if refreshTokenStr == "" {
		// Fallback to body for backward compatibility
		var req struct {
			RefreshToken string `json:"refreshToken"`
		}
		if err := c.BodyParser(&req); err == nil && req.RefreshToken != "" {
			refreshTokenStr = req.RefreshToken
		}
	}
	if refreshTokenStr == "" {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "refreshToken이 필요합니다"})
	}

	newAccessToken, newRefreshToken, err := h.svc.Refresh(refreshTokenStr)
	if err != nil {
		log.Printf("Refresh failed: %v", err)
		return c.Status(fiber.StatusUnauthorized).JSON(fiber.Map{"error": "토큰 갱신에 실패했습니다"})
	}

	c.Cookie(&fiber.Cookie{
		Name:     "refresh_token",
		Value:    newRefreshToken,
		HTTPOnly: true,
		Secure:   true,
		SameSite: "Strict",
		Path:     "/api/auth/refresh",
		MaxAge:   7 * 24 * 60 * 60, // 7 days
	})
	return c.JSON(fiber.Map{
		"token": newAccessToken,
	})
}

func (h *Handler) Logout(c *fiber.Ctx) error {
	userID, ok := c.Locals("userID").(uint)
	if !ok {
		return c.Status(fiber.StatusUnauthorized).JSON(fiber.Map{"error": "인증 정보가 올바르지 않습니다"})
	}
	if err := h.svc.Logout(userID); err != nil {
		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": "로그아웃 처리 중 오류가 발생했습니다"})
	}
	c.Cookie(&fiber.Cookie{
		Name:     "refresh_token",
		Value:    "",
		HTTPOnly: true,
		Secure:   true,
		SameSite: "Strict",
		Path:     "/api/auth/refresh",
		MaxAge:   -1, // delete
	})
	return c.JSON(fiber.Map{"message": "로그아웃 되었습니다"})
}

func (h *Handler) GetAllUsers(c *fiber.Ctx) error {
	offset := c.QueryInt("offset", 0)
	limit := c.QueryInt("limit", 50)
	if limit <= 0 || limit > 100 {
		limit = 50
	}
	if offset < 0 {
		offset = 0
	}
	users, err := h.svc.GetAllUsers(offset, limit)
	if err != nil {
		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": "유저 목록을 불러오지 못했습니다"})
	}
	return c.JSON(users)
}

func (h *Handler) UpdateRole(c *fiber.Ctx) error {
	id, err := strconv.ParseUint(c.Params("id"), 10, 64)
	if err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "유효하지 않은 유저 ID입니다"})
	}
	var body struct {
		Role string `json:"role"`
	}
	if err := c.BodyParser(&body); err != nil || (body.Role != "admin" && body.Role != "user") {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "role은 admin 또는 user여야 합니다"})
	}
	uid := uint(id)
	if err := h.svc.UpdateRole(uid, Role(body.Role)); err != nil {
		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": "권한 변경에 실패했습니다"})
	}
	// 역할 변경 시 기존 세션 무효화 (새 권한으로 재로그인 유도)
	_ = h.svc.Logout(uid)
	return c.JSON(fiber.Map{"message": "권한이 변경되었습니다"})
}

func (h *Handler) VerifyToken(c *fiber.Ctx) error {
	var req struct {
		Token string `json:"token"`
	}
	if err := c.BodyParser(&req); err != nil || req.Token == "" {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "token 필드가 필요합니다"})
	}

	username, err := h.svc.VerifyToken(req.Token)
	if err != nil {
		return c.Status(fiber.StatusUnauthorized).JSON(fiber.Map{"error": err.Error()})
	}

	return c.JSON(fiber.Map{
		"username": username,
	})
}

func (h *Handler) SSAFYLoginURL(c *fiber.Ctx) error {
	loginURL, err := h.svc.GetSSAFYLoginURL()
	if err != nil {
		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": "SSAFY 로그인 URL 생성에 실패했습니다"})
	}
	return c.JSON(fiber.Map{"url": loginURL})
}

func (h *Handler) SSAFYCallback(c *fiber.Ctx) error {
	var req struct {
		Code  string `json:"code"`
		State string `json:"state"`
	}
	if err := c.BodyParser(&req); err != nil || req.Code == "" {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "인가 코드가 필요합니다"})
	}
	if req.State == "" {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "state 파라미터가 필요합니다"})
	}

	accessToken, refreshToken, user, err := h.svc.SSAFYLogin(req.Code, req.State)
	if err != nil {
		log.Printf("SSAFY login failed: %v", err)
		return c.Status(fiber.StatusUnauthorized).JSON(fiber.Map{"error": "SSAFY 로그인에 실패했습니다"})
	}

	c.Cookie(&fiber.Cookie{
		Name:     "refresh_token",
		Value:    refreshToken,
		HTTPOnly: true,
		Secure:   true,
		SameSite: "Strict",
		Path:     "/api/auth/refresh",
		MaxAge:   7 * 24 * 60 * 60, // 7 days
	})
	return c.JSON(fiber.Map{
		"token":    accessToken,
		"username": user.Username,
		"role":     user.Role,
	})
}

// CreateLaunchTicket issues a one-time ticket for the game launcher.
// The launcher uses this ticket instead of receiving the JWT directly in the URL.
func (h *Handler) CreateLaunchTicket(c *fiber.Ctx) error {
	userID, ok := c.Locals("userID").(uint)
	if !ok {
		return c.Status(fiber.StatusUnauthorized).JSON(fiber.Map{"error": "인증 정보가 올바르지 않습니다"})
	}
	ticket, err := h.svc.CreateLaunchTicket(userID)
	if err != nil {
		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": "티켓 발급에 실패했습니다"})
	}
	return c.JSON(fiber.Map{"ticket": ticket})
}

// RedeemLaunchTicket exchanges a one-time ticket for an access token.
// Called by the game launcher, not the web browser.
func (h *Handler) RedeemLaunchTicket(c *fiber.Ctx) error {
	var req struct {
		Ticket string `json:"ticket"`
	}
	if err := c.BodyParser(&req); err != nil || req.Ticket == "" {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "ticket 필드가 필요합니다"})
	}
	token, err := h.svc.RedeemLaunchTicket(req.Ticket)
	if err != nil {
		log.Printf("RedeemLaunchTicket failed: %v", err)
		return c.Status(fiber.StatusUnauthorized).JSON(fiber.Map{"error": "유효하지 않거나 만료된 티켓입니다"})
	}
	return c.JSON(fiber.Map{"token": token})
}

func (h *Handler) DeleteUser(c *fiber.Ctx) error {
	id, err := strconv.ParseUint(c.Params("id"), 10, 64)
	if err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "유효하지 않은 유저 ID입니다"})
	}
	if err := h.svc.DeleteUser(uint(id)); err != nil {
		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": "유저 삭제에 실패했습니다"})
	}
	return c.SendStatus(fiber.StatusNoContent)
}