package handlers

import (
	"net/http"
	"strconv"
	"time"

	apperrors "veza-backend-api/internal/errors"
	"veza-backend-api/internal/services"
	"veza-backend-api/internal/workers"

	"github.com/gin-gonic/gin"
	"github.com/google/uuid"
	"go.uber.org/zap"
)

// AnalyticsHandler gère les opérations d'analytics de lecture de tracks
type AnalyticsHandler struct {
	analyticsService *services.AnalyticsService
	jobWorker        *workers.JobWorker
	commonHandler    *CommonHandler
}

// NewAnalyticsHandler crée un nouveau handler d'analytics
func NewAnalyticsHandler(analyticsService *services.AnalyticsService, logger *zap.Logger) *AnalyticsHandler {
	return &AnalyticsHandler{
		analyticsService: analyticsService,
		commonHandler:    NewCommonHandler(logger),
	}
}

// SetJobWorker définit le JobWorker pour enregistrer des événements analytics
func (h *AnalyticsHandler) SetJobWorker(jobWorker *workers.JobWorker) {
	h.jobWorker = jobWorker
}

// RecordPlayRequest représente la requête pour enregistrer une lecture
// MOD-P1-001: Ajout tags validate pour validation systématique
type RecordPlayRequest struct {
	Duration int    `json:"duration" binding:"required,min=1" validate:"required,min=1"`
	Device   string `json:"device,omitempty" validate:"omitempty,max=100"`
}

// RecordPlay gère l'enregistrement d'une lecture de track
func (h *AnalyticsHandler) RecordPlay(c *gin.Context) {
	trackIDStr := c.Param("id")
	if trackIDStr == "" {
		RespondWithAppError(c, apperrors.NewValidationError("track id is required"))
		return
	}

	trackID, err := uuid.Parse(trackIDStr) // Changed to uuid.Parse
	if err != nil {
		RespondWithAppError(c, apperrors.NewValidationError("invalid track id"))
		return
	}

	var req RecordPlayRequest
	if appErr := h.commonHandler.BindAndValidateJSON(c, &req); appErr != nil {
		RespondWithAppError(c, appErr)
		return
	}

	// Récupérer user_id si authentifié (optionnel pour analytics anonymes)
	var userID *uuid.UUID
	if uid, ok := c.Get("user_id"); ok {
		if uidUUID, ok := uid.(uuid.UUID); ok {
			userID = &uidUUID
		}
	}

	// Récupérer IP address et device
	ipAddress := c.ClientIP()
	device := req.Device
	if device == "" {
		device = c.GetHeader("User-Agent")
	}

	err = h.analyticsService.RecordPlay(c.Request.Context(), trackID, userID, req.Duration, device, ipAddress)
	if err != nil {
		if err.Error() == "track not found" {
			RespondWithAppError(c, apperrors.NewNotFoundError("track"))
			return
		}
		RespondWithAppError(c, apperrors.Wrap(apperrors.ErrCodeInternal, "Failed to record play", err))
		return
	}

	RespondSuccess(c, http.StatusOK, gin.H{"message": "play recorded"})
}

// GetTrackStats gère la récupération des statistiques d'un track
func (h *AnalyticsHandler) GetTrackStats(c *gin.Context) {
	trackIDStr := c.Param("id")
	if trackIDStr == "" {
		RespondWithAppError(c, apperrors.NewValidationError("track id is required"))
		return
	}

	trackID, err := uuid.Parse(trackIDStr) // Changed to uuid.Parse
	if err != nil {
		RespondWithAppError(c, apperrors.NewValidationError("invalid track id"))
		return
	}

	stats, err := h.analyticsService.GetTrackStats(c.Request.Context(), trackID)
	if err != nil {
		if err.Error() == "track not found" {
			RespondWithAppError(c, apperrors.NewNotFoundError("track"))
			return
		}
		RespondWithAppError(c, apperrors.Wrap(apperrors.ErrCodeInternal, "Failed to get track stats", err))
		return
	}

	RespondSuccess(c, http.StatusOK, gin.H{"stats": stats})
}

