package controllers

import (
	"whatsapp-backend/models/dto"
	http_error "whatsapp-backend/models/error"
	"whatsapp-backend/services"
	"whatsapp-backend/utils"

	"github.com/gin-gonic/gin"
	"github.com/google/uuid"
)

type AdminController interface {
	CreateUser(ctx *gin.Context)
	UpdateUser(ctx *gin.Context)
	DeleteUser(ctx *gin.Context)
	SetRegistrationEnabled(ctx *gin.Context)
}

type adminController struct {
	adminService services.AdminService
}

func NewAdminController(adminService services.AdminService) AdminController {
	return &adminController{adminService: adminService}
}

// CreateUser godoc
// @Summary      Create a new user (Admin)
// @Description  Create a new user with specific role
// @Tags         admin
// @Security     BearerAuth
// @Accept       json
// @Produce      json
// @Param        request body dto.CreateUserRequest true "Create User Request"
// @Success      200  {object}  dto.UserResponse
// @Failure      400  {object}  dto.ErrorResponse
// @Router       /admin/create [post]
func (c *adminController) CreateUser(ctx *gin.Context) {
	var req dto.CreateUserRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.SendResponse[any, any](ctx, nil, nil, err)
		return
	}

	resp, err := c.adminService.CreateUser(req)
	if err != nil {
		utils.SendResponse[any, any](ctx, nil, nil, err)
		return
	}
	utils.SendResponse[dto.UserResponse, any](ctx, nil, *resp, nil)
}

// UpdateUser godoc
// @Summary      Update a user (Admin)
// @Description  Update user details
// @Tags         admin
// @Security     BearerAuth
// @Accept       json
// @Produce      json
// @Param        request body dto.UpdateUserRequest true "Update User Request"
// @Success      200  {object}  dto.UserResponse
// @Failure      400  {object}  dto.ErrorResponse
// @Router       /admin/update [post]
func (c *adminController) UpdateUser(ctx *gin.Context) {
	var req dto.UpdateUserRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.SendResponse[any, any](ctx, nil, nil, err)
		return
	}

	resp, err := c.adminService.UpdateUser(req)
	if err != nil {
		utils.SendResponse[any, any](ctx, nil, nil, err)
		return
	}
	utils.SendResponse[dto.UserResponse, any](ctx, nil, *resp, nil)
}

// DeleteUser godoc
// @Summary      Delete a user (Admin)
// @Description  Delete a user by ID
// @Tags         admin
// @Security     BearerAuth
// @Accept       json
// @Produce      json
// @Param        id query string true "User ID"
// @Success      200
// @Router       /admin/delete [post]
func (c *adminController) DeleteUser(ctx *gin.Context) {
	idStr := ctx.Query("id")
	if idStr == "" {
		// Fallback to body? or just error. Query is compliant with "passing api/auth/assign with JSON" instruction?
		// But for DELETE, usually it is id.
		// User instruction said: "/api/admin/create, /api/admin/update, /api/admin/delete".
		// I'll stick to Query param for ID for delete.
		utils.SendResponse[any, any](ctx, nil, nil, http_error.ERR_BAD_REQUEST)
		return
	}
	id, err := uuid.Parse(idStr)
	if err != nil {
		utils.SendResponse[any, any](ctx, nil, nil, err)
		return

	}

	if err := c.adminService.DeleteUser(id); err != nil {
		utils.SendResponse[any, any](ctx, nil, nil, err)
		return
	}
	utils.SendResponse[any, any](ctx, nil, nil, nil)
}

// SetRegistrationEnabled godoc
// @Summary      Toggle registration enabled
// @Description  Enable or disable user registration
// @Tags         admin
// @Security     BearerAuth
// @Accept       json
// @Param        request body dto.SetRegistrationRequest true "Set Registration Request"
// @Success      200  {object}  dto.RegisterEnabledResponse
// @Router       /admin/set_registration [post]
func (c *adminController) SetRegistrationEnabled(ctx *gin.Context) {
	var req dto.SetRegistrationRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.SendResponse[any, any](ctx, nil, nil, err)
		return
	}

	if err := c.adminService.SetRegistrationEnabled(req.Enabled); err != nil {
		utils.SendResponse[any, any](ctx, nil, nil, err)
		return
	}

	utils.SendResponse[dto.RegisterEnabledResponse, any](ctx, nil, dto.RegisterEnabledResponse{
		Register: req.Enabled,
	}, nil)
}