package controller

import (
	"net/http"

	"github.com/Caknoooo/go-gin-clean-starter/modules/maintenance_group/dto"
	"github.com/Caknoooo/go-gin-clean-starter/modules/maintenance_group/query"
	"github.com/Caknoooo/go-gin-clean-starter/modules/maintenance_group/service"
	"github.com/Caknoooo/go-gin-clean-starter/pkg/constants"
	pkgdto "github.com/Caknoooo/go-gin-clean-starter/pkg/dto"
	"github.com/Caknoooo/go-gin-clean-starter/pkg/utils"
	"github.com/Caknoooo/go-pagination"
	"github.com/gin-gonic/gin"
	"github.com/samber/do"
	"github.com/sirupsen/logrus"
	"gorm.io/gorm"
)

type (
	MaintenanceGroupController interface {
		Create(ctx *gin.Context)
		Update(ctx *gin.Context)
		Delete(ctx *gin.Context)
		GetById(ctx *gin.Context)
		GetAll(ctx *gin.Context)
	}

	maintenanceGroupController struct {
		maintGroupService service.MaintenanceGroupService
		db                *gorm.DB
		logger            *logrus.Logger
	}
)

func NewMaintenanceGroupController(i *do.Injector, maintGroupService service.MaintenanceGroupService) MaintenanceGroupController {
	db := do.MustInvokeNamed[*gorm.DB](i, constants.DB)
	logger := do.MustInvokeNamed[*logrus.Logger](i, constants.LOGGER)

	return &maintenanceGroupController{
		maintGroupService: maintGroupService,
		db:                db,
		logger:            logger,
	}
}

// Create godoc
// @Summary      Create a new maintenance group
// @Description  Create a new maintenance group
// @Tags         MaintenanceGroup
// @Accept       json
// @Produce      json
// @Param        body  body      dto.MaintGroupCreateRequest  true  "Create payload"
// @Success      200   {object}  utils.Response
// @Failure      400   {object}  map[string]interface{}
// @Router       /maintenance-groups [post]
func (c *maintenanceGroupController) Create(ctx *gin.Context) {
	var req dto.MaintGroupCreateRequest
	if err := ctx.ShouldBind(&req); err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_GET_DATA_FROM_BODY, err.Error(), nil)
		ctx.AbortWithStatusJSON(http.StatusBadRequest, res)
		return
	}

	result, err := c.maintGroupService.Create(ctx.Request.Context(), req)
	if err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_REGISTER_MG, err.Error(), nil)
		ctx.JSON(http.StatusBadRequest, res)
		return
	}

	res := utils.BuildResponseSuccess(dto.MESSAGE_SUCCESS_REGISTER_MG, result)
	ctx.JSON(http.StatusOK, res)
}

// Update godoc
// @Summary      Update maintenance group
// @Description  Update maintenance group
// @Tags         MaintenanceGroup
// @Accept       json
// @Produce      json
// @Param        body  body      dto.MaintGroupUpdateRequest  true  "Update payload"
// @Success      200   {object}  utils.Response
// @Failure      400   {object}  map[string]interface{}
// @Router       /maintenance-groups [put]
func (c *maintenanceGroupController) Update(ctx *gin.Context) {
	var req dto.MaintGroupUpdateRequest
	if err := ctx.ShouldBind(&req); err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_GET_DATA_FROM_BODY, err.Error(), nil)
		ctx.AbortWithStatusJSON(http.StatusBadRequest, res)
		return
	}
	id := ctx.Param("id")
	result, err := c.maintGroupService.Update(ctx.Request.Context(), req, id)
	if err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_UPDATE_MG, err.Error(), nil)
		ctx.JSON(http.StatusBadRequest, res)
		return
	}
	res := utils.BuildResponseSuccess(dto.MESSAGE_SUCCESS_UPDATE_MG, result)
	ctx.JSON(http.StatusOK, res)
}

// Delete godoc
// @Summary      Delete maintenance group
// @Description  Delete maintenance group
// @Tags         MaintenanceGroup
// @Accept       json
// @Produce      json
// @Param        id   path      string  true  "MaintenanceGroup ID"
// @Success      200   {object}  map[string]interface{}
// @Failure      400   {object}  map[string]interface{}
// @Router       /maintenance-groups/{id} [delete]
func (c *maintenanceGroupController) Delete(ctx *gin.Context) {
	id := ctx.Param("id")
	if err := c.maintGroupService.Delete(ctx.Request.Context(), id); err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_DELETE_MG, err.Error(), nil)
		ctx.AbortWithStatusJSON(http.StatusBadRequest, res)
		return
	}
	res := utils.BuildResponseSuccess(dto.MESSAGE_SUCCESS_DELETE_MG, nil)
	ctx.JSON(http.StatusOK, res)
}

