package controller

import (
	"netidhub-saas-be/app/module/menu_actions/request"
	"netidhub-saas-be/app/module/menu_actions/service"
	"netidhub-saas-be/utils/paginator"
	"strconv"

	"github.com/gofiber/fiber/v2"

	utilRes "netidhub-saas-be/utils/response"
	utilVal "netidhub-saas-be/utils/validator"
)

type menuActionsController struct {
	menuActionsService service.MenuActionsService
}

type MenuActionsController interface {
	All(c *fiber.Ctx) error
	GetByMenuId(c *fiber.Ctx) error
	Show(c *fiber.Ctx) error
	Save(c *fiber.Ctx) error
	SaveBatch(c *fiber.Ctx) error
	Update(c *fiber.Ctx) error
	Delete(c *fiber.Ctx) error
}

func NewMenuActionsController(menuActionsService service.MenuActionsService) MenuActionsController {
	return &menuActionsController{
		menuActionsService: menuActionsService,
	}
}

// All MenuActions
// @Summary      Get all MenuActions
// @Description  API for getting all MenuActions
// @Tags         MenuActions
// @Security     Bearer
// @Param 	     menu_id query int false "Menu ID"
// @Param 	     action_code query string false "Action Code"
// @Param 	     req query paginator.Pagination false "pagination parameters"
// @Success      200  {object}  response.Response
// @Failure      400  {object}  response.BadRequestError
// @Failure      401  {object}  response.UnauthorizedError
// @Failure      500  {object}  response.InternalServerError
// @Router       /menu-actions [get]
func (_i *menuActionsController) All(c *fiber.Ctx) error {
	paginate, err := paginator.Paginate(c)
	if err != nil {
		return err
	}

	req := request.MenuActionsQueryRequest{
		Pagination: paginate,
	}

	if menuId := c.Query("menu_id"); menuId != "" {
		id, _ := strconv.ParseUint(menuId, 10, 0)
		menuIdUint := uint(id)
		req.MenuId = &menuIdUint
	}

	if actionCode := c.Query("action_code"); actionCode != "" {
		req.ActionCode = &actionCode
	}

	menuActionsData, paging, err := _i.menuActionsService.All(req)
	if err != nil {
		return err
	}

	return utilRes.Resp(c, utilRes.Response{
		Success:  true,
		Messages: utilRes.Messages{"MenuActions list successfully retrieved"},
		Data:     menuActionsData,
		Meta:     paging,
	})
}

// GetByMenuId get MenuActions by Menu ID
// @Summary      Get MenuActions by Menu ID
// @Description  API for getting MenuActions by Menu ID
// @Tags         MenuActions
// @Security     Bearer
// @Param        menu_id path int true "Menu ID"
// @Success      200  {object}  response.Response
// @Failure      400  {object}  response.BadRequestError
// @Failure      401  {object}  response.UnauthorizedError
// @Failure      500  {object}  response.InternalServerError
// @Router       /menu-actions/menu/{menu_id} [get]
func (_i *menuActionsController) GetByMenuId(c *fiber.Ctx) error {
	menuId, err := strconv.ParseUint(c.Params("menu_id"), 10, 0)
	if err != nil {
		return err
	}

	menuActionsData, err := _i.menuActionsService.GetByMenuId(uint(menuId))
	if err != nil {
		return err
	}

	return utilRes.Resp(c, utilRes.Response{
		Success:  true,
		Messages: utilRes.Messages{"MenuActions by menu successfully retrieved"},
		Data:     menuActionsData,
	})
}

// Show get one MenuAction
// @Summary      Get one MenuAction
// @Description  API for getting one MenuAction
// @Tags         MenuActions
// @Security     Bearer
// @Param        id path int true "MenuAction ID"
// @Success      200  {object}  response.Response
// @Failure      400  {object}  response.BadRequestError
// @Failure      401  {object}  response.UnauthorizedError
// @Failure      500  {object}  response.InternalServerError
// @Router       /menu-actions/{id} [get]
func (_i *menuActionsController) Show(c *fiber.Ctx) error {
	id, err := strconv.ParseUint(c.Params("id"), 10, 0)
	if err != nil {
		return err
	}

	menuActionData, err := _i.menuActionsService.Show(uint(id))
	if err != nil {
		return err
	}

	return utilRes.Resp(c, utilRes.Response{
		Success:  true,
		Messages: utilRes.Messages{"MenuAction successfully retrieved"},
		Data:     menuActionData,
	})
}

