package handler

import (
	"lune/talentscale/internal/domain"
	"lune/talentscale/pkg/response"

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

type AuthHandler struct {
	usecase domain.AuthUsecase
}

func NewAuthHandler(usecase domain.AuthUsecase) *AuthHandler {
	return &AuthHandler{usecase: usecase}
}

// RegisterRequest defines the request body for register
type RegisterRequest struct {
	Name     string `json:"name"`
	Email    string `json:"email"`
	Password string `json:"password"`
	Phone    string `json:"phone"`
	RoleID   string `json:"role_id"`
}

// LoginRequest defines the request body for login
type LoginRequest struct {
	Email    string `json:"email"`
	Password string `json:"password"`
}

// Register godoc
// POST /api/v1/auth/register
func (h *AuthHandler) Register(c *fiber.Ctx) error {
	var req RegisterRequest
	if err := c.BodyParser(&req); err != nil {
		return response.BadRequest(c, "Invalid request body: "+err.Error())
	}
	if req.Email == "" || req.Password == "" || req.Name == "" {
		return response.BadRequest(c, "name, email, and password are required")
	}

	user := &domain.User{
		Name:     req.Name,
		Email:    req.Email,
		Password: req.Password,
		Phone:    req.Phone,
	}

	if err := h.usecase.Register(c.Context(), user); err != nil {
		return response.InternalError(c, err.Error())
	}

	// Never return password hash
	user.Password = ""
	return response.Created(c, "User registered successfully", user)
}

// Login godoc
// POST /api/v1/auth/login
func (h *AuthHandler) Login(c *fiber.Ctx) error {
	var req LoginRequest
	if err := c.BodyParser(&req); err != nil {
		return response.BadRequest(c, "Invalid request body: "+err.Error())
	}
	if req.Email == "" || req.Password == "" {
		return response.BadRequest(c, "email and password are required")
	}

	token, user, roleName, permissions, err := h.usecase.Login(c.Context(), req.Email, req.Password)
	if err != nil {
		return response.Unauthorized(c, err.Error())
	}

	// Update response to include actual user and permissions
	return response.OK(c, "Login successful", fiber.Map{
		"token":       token,
		"permissions": permissions,
		"user": fiber.Map{
			"id":           user.ID,
			"email":        user.Email,
			"name":         user.Name,
			"role":         roleName,
			"candidate_id": user.CandidateID,
			"company_id":   user.CompanyID,
		},
	})
}

// Me godoc
// GET /api/v1/auth/me
func (h *AuthHandler) Me(c *fiber.Ctx) error {
	userIDStr, ok := c.Locals("user_id").(string)
	if !ok || userIDStr == "" {
		return response.Unauthorized(c, "Unauthorized")
	}

	userID, err := uuid.Parse(userIDStr)
	if err != nil {
		return response.BadRequest(c, "Invalid user ID")
	}

	user, err := h.usecase.GetMe(c.Context(), userID)
	if err != nil {
		return response.NotFound(c, "User not found")
	}

	return response.OK(c, "User profile retrieved", fiber.Map{"user": user})
}

// Logout godoc
// POST /api/v1/auth/logout
func (h *AuthHandler) Logout(c *fiber.Ctx) error {
	if err := h.usecase.Logout(c.Context()); err != nil {
		return response.InternalError(c, err.Error())
	}
	return response.OK(c, "Logout successful", nil)
}