// GetById godoc
// @Summary      Get maintenance group by ID
// @Description  Get maintenance group by ID
// @Tags         MaintenanceGroup
// @Accept       json
// @Produce      json
// @Param        id   path      string  true  "MaintenanceGroup ID"
// @Success      200   {object}  utils.Response
// @Failure      400   {object}  map[string]interface{}
// @Router       /maintenance-groups/{id} [get]
func (c *maintenanceGroupController) GetById(ctx *gin.Context) {
	id := ctx.Param("id")
	result, err := c.maintGroupService.GetById(ctx.Request.Context(), id)
	if err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_GET_MG, err.Error(), nil)
		ctx.JSON(http.StatusBadRequest, res)
		return
	}
	res := utils.BuildResponseSuccess(dto.MESSAGE_SUCCESS_GET_MG, result)
	ctx.JSON(http.StatusOK, res)
}

// GetAll godoc
// @Summary      Get all maintenance groups
// @Description  Get all maintenance groups
// @Tags         MaintenanceGroup
// @Accept       json
// @Produce      json
// @Success      200   {array}   utils.Response
// @Failure      400   {object}  map[string]interface{}
// @Router       /maintenance-groups [get]
func (c *maintenanceGroupController) GetAll(ctx *gin.Context) {
	// clientId := ctx.MustGet("client_id").(string)
	var filter = &query.MaintenanceGroupFilter{
		Name:        ctx.Query("name"),
		Code:        ctx.Query("code"),
		Description: ctx.Query("description"),
		ClientID:    ctx.Query("client_id"),
		Includes:    ctx.QueryArray("includes"),
	}
	logrus.Info(filter.ClientID)
	filter.BindPagination(ctx)
	ctx.ShouldBindQuery(&filter)
	// logrus.Infof("pagination: page=%d, page_size=%d", filter.Pagination.Page, filter.Pagination.PerPage)
	logrus.Info("1")
	groups, total, err := pagination.PaginatedQueryWithIncludableAndOptions[query.M_MaintenanceGroup](
		c.db,
		filter,
		pagination.PaginatedQueryOptions{
			EnableSoftDelete: true,
			// Dialect: pagination.MySQL, // atau PostgreSQL jika perlu
		},
	)
	groupsResponse := ToMaintGroupSimpleResponses(groups)
	if err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_GET_LIST_MG, err.Error(), nil)
		ctx.JSON(http.StatusBadRequest, res)
		return
	}
	logrus.Info("3")
	// groupResponses := dto.ToMaintGroupResponses(groups)
	paginationResponse := pagination.CalculatePagination(filter.Pagination, total)

	response := pagination.NewPaginatedResponse(http.StatusOK, dto.MESSAGE_SUCCESS_GET_LIST_MG, groupsResponse, paginationResponse)
	ctx.JSON(http.StatusOK, response)
}

func ToMaintGroupSimpleResponses(groups []query.M_MaintenanceGroup) []dto.MaintGroupResponse {
	res := make([]dto.MaintGroupResponse, 0, len(groups))
	for _, g := range groups {
		roles := make([]dto.MaintenanceGroupRoleResponse, 0, len(g.MaintenanceGroupRoles))
		for _, r := range g.MaintenanceGroupRoles {
			roles = append(roles, dto.MaintenanceGroupRoleResponse{
				ID:    r.ID.String(),
				Level: r.Level,
				Role: pkgdto.RoleResponse{
					ID:   r.Role.ID.String(),
					Name: r.Role.Name,
				}})
		}
		res = append(res, dto.MaintGroupResponse{
			ID:                        g.ID,
			Name:                      g.Name,
			Code:                      g.Code,
			Description:               g.Description,
			TotalMaintenanceGroupRole: g.TotalMaintenanceGroupRole,
			Client: pkgdto.IdNameResponse{
				ID:   g.Client.ID.String(),
				Name: g.Client.Name,
			},
			MaintenanceGroupRoles: &roles,
		})
	}
	return res
}