package controllers

import (
	"net/http"

	"dinacom-11.0-backend/models/dto"
	"dinacom-11.0-backend/services"
	"dinacom-11.0-backend/utils"

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

type AuthController interface {
	RegisterUser(ctx *gin.Context)
	VerifyOTP(ctx *gin.Context)
	LoginUser(ctx *gin.Context)
	LoginAdmin(ctx *gin.Context)
	LoginWorker(ctx *gin.Context)
	GoogleAuth(ctx *gin.Context)
	GetProfile(ctx *gin.Context)
	GetAllUsers(ctx *gin.Context)
	GetAllWorkers(ctx *gin.Context)
	AssignWorkerRole(ctx *gin.Context)
	CreateWorker(ctx *gin.Context)
	GetWorkerByID(ctx *gin.Context)
	UpdateWorker(ctx *gin.Context)
	DeleteWorker(ctx *gin.Context)
}

type authController struct {
	authService services.AuthService
}

func NewAuthController(authService services.AuthService) AuthController {
	return &authController{authService: authService}
}

// @Summary Register a new user
// @Description Register a new user with email verification via OTP
// @Tags Auth
// @Accept json
// @Produce json
// @Param request body dto.RegisterRequest true "Register Request"
// @Success 200 {object} map[string]string
// @Failure 400 {object} map[string]string
// @Router /api/auth/user/register [post]
func (c *authController) RegisterUser(ctx *gin.Context) {
	var req dto.RegisterRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.SendErrorResponse(ctx, http.StatusBadRequest, err.Error())
		return
	}

	if err := c.authService.RegisterUser(req); err != nil {
		utils.SendErrorResponse(ctx, http.StatusBadRequest, err.Error())
		return
	}

	utils.SendSuccessResponse(ctx, "OTP sent to email", nil)
}

// @Summary Verify OTP
// @Description Verify OTP to activate user account and get access token
// @Tags Auth
// @Accept json
// @Produce json
// @Param request body dto.VerifyOTPRequest true "Verify OTP Request"
// @Success 200 {object} dto.AuthResponse
// @Failure 401 {object} map[string]string
// @Router /api/auth/user/verify-otp [post]
func (c *authController) VerifyOTP(ctx *gin.Context) {
	var req dto.VerifyOTPRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.SendErrorResponse(ctx, http.StatusBadRequest, err.Error())
		return
	}

	token, err := c.authService.VerifyOTP(req)
	if err != nil {
		utils.SendErrorResponse(ctx, http.StatusUnauthorized, err.Error())
		return
	}

	utils.SendSuccessResponse(ctx, "Verification successful", dto.AuthResponse{Token: token})
}

// @Summary Login User
// @Description Login for users
// @Tags Auth
// @Accept json
// @Produce json
// @Param request body dto.LoginRequest true "Login Request"
// @Success 200 {object} dto.AuthResponse
// @Failure 401 {object} map[string]string
// @Router /api/auth/user/login [post]
func (c *authController) LoginUser(ctx *gin.Context) {
	var req dto.LoginRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.SendErrorResponse(ctx, http.StatusBadRequest, err.Error())
		return
	}

	token, err := c.authService.LoginUser(req)
	if err != nil {
		utils.SendErrorResponse(ctx, http.StatusUnauthorized, err.Error())
		return
	}

	utils.SendSuccessResponse(ctx, "Login successful", dto.AuthResponse{Token: token})
}

// @Summary Login Admin
// @Description Login for admins
// @Tags Auth
// @Accept json
// @Produce json
// @Param request body dto.LoginRequest true "Login Request"
// @Success 200 {object} dto.AuthResponse
// @Failure 401 {object} map[string]string
// @Router /api/auth/admin/login [post]
func (c *authController) LoginAdmin(ctx *gin.Context) {
	var req dto.LoginRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.SendErrorResponse(ctx, http.StatusBadRequest, err.Error())
		return
	}

	token, err := c.authService.LoginAdmin(req)
	if err != nil {
		utils.SendErrorResponse(ctx, http.StatusUnauthorized, err.Error())
		return
	}

	utils.SendSuccessResponse(ctx, "Login successful", dto.AuthResponse{Token: token})
}

