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/v2/order"
	"github.com/gin-gonic/gin"
	"github.com/go-playground/validator/v10"
	"net/http"
)

type Handler struct {
	service order.Service
}

func NewOrderHandler(service order.Service) *Handler {
	return &Handler{
		service: service,
	}
}

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

	route.POST("/inquiry", jwt, h.Inquiry)
	route.POST("/execute", jwt, h.Execute)
}

type InquiryRequest struct {
	CustomerID          *int64             `json:"customer_id"`
	CustomerName        string             `json:"customer_name" validate:"required_without=CustomerID"`
	CustomerEmail       string             `json:"customer_email"`
	CustomerPhoneNumber string             `json:"customer_phone_number"`
	PaymentMethod       string             `json:"payment_method" validate:"required"`
	OrderItems          []OrderItemRequest `json:"order_items" validate:"required,min=1,dive"`
	OrderType           string             `json:"order_type"`
	PaymentProvider     string             `json:"payment_provider"`
	TableNumber         string             `json:"table_number"`
}

func (o *InquiryRequest) GetPaymentProvider() string {
	if o.PaymentMethod == "CASH" {
		return "CASH"
	}

	return o.PaymentProvider
}

type OrderItemRequest struct {
	ProductID int64 `json:"product_id" validate:"required"`
	Quantity  int   `json:"quantity" validate:"required,min=1"`
}

type ExecuteRequest struct {
	PaymentMethod     string `json:"payment_method" validate:"required"`
	PaymentProvider   string `json:"payment_provider"`
	InProgressOrderID string `json:"in_progress_order_id"`
	Token             string `json:"token"`
}

func (h *Handler) Inquiry(c *gin.Context) {
	ctx := request.GetMyContext(c)
	userID := ctx.RequestedBy()
	partnerID := ctx.GetPartnerID()

	var req InquiryRequest
	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
	}

	orderItems := make([]entity.OrderItemRequest, len(req.OrderItems))
	for i, item := range req.OrderItems {
		orderItems[i] = entity.OrderItemRequest{
			ProductID: item.ProductID,
			Quantity:  item.Quantity,
		}
	}

	orderReq := &entity.OrderRequest{
		Source:              "POS",
		CreatedBy:           userID,
		PartnerID:           *partnerID,
		PaymentMethod:       req.PaymentMethod,
		OrderItems:          orderItems,
		CustomerID:          req.CustomerID,
		CustomerName:        req.CustomerName,
		CustomerEmail:       req.CustomerEmail,
		CustomerPhoneNumber: req.CustomerPhoneNumber,
		OrderType:           req.OrderType,
		PaymentProvider:     req.GetPaymentProvider(),
		TableNumber:         req.TableNumber,
	}

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

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

func (h *Handler) Execute(c *gin.Context) {
	ctx := request.GetMyContext(c)

	var req ExecuteRequest
	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.ExecuteOrderInquiry(ctx, req.Token, req.PaymentMethod, req.PaymentProvider, req.InProgressOrderID)
	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

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