// GetTopTracks gère la récupération des tracks les plus écoutés
func (h *AnalyticsHandler) GetTopTracks(c *gin.Context) {
	// Parse limit
	limit := 10
	if limitStr := c.Query("limit"); limitStr != "" {
		if l, err := strconv.Atoi(limitStr); err == nil && l > 0 && l <= 100 {
			limit = l
		} else {
			RespondWithAppError(c, apperrors.NewValidationError("invalid limit (must be between 1 and 100)"))
			return
		}
	}

	// Parse start_date (optionnel)
	var startDate *time.Time
	if startDateStr := c.Query("start_date"); startDateStr != "" {
		parsed, err := time.Parse(time.RFC3339, startDateStr)
		if err != nil {
			RespondWithAppError(c, apperrors.NewValidationError("invalid start_date format (use RFC3339)"))
			return
		}
		startDate = &parsed
	}

	// Parse end_date (optionnel)
	var endDate *time.Time
	if endDateStr := c.Query("end_date"); endDateStr != "" {
		parsed, err := time.Parse(time.RFC3339, endDateStr)
		if err != nil {
			RespondWithAppError(c, apperrors.NewValidationError("invalid end_date format (use RFC3339)"))
			return
		}
		endDate = &parsed
	}

	topTracks, err := h.analyticsService.GetTopTracks(c.Request.Context(), limit, startDate, endDate)
	if err != nil {
		RespondWithAppError(c, apperrors.Wrap(apperrors.ErrCodeInternal, "Failed to get top tracks", err))
		return
	}

	RespondSuccess(c, http.StatusOK, gin.H{"tracks": topTracks})
}

// GetPlaysOverTime gère la récupération des lectures sur une période
func (h *AnalyticsHandler) GetPlaysOverTime(c *gin.Context) {
	trackIDStr := c.Param("id")
	if trackIDStr == "" {
		RespondWithAppError(c, apperrors.NewValidationError("track id is required"))
		return
	}

	trackID, err := uuid.Parse(trackIDStr) // Changed to uuid.Parse
	if err != nil {
		RespondWithAppError(c, apperrors.NewValidationError("invalid track id"))
		return
	}

	// Parse start_date (optionnel, défaut: 30 jours)
	startDate := time.Now().AddDate(0, 0, -30)
	if startDateStr := c.Query("start_date"); startDateStr != "" {
		parsed, err := time.Parse(time.RFC3339, startDateStr)
		if err != nil {
			RespondWithAppError(c, apperrors.NewValidationError("invalid start_date format (use RFC3339)"))
			return
		}
		startDate = parsed
	}

	// Parse end_date (optionnel, défaut: maintenant)
	endDate := time.Now()
	if endDateStr := c.Query("end_date"); endDateStr != "" {
		parsed, err := time.Parse(time.RFC3339, endDateStr)
		if err != nil {
			RespondWithAppError(c, apperrors.NewValidationError("invalid end_date format (use RFC3339)"))
			return
		}
		endDate = parsed
	}

	// Parse interval (optionnel, défaut: day)
	interval := c.DefaultQuery("interval", "day")
	validIntervals := map[string]bool{"hour": true, "day": true, "week": true, "month": true}
	if !validIntervals[interval] {
		RespondWithAppError(c, apperrors.NewValidationError("invalid interval (must be: hour, day, week, month)"))
		return
	}

	points, err := h.analyticsService.GetPlaysOverTime(c.Request.Context(), trackID, startDate, endDate, interval)
	if err != nil {
		if err.Error() == "track not found" {
			RespondWithAppError(c, apperrors.NewNotFoundError("track"))
			return
		}
		RespondWithAppError(c, apperrors.Wrap(apperrors.ErrCodeInternal, "Failed to get plays over time", err))
		return
	}

	RespondSuccess(c, http.StatusOK, gin.H{"points": points})
}

// GetUserStats gère la récupération des statistiques d'un utilisateur
func (h *AnalyticsHandler) GetUserStats(c *gin.Context) {
	userIDStr := c.Param("id")
	if userIDStr == "" {
		RespondWithAppError(c, apperrors.NewValidationError("user id is required"))
		return
	}

	userID, err := uuid.Parse(userIDStr)
	if err != nil {
		RespondWithAppError(c, apperrors.NewValidationError("invalid user id"))
		return
	}

	// Vérifier que l'utilisateur peut accéder à ses propres stats
	var authenticatedUserID *uuid.UUID
	if uid, ok := c.Get("user_id"); ok {
		if uidUUID, ok := uid.(uuid.UUID); ok {
			authenticatedUserID = &uidUUID
		}
	}
	if authenticatedUserID != nil && *authenticatedUserID != userID {
		RespondWithAppError(c, apperrors.NewForbiddenError("cannot access other user's stats"))
		return
	}

	stats, err := h.analyticsService.GetUserStats(c.Request.Context(), userID)
	if err != nil {
		if err.Error() == "user not found" {
			RespondWithAppError(c, apperrors.NewNotFoundError("user"))
			return
		}
		RespondWithAppError(c, apperrors.Wrap(apperrors.ErrCodeInternal, "Failed to get user stats", err))
		return
	}

	RespondSuccess(c, http.StatusOK, gin.H{"stats": stats})
}

