package customerauth

import (
	"fmt"
	"net/http"
	"strings"

	"github.com/gin-gonic/gin"

	"enaklo-pos-be/internal/common/errors"
	auth2 "enaklo-pos-be/internal/handlers/request"
	"enaklo-pos-be/internal/handlers/response"
	"enaklo-pos-be/internal/services"
)

type AuthHandler struct {
	service     services.Auth
	userService services.User
}

func (a *AuthHandler) Route(group *gin.RouterGroup, jwt gin.HandlerFunc) {
	authRoute := group.Group("/auth")
	authRoute.POST("/login", a.AuthLogin)
	authRoute.POST("/forgot-password", a.ForgotPassword)
	authRoute.POST("/reset-password", jwt, a.ResetPassword)
	authRoute.POST("/register", a.Register)
}

func NewAuthHandler(service services.Auth, userService services.User) *AuthHandler {
	return &AuthHandler{
		service:     service,
		userService: userService,
	}
}

// AuthLogin handles the authentication process for user login.
// @Summary User login
// @Description Authenticates a user based on the provided credentials and returns a JWT token.
// @Accept json
// @Produce json
// @Param bodyParam body auth2.LoginRequest true "User login credentials"
// @Success 200 {object} response.BaseResponse{data=response.LoginResponse} "Login successful"
// @Failure 400 {object} response.BaseResponse{data=errors.Error} "Bad request"
// @Failure 401 {object} response.BaseResponse{data=errors.Error} "Unauthorized"
// @Router /api/v1/auth/login [post]
// @Tags Auth Login API's
func (h *AuthHandler) AuthLogin(c *gin.Context) {
	var bodyParam auth2.LoginRequest
	if err := c.ShouldBindJSON(&bodyParam); err != nil {
		response.ErrorWrapper(c, errors.ErrorBadRequest)
		return
	}
	email := strings.ToLower(bodyParam.Email)
	authUser, err := h.service.AuthenticateUser(c, email, bodyParam.Password)
	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

	if authUser.UserType != "CUSTOMER" {
		response.ErrorWrapper(c, errors.ErrorUserIsNotFound)
		return
	}

	resp := response.LoginResponseCustoemr{
		ID:            authUser.ID,
		Token:         authUser.Token,
		Name:          authUser.Name,
		ResetPassword: authUser.ResetPassword,
	}

	c.JSON(http.StatusOK, response.BaseResponse{
		Success: true,
		Status:  http.StatusOK,
		Message: "Login Success",
		Data:    resp,
	})
}

// ForgotPassword handles the request for password reset.
// @Summary Request password reset
// @Description Sends a password reset link to the user's email.
// @Accept json
// @Produce json
// @Param bodyParam body auth2.ForgotPasswordRequest true "User email"
// @Success 200 {object} response.BaseResponse "Password reset link sent"
// @Failure 400 {object} response.BaseResponse{data=errors.Error} "Bad request"
// @Router /api/v1/auth/forgot-password [post]
// @Tags Auth Password API's
func (h *AuthHandler) ForgotPassword(c *gin.Context) {
	var bodyParam auth2.ResetPasswordRequest
	if err := c.ShouldBindJSON(&bodyParam); err != nil {
		response.ErrorWrapper(c, errors.ErrorBadRequest)
		return
	}

	err := h.service.SendPasswordResetLink(c, bodyParam.Email)
	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

	c.JSON(http.StatusOK, response.BaseResponse{
		Success: true,
		Status:  http.StatusOK,
		Message: "Password reset link sent",
	})
}

// ResetPassword handles the password reset process.
// @Summary Reset user password
// @Description Resets the user's password using the provided token.
// @Accept json
// @Produce json
// @Param bodyParam body auth2.ResetPasswordRequest true "Reset password details"
// @Success 200 {object} response.BaseResponse "Password reset successful"
// @Failure 400 {object} response.BaseResponse{data=errors.Error} "Bad request"
// @Router /api/v1/auth/reset-password [post]
// @Tags Auth Password API's
func (h *AuthHandler) ResetPassword(c *gin.Context) {
	ctx := auth2.GetMyContext(c)

	var req auth2.ResetPasswordChangeRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.ErrorWrapper(c, errors.ErrorBadRequest)
		return
	}

	if err := req.Validate(); err != nil {
		response.ErrorWrapper(c, errors.NewError(
			errors.ErrorBadRequest.ErrorType(),
			fmt.Sprintf("invalid request %v", err.Error())))
		return
	}

	err := h.service.ResetPassword(ctx, req.OldPassword, req.NewPassword)
	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

	c.JSON(http.StatusOK, response.BaseResponse{
		Success: true,
		Status:  http.StatusOK,
		Message: "Password reset successful",
	})
}

func (h *AuthHandler) Register(c *gin.Context) {
	var req auth2.UserRegister
	if err := c.ShouldBindJSON(&req); err != nil {
		response.ErrorWrapper(c, errors.ErrorBadRequest)
		return
	}

	ctx := auth2.GetMyContext(c)
	res, err := h.userService.Create(ctx, req.ToEntity())
	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

	resp := response.UserRegister{
		ID:        res.ID,
		Name:      res.Name,
		Email:     res.Email,
		Status:    string(res.Status),
		CreatedAt: res.CreatedAt,
		UpdatedAt: res.UpdatedAt,
	}

	c.JSON(http.StatusOK, response.BaseResponse{
		Success: true,
		Status:  http.StatusOK,
		Data:    resp,
	})
}