package restricted

import (
	"strconv"
	"time"

	"git.ma-al.com/goc_daniel/b2b/app/config"
	"git.ma-al.com/goc_daniel/b2b/app/model"
	"git.ma-al.com/goc_daniel/b2b/app/service/specificPriceService"
	"git.ma-al.com/goc_daniel/b2b/app/utils/responseErrors"
	"github.com/gofiber/fiber/v3"
)

type SpecificPriceHandler struct {
	SpecificPriceService *specificPriceService.SpecificPriceService
	config               *config.Config
}

func NewSpecificPriceHandler() *SpecificPriceHandler {
	SpecificPriceService := specificPriceService.New()
	return &SpecificPriceHandler{
		SpecificPriceService: SpecificPriceService,
		config:               config.Get(),
	}
}

func SpecificPriceHandlerRoutes(r fiber.Router) fiber.Router {
	handler := NewSpecificPriceHandler()

	r.Post("/", handler.Create)
	r.Put("/:id", handler.Update)
	r.Delete("/:id", handler.Delete)
	r.Get("/", handler.List)
	r.Get("/:id", handler.GetByID)
	r.Patch("/:id/activate", handler.Activate)
	r.Patch("/:id/deactivate", handler.Deactivate)

	return r
}

func (h *SpecificPriceHandler) Create(c fiber.Ctx) error {
	var pr model.SpecificPrice
	if err := c.Bind().Body(&pr); err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
			"error": responseErrors.GetErrorCode(c, responseErrors.ErrInvalidBody),
		})
	}

	result, err := h.SpecificPriceService.Create(c.Context(), &pr)
	if err != nil {
		return c.Status(responseErrors.GetErrorStatus(err)).JSON(fiber.Map{
			"error": responseErrors.GetErrorCode(c, err),
		})
	}

	return c.Status(fiber.StatusCreated).JSON(result)
}

func (h *SpecificPriceHandler) Update(c fiber.Ctx) error {
	idStr := c.Params("id")
	id, err := strconv.ParseUint(idStr, 10, 64)
	if err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
			"error": responseErrors.GetErrorCode(c, responseErrors.ErrInvalidBody),
		})
	}

	var pr model.SpecificPrice
	if err := c.Bind().Body(&pr); err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
			"error": responseErrors.GetErrorCode(c, responseErrors.ErrInvalidBody),
		})
	}

	result, err := h.SpecificPriceService.Update(c.Context(), id, &pr)
	if err != nil {
		return c.Status(responseErrors.GetErrorStatus(err)).JSON(fiber.Map{
			"error": responseErrors.GetErrorCode(c, err),
		})
	}

	return c.JSON(result)
}

func (h *SpecificPriceHandler) List(c fiber.Ctx) error {
	result, err := h.SpecificPriceService.List(c.Context())
	if err != nil {
		return c.Status(responseErrors.GetErrorStatus(err)).JSON(fiber.Map{
			"error": responseErrors.GetErrorCode(c, err),
		})
	}

	return c.JSON(result)
}

func (h *SpecificPriceHandler) GetByID(c fiber.Ctx) error {
	idStr := c.Params("id")
	id, err := strconv.ParseUint(idStr, 10, 64)
	if err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
			"error": responseErrors.GetErrorCode(c, responseErrors.ErrInvalidBody),
		})
	}

	result, err := h.SpecificPriceService.GetByID(c.Context(), id)
	if err != nil {
		return c.Status(responseErrors.GetErrorStatus(err)).JSON(fiber.Map{
			"error": responseErrors.GetErrorCode(c, err),
		})
	}

	return c.JSON(result)
}

func (h *SpecificPriceHandler) Activate(c fiber.Ctx) error {
	idStr := c.Params("id")
	id, err := strconv.ParseUint(idStr, 10, 64)
	if err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
			"error": responseErrors.GetErrorCode(c, responseErrors.ErrInvalidBody),
		})
	}

	err = h.SpecificPriceService.SetActive(c.Context(), id, true)
	if err != nil {
		return c.Status(responseErrors.GetErrorStatus(err)).JSON(fiber.Map{
			"error": responseErrors.GetErrorCode(c, err),
		})
	}

	return c.JSON(fiber.Map{
		"message": "price reduction activated",
	})
}

func (h *SpecificPriceHandler) Deactivate(c fiber.Ctx) error {
	idStr := c.Params("id")
	id, err := strconv.ParseUint(idStr, 10, 64)
	if err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
			"error": responseErrors.GetErrorCode(c, responseErrors.ErrInvalidBody),
		})
	}

	err = h.SpecificPriceService.SetActive(c.Context(), id, false)
	if err != nil {
		return c.Status(responseErrors.GetErrorStatus(err)).JSON(fiber.Map{
			"error": responseErrors.GetErrorCode(c, err),
		})
	}

	return c.JSON(fiber.Map{
		"message": "price reduction deactivated",
	})
}

func (h *SpecificPriceHandler) Delete(c fiber.Ctx) error {
	idStr := c.Params("id")
	id, err := strconv.ParseUint(idStr, 10, 64)
	if err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
			"error": responseErrors.GetErrorCode(c, responseErrors.ErrInvalidBody),
		})
	}

	err = h.SpecificPriceService.Delete(c.Context(), id)
	if err != nil {
		return c.Status(responseErrors.GetErrorStatus(err)).JSON(fiber.Map{
			"error": responseErrors.GetErrorCode(c, err),
		})
	}

	return c.JSON(fiber.Map{
		"message": "specific price deleted",
	})
}

func parseTime(s *string) *time.Time {
	if s == nil {
		return nil
	}
	t, err := time.Parse(time.RFC3339, *s)
	if err != nil {
		return nil
	}
	return &t
}