package shortcuts

import "github.com/gofiber/fiber/v2"

type ErrorKind string

const (
	BadRequest    ErrorKind = "bad_request"
	Forbidden     ErrorKind = "forbidden"
	Internal      ErrorKind = "internal"
	NotFound      ErrorKind = "not_found"
	Unauthorized  ErrorKind = "unauthorized"
	Unprocessable ErrorKind = "unprocessable"
)

type Error struct {
	Kind    ErrorKind
	Message string
}

func (self *Error) Error() string {
	return self.Message
}

var statusMap = map[ErrorKind]int{
	BadRequest:    fiber.StatusBadRequest,
	Forbidden:     fiber.StatusForbidden,
	Internal:      fiber.StatusInternalServerError,
	NotFound:      fiber.StatusNotFound,
	Unauthorized:  fiber.StatusUnauthorized,
	Unprocessable: fiber.StatusUnprocessableEntity,
}

func ServiceError(kind ErrorKind, message string) *Error {
	return &Error{
		Kind:    kind,
		Message: message,
	}
}

func isHtmxRequest(context *fiber.Ctx) bool {
	return context.Get("HX-Request") == "true" && context.Get("HX-Boosted") != "true"
}

func renderAlert(context *fiber.Ctx, message string, statusCode int) error {
	context.Status(statusCode)
	return context.Render("partials/alert", fiber.Map{
		"ErrorMessage": message,
	})
}

func HandleError(context *fiber.Ctx, serviceError *Error) error {
	statusCode, exists := statusMap[serviceError.Kind]
	if !exists {
		statusCode = fiber.StatusInternalServerError
	}

	if isHtmxRequest(context) {
		return renderAlert(context, serviceError.Message, statusCode)
	}

	return RenderWithStatus(context, "error", fiber.Map{
		"ErrorMessage": serviceError.Message,
	}, statusCode)
}

func BadRequestError(context *fiber.Ctx, err error) error {
	if isHtmxRequest(context) {
		return renderAlert(context, err.Error(), fiber.StatusBadRequest)
	}

	return RenderWithStatus(context, "error", fiber.Map{
		"ErrorMessage": err.Error(),
	}, fiber.StatusBadRequest)
}

func ForbiddenError(context *fiber.Ctx, err error) error {
	if isHtmxRequest(context) {
		return renderAlert(context, err.Error(), fiber.StatusForbidden)
	}

	return RenderWithStatus(context, "error", fiber.Map{
		"ErrorMessage": err.Error(),
	}, fiber.StatusForbidden)
}

func InternalServerError(context *fiber.Ctx, err error) error {
	if isHtmxRequest(context) {
		return renderAlert(context, err.Error(), fiber.StatusInternalServerError)
	}

	return RenderWithStatus(context, "error", fiber.Map{
		"ErrorMessage": err.Error(),
	}, fiber.StatusInternalServerError)
}

func NotFoundError(context *fiber.Ctx, err error) error {
	if isHtmxRequest(context) {
		return renderAlert(context, err.Error(), fiber.StatusNotFound)
	}

	return RenderWithStatus(context, "error", fiber.Map{
		"ErrorMessage": err.Error(),
	}, fiber.StatusNotFound)
}

func UnauthorizedError(context *fiber.Ctx, err error) error {
	if isHtmxRequest(context) {
		return renderAlert(context, err.Error(), fiber.StatusUnauthorized)
	}

	return RenderWithStatus(context, "error", fiber.Map{
		"ErrorMessage": err.Error(),
	}, fiber.StatusUnauthorized)
}