package users

import (
	"errors"
	"github.com/go-playground/validator/v10"
	"mangezmieux-backend/internal/logger"
	"mangezmieux-backend/internal/middleware"
	"mangezmieux-backend/internal/responses"
	"mangezmieux-backend/internal/users/model"
	"mangezmieux-backend/internal/users/service"

	"net/http"
	"strings"

	"github.com/gin-gonic/gin"
	coreValidator "mangezmieux-backend/internal/validator"
)

type Handler struct {
	Service   *service.Service
	Validator *validator.Validate
}

func NewHandler(service *service.Service, validator *validator.Validate) *Handler {
	return &Handler{
		Service:   service,
		Validator: validator,
	}
}

func (h Handler) CreateUser(context *gin.Context) {
	userEditable := model.UserEditable{}
	if err := context.BindJSON(&userEditable); err != nil {
		responses.JSONError(context.Writer, coreValidator.NewDataValidationAPIError(err))
		return
	}
	user, err := h.Service.CreateUser(&userEditable)
	if err != nil {
		logger.GetLogger().Error(err)
		var apiError *responses.APIError
		if errors.As(err, &apiError) {
			responses.JSONError(context.Writer, *apiError)
			return
		}
		responses.JSONErrorWithMessage(context.Writer, responses.ErrInternalServer, err.Error())
		return
	}
	responses.JSON(context.Writer, http.StatusCreated, user)
}

func (h Handler) Login(context *gin.Context) {
	userLoginRequest := model.UserLoginRequest{}
	if err := context.BindJSON(&userLoginRequest); err != nil {
		responses.JSONError(context.Writer, coreValidator.NewDataValidationAPIError(err))
		return
	}
	token, err := h.Service.Login(userLoginRequest)
	if err != nil {
		logger.GetLogger().Error(err)
		var apiError *responses.APIError
		if errors.As(err, &apiError) {
			responses.JSONError(context.Writer, *apiError)
			return
		}
		responses.JSONErrorWithMessage(context.Writer, responses.ErrInternalServer, err.Error())
		return
	}
	context.SetCookie("token", token, 10, "/", "localhost", true, false)
	userLoginResponse := model.UserLoginResponse{
		AccessToken: token,
		TokenType:   "Bearer",
	}
	responses.JSON(context.Writer, http.StatusOK, userLoginResponse)
}

func (h Handler) IntrospectToken(context *gin.Context) {
	authorization := context.Request.Header.Get("Authorization")
	splitToken := strings.Split(authorization, "Bearer ")
	reqToken := splitToken[1]
	user, err := h.Service.Introspect(reqToken)
	if err != nil {
		logger.GetLogger().Error(err)
		var apiError *responses.APIError
		if errors.As(err, &apiError) {
			responses.JSONError(context.Writer, *apiError)
			return
		}
		responses.JSONErrorWithMessage(context.Writer, responses.ErrInternalServer, err.Error())
		return

	}
	responses.JSON(context.Writer, http.StatusOK, user)
}

func (h Handler) RefreshToken(context *gin.Context) {
	authorization := context.Request.Header.Get("Authorization")
	splitToken := strings.Split(authorization, "Bearer ")
	reqToken := splitToken[1]

	refreshedToken, err := h.Service.Refresh(reqToken)
	if err != nil {
		logger.GetLogger().Error(err)
		var apiError *responses.APIError
		if errors.As(err, &apiError) {
			responses.JSONError(context.Writer, *apiError)
			return
		}
		responses.JSONErrorWithMessage(context.Writer, responses.ErrInternalServer, err.Error())
		return

	}
	context.SetCookie("token", refreshedToken, 10, "/", "localhost", true, false)
}

func (h Handler) GetMe(context *gin.Context) {
	usr, exists := context.Get(middleware.CtxUser)
	if !exists {
		responses.JSONErrorWithMessage(context.Writer, responses.ErrInternalServer, "User not found in context")
		return
	}
	responses.JSON(context.Writer, http.StatusOK, usr)

}