// GetTrackAnalyticsDashboard gère la récupération du dashboard d'analytics complet pour un track
// BE-API-036: GET /api/v1/analytics/tracks/:id returns comprehensive track analytics
// @Summary      Get Track Analytics Dashboard
// @Description  Get comprehensive analytics dashboard for a track
// @Tags         Analytics
// @Accept       json
// @Produce      json
// @Security     BearerAuth
// @Param        id   path      string  true  "Track ID"
// @Success      200  {object}  APIResponse{data=object{dashboard=object}}
// @Failure      400  {object}  APIResponse "Validation Error"
// @Failure      404  {object}  APIResponse "Track not found"
// @Failure      500  {object}  APIResponse "Internal Error"
// @Router       /analytics/tracks/{id} [get]
func (h *AnalyticsHandler) GetTrackAnalyticsDashboard(c *gin.Context) {
	trackIDStr := c.Param("id")
	if trackIDStr == "" {
		RespondWithAppError(c, apperrors.NewValidationError("track id is required"))
		return
	}

	trackID, err := uuid.Parse(trackIDStr)
	if err != nil {
		RespondWithAppError(c, apperrors.NewValidationError("invalid track id"))
		return
	}

	// Récupérer les statistiques de base
	stats, err := h.analyticsService.GetTrackStats(c.Request.Context(), trackID)
	if err != nil {
		if err.Error() == "track not found" {
			RespondWithAppError(c, apperrors.NewNotFoundError("track"))
			return
		}
		RespondWithAppError(c, apperrors.Wrap(apperrors.ErrCodeInternal, "Failed to get track stats", err))
		return
	}

	// Récupérer les lectures sur une période (30 derniers jours)
	startDate := time.Now().AddDate(0, 0, -30)
	endDate := time.Now()
	playsOverTime, err := h.analyticsService.GetPlaysOverTime(c.Request.Context(), trackID, startDate, endDate, "day")
	if err != nil {
		// Ne pas échouer si on ne peut pas récupérer les données temporelles
		playsOverTime = []services.PlayTimePoint{}
	}

	// Construire le dashboard complet
	dashboard := gin.H{
		"track_id": trackID.String(),
		"stats": gin.H{
			"total_plays":       stats.TotalPlays,
			"unique_listeners":  stats.UniqueListeners,
			"average_duration":  stats.AverageDuration,
			"completion_rate":   stats.CompletionRate,
		},
		"plays_over_time": playsOverTime,
		"period": gin.H{
			"start_date": startDate.Format(time.RFC3339),
			"end_date":   endDate.Format(time.RFC3339),
			"days":       30,
		},
	}

	RespondSuccess(c, http.StatusOK, gin.H{
		"dashboard": dashboard,
	})
}

// RecordEventRequest représente la requête pour enregistrer un événement analytics personnalisé
// BE-API-035: POST /api/v1/analytics/events to record custom analytics events
type RecordEventRequest struct {
	EventName string                 `json:"event_name" binding:"required,min=1,max=100" validate:"required,min=1,max=100"`
	Payload   map[string]interface{} `json:"payload,omitempty" validate:"omitempty"`
}

// RecordEvent gère l'enregistrement d'un événement analytics personnalisé
// BE-API-035: Implement analytics events endpoint
// @Summary      Record Analytics Event
// @Description  Record a custom analytics event
// @Tags         Analytics
// @Accept       json
// @Produce      json
// @Security     BearerAuth
// @Param        request body RecordEventRequest true "Event Data"
// @Success      200  {object}  APIResponse{data=object{message=string}}
// @Failure      400  {object}  APIResponse "Validation Error"
// @Failure      401  {object}  APIResponse "Unauthorized"
// @Failure      500  {object}  APIResponse "Internal Error"
// @Router       /analytics/events [post]
func (h *AnalyticsHandler) RecordEvent(c *gin.Context) {
	var req RecordEventRequest
	if appErr := h.commonHandler.BindAndValidateJSON(c, &req); appErr != nil {
		RespondWithAppError(c, appErr)
		return
	}

	// Récupérer user_id si authentifié (optionnel pour analytics anonymes)
	var userID *uuid.UUID
	if uid, ok := c.Get("user_id"); ok {
		if uidUUID, ok := uid.(uuid.UUID); ok {
			userID = &uidUUID
		}
	}

	// Vérifier que le JobWorker est disponible
	if h.jobWorker == nil {
		RespondWithAppError(c, apperrors.New(apperrors.ErrCodeInternal, "analytics service not available"))
		return
	}

	// Enqueue l'événement analytics via le JobWorker
	h.jobWorker.EnqueueAnalyticsJob(req.EventName, userID, req.Payload)

	RespondSuccess(c, http.StatusOK, gin.H{
		"message":    "event recorded",
		"event_name": req.EventName,
	})
}