// @Summary Login Worker
// @Description Login for workers
// @Tags Auth
// @Accept json
// @Produce json
// @Param request body dto.LoginRequest true "Login Request"
// @Success 200 {object} dto.AuthResponse
// @Failure 401 {object} map[string]string
// @Router /api/auth/worker/login [post]
func (c *authController) LoginWorker(ctx *gin.Context) {
	var req dto.LoginRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.SendErrorResponse(ctx, http.StatusBadRequest, err.Error())
		return
	}

	token, err := c.authService.LoginWorker(req)
	if err != nil {
		utils.SendErrorResponse(ctx, http.StatusUnauthorized, err.Error())
		return
	}

	utils.SendSuccessResponse(ctx, "Login successful", dto.AuthResponse{Token: token})
}

// @Summary Get Profile
// @Description Get current user's profile
// @Tags Auth
// @Produce json
// @Security BearerAuth
// @Success 200 {object} dto.UserResponse
// @Failure 401 {object} map[string]string
// @Router /api/auth/me [get]
func (c *authController) GetProfile(ctx *gin.Context) {
	userIDVal, exists := ctx.Get("user_id")
	if !exists {
		utils.SendErrorResponse(ctx, http.StatusUnauthorized, "Unauthorized")
		return
	}

	userID := userIDVal.(uuid.UUID)
	profile, err := c.authService.GetProfile(userID)
	if err != nil {
		utils.SendErrorResponse(ctx, http.StatusNotFound, err.Error())
		return
	}

	utils.SendSuccessResponse(ctx, "Profile retrieved", profile)
}

// @Summary Get All Users
// @Description Get all users (Admin only)
// @Tags Admin
// @Produce json
// @Security BearerAuth
// @Success 200 {array} dto.UserResponse
// @Failure 403 {object} map[string]string
// @Router /api/auth/admin/users [get]
func (c *authController) GetAllUsers(ctx *gin.Context) {
	users, err := c.authService.GetAllUsers()
	if err != nil {
		utils.SendErrorResponse(ctx, http.StatusInternalServerError, err.Error())
		return
	}

	utils.SendSuccessResponse(ctx, "Users retrieved", users)
}

// @Summary Get All Workers
// @Description Get all workers (Admin only)
// @Tags Admin
// @Produce json
// @Security BearerAuth
// @Success 200 {array} dto.UserResponse
// @Failure 403 {object} map[string]string
// @Router /api/auth/admin/workers [get]
func (c *authController) GetAllWorkers(ctx *gin.Context) {
	workers, err := c.authService.GetAllWorkers()
	if err != nil {
		utils.SendErrorResponse(ctx, http.StatusInternalServerError, err.Error())
		return
	}

	utils.SendSuccessResponse(ctx, "Workers retrieved", workers)
}

// @Summary Google Authentication
// @Description Authenticate with Google ID token and get JWT
// @Tags Auth
// @Accept json
// @Produce json
// @Param request body dto.GoogleAuthRequest true "Google Auth Request"
// @Success 200 {object} dto.GoogleAuthResponse
// @Failure 401 {object} map[string]string
// @Router /api/auth/google [post]
func (c *authController) GoogleAuth(ctx *gin.Context) {
	var req dto.GoogleAuthRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.SendErrorResponse(ctx, http.StatusBadRequest, err.Error())
		return
	}

	response, err := c.authService.GoogleAuth(req)
	if err != nil {
		utils.SendErrorResponse(ctx, http.StatusUnauthorized, err.Error())
		return
	}

	utils.SendSuccessResponse(ctx, "Authentication successful", response)
}

// @Summary Assign Worker Role
// @Description Assign worker role to a user (Admin only)
// @Tags Admin
// @Accept json
// @Produce json
// @Security BearerAuth
// @Param request body dto.AssignWorkerRoleRequest true "Assign Worker Role Request"
// @Success 200 {object} map[string]string
// @Failure 400 {object} map[string]string
// @Failure 403 {object} map[string]string
// @Router /api/admin/auth/assign [post]
func (c *authController) AssignWorkerRole(ctx *gin.Context) {
	var req dto.AssignWorkerRoleRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.SendErrorResponse(ctx, http.StatusBadRequest, err.Error())
		return
	}

	if err := c.authService.AssignWorkerRole(req.WorkerID); err != nil {
		utils.SendErrorResponse(ctx, http.StatusBadRequest, err.Error())
		return
	}

	utils.SendSuccessResponse(ctx, "Worker role assigned successfully", nil)
}

