package handler

import (
	"eslogad-be/internal/constants"
	"eslogad-be/internal/contract"
	"eslogad-be/internal/logger"
	"net/http"
	"strconv"

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

type RepositoryAttachmentHandler struct {
	attachmentService RepositoryAttachmentService
}

func NewRepositoryAttachmentHandler(attachmentService RepositoryAttachmentService) *RepositoryAttachmentHandler {
	return &RepositoryAttachmentHandler{
		attachmentService: attachmentService,
	}
}

func (h *RepositoryAttachmentHandler) CreateAttachment(c *gin.Context) {
	var req contract.CreateRepositoryAttachmentRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.FromContext(c).WithError(err).Error("UserHandler::CreateAttachment -> request binding failed")
		h.sendValidationErrorResponse(c, "Invalid request body", constants.MissingFieldErrorCode)
		return
	}

	userResponse, err := h.attachmentService.CreateAttachment(c.Request.Context(), &req)
	if err != nil {
		logger.FromContext(c).WithError(err).Error("UserHandler::CreateAttachment -> Failed to create user from service")
		h.sendErrorResponse(c, err.Error(), http.StatusInternalServerError)
		return
	}

	logger.FromContext(c).Infof("UserHandler::CreateUser -> Successfully created repository attachment = %+v", userResponse)
	c.JSON(http.StatusOK, contract.BuildSuccessResponse(userResponse))
}

func (h *RepositoryAttachmentHandler) DeleteAttachment(c *gin.Context) {
	attachmentIDStr := c.Param("id")
	attachmentID, err := uuid.Parse(attachmentIDStr)
	if err != nil {
		logger.FromContext(c).WithError(err).Error("UserHandler::DeleteAttachment -> Invalid attachment id")
		h.sendValidationErrorResponse(c, "Invalid user ID", constants.MalformedFieldErrorCode)
		return
	}

	err = h.attachmentService.DeleteAttachment(c.Request.Context(), attachmentID)
	if err != nil {
		logger.FromContext(c).WithError(err).Error("UserHandler::DeleteAttachment -> Failed to delete attachment from service")
		h.sendErrorResponse(c, err.Error(), http.StatusInternalServerError)
		return
	}

	logger.FromContext(c).Info("UserHandler::DeleteAttachment -> Successfully deleted attachment")
	c.JSON(http.StatusOK, &contract.SuccessResponse{Message: "User deleted successfully"})
}

func (h *RepositoryAttachmentHandler) GetAttachment(c *gin.Context) {
	attachmentIDStr := c.Param("id")
	attachmentID, err := uuid.Parse(attachmentIDStr)
	if err != nil {
		logger.FromContext(c).WithError(err).Error("UserHandler::GetAttachment -> Invalid attachment ID")
		h.sendValidationErrorResponse(c, "Invalid user ID", constants.MalformedFieldErrorCode)
		return
	}

	attachmentResponse, err := h.attachmentService.GetById(c.Request.Context(), attachmentID)
	if err != nil {
		logger.FromContext(c).WithError(err).Error("UserHandler::GetAttachment -> Failed to get attachment from service")
		h.sendErrorResponse(c, err.Error(), http.StatusInternalServerError)
		return
	}

	logger.FromContext(c).Infof("UserHandler::GetAttachment -> Successfully retrieved attachment = %+v", attachmentResponse)
	c.JSON(http.StatusOK, attachmentResponse)
}
func (h *RepositoryAttachmentHandler) ListAttachment(c *gin.Context) {
	ctx := c.Request.Context()

	req := &contract.ListRepositoryAttachmentsRequest{
		Page:  1,
		Limit: 10,
	}

	if page := c.Query("page"); page != "" {
		if p, err := strconv.Atoi(page); err == nil {
			req.Page = p
		}
	}

	if limit := c.Query("limit"); limit != "" {
		if l, err := strconv.Atoi(limit); err == nil {
			req.Limit = l
		}
	}

	attachmentsResponse, err := h.attachmentService.ListAttachment(ctx, req)
	if err != nil {
		logger.FromContext(c).WithError(err).Error("UserHandler::ListUsers -> Failed to list users from service")
		h.sendErrorResponse(c, err.Error(), http.StatusInternalServerError)
		return
	}

	logger.FromContext(c).Infof("UserHandler::ListUsers -> Successfully listed users = %+v", attachmentsResponse)
	c.JSON(http.StatusOK, contract.BuildSuccessResponse(attachmentsResponse))
}

func (h *RepositoryAttachmentHandler) sendValidationErrorResponse(c *gin.Context, message string, errorCode string) {
	statusCode := constants.HttpErrorMap[errorCode]
	if statusCode == 0 {
		statusCode = http.StatusBadRequest
	}

	errorResponse := &contract.ErrorResponse{
		Error: message,
		Code:  statusCode,
		Details: map[string]interface{}{
			"error_code": errorCode,
			"entity":     constants.UserValidatorEntity,
		},
	}
	c.JSON(statusCode, errorResponse)
}

func (h *RepositoryAttachmentHandler) sendErrorResponse(c *gin.Context, message string, statusCode int) {
	errorResponse := &contract.ErrorResponse{
		Error:   message,
		Code:    statusCode,
		Details: map[string]interface{}{},
	}
	c.JSON(statusCode, errorResponse)
}