package user

import (
	"RenewCMS/api/pkg/access"
	"RenewCMS/api/pkg/apperr"
	"RenewCMS/internal/domain/role"
	domain "RenewCMS/internal/domain/user"
	"RenewCMS/internal/infrastructure/useCases"
	"errors"
	"net/http"
	"strconv"

	"github.com/go-chi/chi/v5"
)

type RemoveHandler struct {
	RemoveUserUseCase *useCases.RemoveUserUseCase
}

func NewRemoveHandler(removeUser *useCases.RemoveUserUseCase) *RemoveHandler {
	return &RemoveHandler{RemoveUserUseCase: removeUser}
}

func (h *RemoveHandler) Remove(w http.ResponseWriter, r *http.Request) {
	targetID, err := strconv.ParseUint(chi.URLParam(r, "id"), 10, 32)
	if err != nil {
		http.Error(w, apperr.IdUint32ErrorMessage, http.StatusBadRequest)
		return
	}
	expectedRoleID, err := strconv.ParseUint(r.URL.Query().Get("expected_role_id"), 10, 32)
	if err != nil || expectedRoleID == 0 {
		http.Error(w, apperr.InvalidRoleErrorMessage, http.StatusBadRequest)
		return
	}

	err = h.RemoveUserUseCase.Remove(r.Context(), useCases.RemoveUserCommand{
		Caller:         access.CallerOf(r),
		TargetID:       uint32(targetID),
		ExpectedRoleID: uint32(expectedRoleID),
	})
	if err != nil {
		writeRemoveError(w, err)
		return
	}
	w.WriteHeader(http.StatusNoContent)
}

func writeRemoveError(w http.ResponseWriter, err error) {
	if writeRoleRefusal(w, err) {
		return
	}
	switch {
	case errors.Is(err, role.ErrOwnRole):
		http.Error(w, apperr.OwnRoleErrorMessage, http.StatusForbidden)
	case errors.Is(err, domain.ErrUserNotFound):
		http.Error(w, apperr.UserNotFoundErrorMessage, http.StatusNotFound)
	case errors.Is(err, domain.ErrRoleChanged):
		http.Error(w, apperr.UserRoleChangedErrorMessage, http.StatusConflict)
	default:
		http.Error(w, "Internal server error", http.StatusInternalServerError)
	}
}