// @Summary Create Worker
// @Description Create a new worker account (Admin only)
// @Tags Admin
// @Accept json
// @Produce json
// @Security BearerAuth
// @Param request body dto.CreateWorkerRequest true "Create Worker Request"
// @Success 200 {object} dto.WorkerResponse
// @Failure 400 {object} map[string]string
// @Router /api/admin/worker [post]
func (c *authController) CreateWorker(ctx *gin.Context) {
	var req dto.CreateWorkerRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.SendErrorResponse(ctx, http.StatusBadRequest, err.Error())
		return
	}

	worker, err := c.authService.CreateWorker(req)
	if err != nil {
		utils.SendErrorResponse(ctx, http.StatusBadRequest, err.Error())
		return
	}

	utils.SendSuccessResponse(ctx, "Worker created successfully", worker)
}

// @Summary Get Worker By ID
// @Description Get worker details by ID (Admin only)
// @Tags Admin
// @Produce json
// @Security BearerAuth
// @Param id path string true "Worker ID"
// @Success 200 {object} dto.WorkerResponse
// @Failure 400 {object} map[string]string
// @Router /api/admin/worker/{id} [get]
func (c *authController) GetWorkerByID(ctx *gin.Context) {
	workerIDStr := ctx.Param("id")
	workerID, err := uuid.Parse(workerIDStr)
	if err != nil {
		utils.SendErrorResponse(ctx, http.StatusBadRequest, "Invalid worker ID")
		return
	}

	worker, err := c.authService.GetWorkerByID(workerID)
	if err != nil {
		utils.SendErrorResponse(ctx, http.StatusBadRequest, err.Error())
		return
	}

	utils.SendSuccessResponse(ctx, "Worker retrieved successfully", worker)
}

// @Summary Update Worker
// @Description Update worker details (Admin only)
// @Tags Admin
// @Accept json
// @Produce json
// @Security BearerAuth
// @Param id path string true "Worker ID"
// @Param request body dto.UpdateWorkerRequest true "Update Worker Request"
// @Success 200 {object} dto.WorkerResponse
// @Failure 400 {object} map[string]string
// @Router /api/admin/worker/{id} [put]
func (c *authController) UpdateWorker(ctx *gin.Context) {
	workerIDStr := ctx.Param("id")
	workerID, err := uuid.Parse(workerIDStr)
	if err != nil {
		utils.SendErrorResponse(ctx, http.StatusBadRequest, "Invalid worker ID")
		return
	}

	var req dto.UpdateWorkerRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.SendErrorResponse(ctx, http.StatusBadRequest, err.Error())
		return
	}

	worker, err := c.authService.UpdateWorker(workerID, req)
	if err != nil {
		utils.SendErrorResponse(ctx, http.StatusBadRequest, err.Error())
		return
	}

	utils.SendSuccessResponse(ctx, "Worker updated successfully", worker)
}

// @Summary Delete Worker
// @Description Delete a worker (Admin only)
// @Tags Admin
// @Produce json
// @Security BearerAuth
// @Param id path string true "Worker ID"
// @Success 200 {object} map[string]string
// @Failure 400 {object} map[string]string
// @Router /api/admin/worker/{id} [delete]
func (c *authController) DeleteWorker(ctx *gin.Context) {
	workerIDStr := ctx.Param("id")
	workerID, err := uuid.Parse(workerIDStr)
	if err != nil {
		utils.SendErrorResponse(ctx, http.StatusBadRequest, "Invalid worker ID")
		return
	}

	if err := c.authService.DeleteWorker(workerID); err != nil {
		utils.SendErrorResponse(ctx, http.StatusBadRequest, err.Error())
		return
	}

	utils.SendSuccessResponse(ctx, "Worker deleted successfully", nil)
}