package handler

import (
	"net/http"

	"bugulma/backend/internal/domain"
	"bugulma/backend/internal/service"

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

// OrganizationAdminHandler handles admin-specific organization operations
type OrganizationAdminHandler struct {
	orgHandler          *OrganizationHandler
	verificationService *service.VerificationService
}

func NewOrganizationAdminHandler(orgHandler *OrganizationHandler, verificationService *service.VerificationService) *OrganizationAdminHandler {
	return &OrganizationAdminHandler{
		orgHandler:          orgHandler,
		verificationService: verificationService,
	}
}

// GetVerificationQueue returns organizations pending verification (admin only)
// @Summary Get verification queue
// @Tags admin
// @Produce json
// @Param status query string false "Filter by status"
// @Param dataType query string false "Filter by data type"
// @Param organizationId query string false "Filter by organization ID"
// @Success 200 {object} map[string]interface{}
// @Router /api/v1/admin/organizations/verification-queue [get]
func (h *OrganizationAdminHandler) GetVerificationQueue(c *gin.Context) {
	filters := service.VerificationQueueFilters{}

	if statusStr := c.Query("status"); statusStr != "" {
		status := domain.VerificationStatus(statusStr)
		filters.Status = &status
	}
	if dataType := c.Query("dataType"); dataType != "" {
		filters.DataType = &dataType
	}
	if orgID := c.Query("organizationId"); orgID != "" {
		filters.OrganizationID = &orgID
	}

	queue, err := h.verificationService.GetVerificationQueue(c.Request.Context(), filters)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}

	c.JSON(http.StatusOK, gin.H{"queue": queue})
}

// VerifyOrganization verifies an organization (admin only)
// @Summary Verify organization
// @Tags admin
// @Accept json
// @Produce json
// @Param id path string true "Organization ID"
// @Param request body VerifyOrganizationRequest true "Verification request"
// @Success 200 {object} map[string]string
// @Router /api/v1/admin/organizations/:id/verify [post]
func (h *OrganizationAdminHandler) VerifyOrganization(c *gin.Context) {
	orgID := c.Param("id")

	var req VerifyOrganizationRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	userID, _ := c.Get("user_id")
	verifiedBy := userID.(string)

	if err := h.verificationService.VerifyOrganization(c.Request.Context(), orgID, verifiedBy, req.Notes); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	c.JSON(http.StatusOK, gin.H{"message": "Organization verified"})
}

type VerifyOrganizationRequest struct {
	Notes string `json:"notes"`
}

// RejectVerification rejects an organization verification (admin only)
// @Summary Reject verification
// @Tags admin
// @Accept json
// @Produce json
// @Param id path string true "Organization ID"
// @Param request body RejectVerificationRequest true "Rejection request"
// @Success 200 {object} map[string]string
// @Router /api/v1/admin/organizations/:id/reject [post]
func (h *OrganizationAdminHandler) RejectVerification(c *gin.Context) {
	orgID := c.Param("id")

	var req RejectVerificationRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	if err := h.verificationService.RejectVerification(c.Request.Context(), orgID, req.Reason, req.Notes); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	c.JSON(http.StatusOK, gin.H{"message": "Verification rejected"})
}

type RejectVerificationRequest struct {
	Reason string `json:"reason" binding:"required"`
	Notes  string `json:"notes"`
}

// BulkVerify verifies multiple organizations (admin only)
// @Summary Bulk verify organizations
// @Tags admin
// @Accept json
// @Produce json
// @Param request body BulkVerifyRequest true "Bulk verify request"
// @Success 200 {object} map[string]string
// @Router /api/v1/admin/organizations/bulk-verify [post]
func (h *OrganizationAdminHandler) BulkVerify(c *gin.Context) {
	var req BulkVerifyRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	userID, _ := c.Get("user_id")
	verifiedBy := userID.(string)

	if err := h.verificationService.BulkVerify(c.Request.Context(), req.OrganizationIDs, verifiedBy); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	c.JSON(http.StatusOK, gin.H{"message": "Organizations verified"})
}

type BulkVerifyRequest struct {
	OrganizationIDs []string `json:"organizationIds" binding:"required"`
}

// GetOrganizationStats returns organization statistics (admin only)
// @Summary Get organization statistics
// @Tags admin
// @Produce json
// @Success 200 {object} map[string]interface{}
// @Router /api/v1/admin/organizations/stats [get]
func (h *OrganizationAdminHandler) GetOrganizationStats(c *gin.Context) {
	// TODO: Implement organization statistics
	c.JSON(http.StatusOK, gin.H{
		"total":          0,
		"verified":       0,
		"pending":        0,
		"unverified":     0,
		"new_this_month": 0,
	})
}