// Save create MenuAction
// @Summary      Create MenuAction
// @Description  API for create MenuAction
// @Tags         MenuActions
// @Security     Bearer
// @Param        X-Csrf-Token header string false "Insert the X-Csrf-Token"
// @Param 	     payload body request.MenuActionsCreateRequest true "Required payload"
// @Success      200  {object}  response.Response
// @Failure      400  {object}  response.BadRequestError
// @Failure      401  {object}  response.UnauthorizedError
// @Failure      500  {object}  response.InternalServerError
// @Router       /menu-actions [post]
func (_i *menuActionsController) Save(c *fiber.Ctx) error {
	req := new(request.MenuActionsCreateRequest)
	if err := utilVal.ParseAndValidate(c, req); err != nil {
		return err
	}

	err := _i.menuActionsService.Save(*req)
	if err != nil {
		return err
	}

	return utilRes.Resp(c, utilRes.Response{
		Success:  true,
		Messages: utilRes.Messages{"MenuAction successfully created"},
	})
}

// SaveBatch create MenuActions batch
// @Summary      Create MenuActions batch
// @Description  API for create MenuActions batch
// @Tags         MenuActions
// @Security     Bearer
// @Param        X-Csrf-Token header string false "Insert the X-Csrf-Token"
// @Param 	     payload body request.MenuActionsBatchCreateRequest true "Required payload"
// @Success      200  {object}  response.Response
// @Failure      400  {object}  response.BadRequestError
// @Failure      401  {object}  response.UnauthorizedError
// @Failure      500  {object}  response.InternalServerError
// @Router       /menu-actions/batch [post]
func (_i *menuActionsController) SaveBatch(c *fiber.Ctx) error {
	req := new(request.MenuActionsBatchCreateRequest)
	if err := utilVal.ParseAndValidate(c, req); err != nil {
		return err
	}

	err := _i.menuActionsService.SaveBatch(*req)
	if err != nil {
		return err
	}

	return utilRes.Resp(c, utilRes.Response{
		Success:  true,
		Messages: utilRes.Messages{"MenuActions batch successfully created"},
	})
}

// Update MenuAction
// @Summary      Update MenuAction
// @Description  API for update MenuAction
// @Tags         MenuActions
// @Security     Bearer
// @Param        X-Csrf-Token header string false "Insert the X-Csrf-Token"
// @Param        id path int true "MenuAction ID"
// @Param 	     payload body request.MenuActionsUpdateRequest true "Required payload"
// @Success      200  {object}  response.Response
// @Failure      400  {object}  response.BadRequestError
// @Failure      401  {object}  response.UnauthorizedError
// @Failure      500  {object}  response.InternalServerError
// @Router       /menu-actions/{id} [put]
func (_i *menuActionsController) Update(c *fiber.Ctx) error {
	id, err := strconv.ParseUint(c.Params("id"), 10, 0)
	if err != nil {
		return err
	}

	req := new(request.MenuActionsUpdateRequest)
	if err := utilVal.ParseAndValidate(c, req); err != nil {
		return err
	}

	err = _i.menuActionsService.Update(uint(id), *req)
	if err != nil {
		return err
	}

	return utilRes.Resp(c, utilRes.Response{
		Success:  true,
		Messages: utilRes.Messages{"MenuAction successfully updated"},
	})
}

// Delete MenuAction
// @Summary      Delete MenuAction
// @Description  API for delete MenuAction
// @Tags         MenuActions
// @Security     Bearer
// @Param        X-Csrf-Token header string false "Insert the X-Csrf-Token"
// @Param        id path int true "MenuAction ID"
// @Success      200  {object}  response.Response
// @Failure      400  {object}  response.BadRequestError
// @Failure      401  {object}  response.UnauthorizedError
// @Failure      500  {object}  response.InternalServerError
// @Router       /menu-actions/{id} [delete]
func (_i *menuActionsController) Delete(c *fiber.Ctx) error {
	id, err := strconv.ParseUint(c.Params("id"), 10, 0)
	if err != nil {
		return err
	}

	err = _i.menuActionsService.Delete(uint(id))
	if err != nil {
		return err
	}

	return utilRes.Resp(c, utilRes.Response{
		Success:  true,
		Messages: utilRes.Messages{"MenuAction successfully deleted"},
	})
}