package http

import (
	"enaklo-pos-be/internal/common/errors"
	"enaklo-pos-be/internal/handlers/request"
	"enaklo-pos-be/internal/handlers/response"
	"enaklo-pos-be/internal/services/v2/cashier_session"
	"net/http"
	"strconv"

	"github.com/gin-gonic/gin"
)

type CashierSessionHandler struct {
	service cashier_session.Service
}

func NewCashierSession(service cashier_session.Service) *CashierSessionHandler {
	return &CashierSessionHandler{
		service: service,
	}
}

func (h *CashierSessionHandler) Route(group *gin.RouterGroup, jwt gin.HandlerFunc) {
	route := group.Group("/cashier-sessions")
	route.Use(jwt)

	route.POST("/open", h.OpenSession)
	route.POST("/close/:id", h.CloseSession)
	route.GET("/open", h.GetOpenSession)
	route.GET("/report/:id", h.GetSessionReport)
	route.GET("/history", h.GetSessionHistory)
}

func (h *CashierSessionHandler) OpenSession(c *gin.Context) {
	ctx := request.GetMyContext(c)

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

	session, err := h.service.OpenSession(ctx, req.ToEntity(ctx.RequestedBy()))
	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

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

func (h *CashierSessionHandler) CloseSession(c *gin.Context) {
	ctx := request.GetMyContext(c)
	idStr := c.Param("id")
	sessionID, err := strconv.ParseInt(idStr, 10, 64)
	if err != nil {
		response.ErrorWrapper(c, errors.ErrorBadRequest)
		return
	}

	var body struct {
		ClosingAmount float64 `json:"closing_amount"`
	}

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

	report, err := h.service.CloseSession(ctx, sessionID, body.ClosingAmount)
	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

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

func (h *CashierSessionHandler) GetOpenSession(c *gin.Context) {
	ctx := request.GetMyContext(c)

	cashierID := ctx.RequestedBy()

	session, err := h.service.GetOpenSession(ctx, cashierID)
	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

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

func (h *CashierSessionHandler) GetSessionReport(c *gin.Context) {
	ctx := request.GetMyContext(c)
	idStr := c.Param("id")

	sessionID, err := strconv.ParseInt(idStr, 10, 64)
	if err != nil {
		response.ErrorWrapper(c, errors.ErrorBadRequest)
		return
	}

	report, err := h.service.GetSessionReport(ctx, sessionID)
	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

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

func (h *CashierSessionHandler) GetSessionHistory(c *gin.Context) {
	ctx := request.GetMyContext(c)
	partnerID := ctx.GetPartnerID()

	// Parse query parameters
	limitStr := c.DefaultQuery("limit", "10")
	offsetStr := c.DefaultQuery("offset", "0")

	limit, err := strconv.Atoi(limitStr)
	if err != nil || limit < 0 {
		limit = 10
	}
	if limit > 50 {
		limit = 50
	}

	offset, err := strconv.Atoi(offsetStr)
	if err != nil || offset < 0 {
		offset = 0
	}

	sessions, total, err := h.service.GetSessionHistory(ctx, *partnerID, limit, offset)
	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

	responseData := make([]*response.CashierSessionResponse, len(sessions))
	for i, session := range sessions {
		responseData[i] = response.MapToCashierSessionResponse(session)
	}

	pagingMeta := response.NewPaginationHelper().BuildPagingMeta(offset, limit, total)

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