package http

import (
	"enaklo-pos-be/internal/common/errors"
	"enaklo-pos-be/internal/entity"
	"enaklo-pos-be/internal/handlers/request"
	"enaklo-pos-be/internal/handlers/response"
	"enaklo-pos-be/internal/services/member"
	"github.com/gin-gonic/gin"
	"github.com/go-playground/validator/v10"
	"net/http"
)

type MemberHandler struct {
	service member.RegistrationService
}

func NewMemberRegistrationHandler(service member.RegistrationService) *MemberHandler {
	return &MemberHandler{
		service: service,
	}
}

func (h *MemberHandler) Route(group *gin.RouterGroup, jwt gin.HandlerFunc) {
	route := group.Group("/member")

	route.POST("/register", jwt, h.InitiateRegistration)
	route.POST("/verify", jwt, h.VerifyOTP)
	route.GET("/status", jwt, h.GetRegistrationStatus)
	route.POST("/resend-otp", jwt, h.ResendOTP)
	route.GET("/list", jwt, h.GetRegistrationStatus)
}

func (h *MemberHandler) InitiateRegistration(c *gin.Context) {
	ctx := request.GetMyContext(c)
	userID := ctx.RequestedBy()

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

	validate := validator.New()
	if err := validate.Struct(req); err != nil {
		response.ErrorWrapper(c, err)
		return
	}

	birthDate, err := req.GetBirthdate()
	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

	memberReq := &entity.MemberRegistrationRequest{
		Name:      req.Name,
		Email:     req.Email,
		Phone:     req.Phone,
		BirthDate: birthDate,
		BranchID:  *ctx.GetPartnerID(),
		CashierID: userID,
	}

	result, err := h.service.InitiateRegistration(ctx, memberReq)
	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

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

func (h *MemberHandler) VerifyOTP(c *gin.Context) {
	ctx := request.GetMyContext(c)

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

	validate := validator.New()
	if err := validate.Struct(req); err != nil {
		response.ErrorWrapper(c, err)
		return
	}

	result, err := h.service.VerifyOTP(ctx, req.Token, req.OTP)
	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

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

func (h *MemberHandler) GetRegistrationStatus(c *gin.Context) {
	ctx := request.GetMyContext(c)
	token := c.Query("token")

	if token == "" {
		response.ErrorWrapper(c, errors.ErrorBadRequest)
		return
	}

	result, err := h.service.GetRegistrationStatus(ctx, token)
	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

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

func (h *MemberHandler) ResendOTP(c *gin.Context) {
	ctx := request.GetMyContext(c)

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

	validate := validator.New()
	if err := validate.Struct(req); err != nil {
		response.ErrorWrapper(c, err)
		return
	}

	result, err := h.service.ResendOTP(ctx, req.Token)
	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

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