package controllers

import (
	"crypto/rand"
	"fmt"
	"net/http"
	"net/url"
	"os"
	"strconv"
	"strings"
	"time"

	"fotbal-club/internal/config"
	"fotbal-club/internal/models"
	"fotbal-club/internal/services"
	"fotbal-club/pkg/email"
	"fotbal-club/pkg/logger"
	"fotbal-club/pkg/utils"

	"github.com/gin-gonic/gin"
	"gorm.io/datatypes"
	"gorm.io/gorm"
)

type ContactController struct {
	DB           *gorm.DB
	emailService email.EmailService
}

// GetNewsletterTokenForUser returns a short-lived newsletter preferences token for the authenticated user's email
// GET /api/v1/newsletter/token/me (auth required)
func (cc *ContactController) GetNewsletterTokenForUser(c *gin.Context) {
	u, ok := c.Get("user")
	if !ok || u == nil {
		c.JSON(http.StatusUnauthorized, gin.H{"error": "Not authenticated"})
		return
	}

	user := u.(*models.User)
	email := strings.TrimSpace(strings.ToLower(user.Email))
	if email == "" {
		c.JSON(http.StatusBadRequest, gin.H{"error": "User email not available"})
		return
	}

	// Generate a 24h token for managing newsletter preferences
	token, err := utils.GenerateSubscriberToken(email, 60*24)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to generate token"})
		return
	}

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

// SendNewsletterDigest builds and sends a digest newsletter based on a template type (admin only)
// POST /api/v1/admin/newsletter/send-digest { type: "blogs|events|matches|scores|weekly", competitions?: "ABC, DEF" }
func (cc *ContactController) SendNewsletterDigest(c *gin.Context) {
	if c.GetString("userRole") != "admin" {
		c.JSON(http.StatusForbidden, gin.H{"error": "Access denied"})
		return
	}

	var input struct {
		Type         string `json:"type" binding:"required"`
		Competitions string `json:"competitions"`
	}
	if err := c.ShouldBindJSON(&input); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid input"})
		return
	}

	t := strings.ToLower(strings.TrimSpace(input.Type))
	allowed := map[string]bool{"blogs": true, "events": true, "matches": true, "scores": true, "weekly": true}
	if !allowed[t] {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Unknown digest type"})
		return
	}

	// Fetch active subscribers
	var subscribers []models.NewsletterSubscription
	if err := cc.DB.Where("is_active = ?", true).Find(&subscribers).Error; err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to load subscribers"})
		return
	}
	if len(subscribers) == 0 {
		c.JSON(http.StatusBadRequest, gin.H{"error": "No active subscribers"})
		return
	}

	// Build digest content once based on selected type
	prefs := services.NewsletterPrefs{
		Email:        "digest@local",
		ContentTypes: []string{},
		Competitions: []string{},
		Frequency:    "daily",
	}
	if t == "weekly" {
		prefs.ContentTypes = []string{"blogs", "events", "matches", "scores"}
		prefs.Frequency = "weekly"
	} else {
		prefs.ContentTypes = []string{t}
	}
	if strings.TrimSpace(input.Competitions) != "" {
		for _, p := range strings.Split(input.Competitions, ",") {
			if v := strings.TrimSpace(p); v != "" {
				prefs.Competitions = append(prefs.Competitions, v)
			}
		}
	}
	subj, html := services.BuildNewsletterDigest("cache/prefetch", prefs)
	if strings.TrimSpace(html) == "" {
		c.JSON(http.StatusBadRequest, gin.H{"error": "No content for selected digest"})
		return
	}

	// Recipients list
	recipients := make([]string, 0, len(subscribers))
	for _, s := range subscribers {
		if s.Email != "" {
			recipients = append(recipients, s.Email)
		}
	}
	if len(recipients) == 0 {
		c.JSON(http.StatusBadRequest, gin.H{"error": "No valid recipient emails"})
		return
	}

	if subj == "" {
		subj = strings.Title(t) + " digest"
	}

	data := &email.NewsletterData{Subject: subj, Content: html, Recipients: recipients}
	if err := cc.emailService.SendNewsletter(data); err != nil {
		logger.Error("Failed to send digest newsletter: %v", err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to send digest newsletter"})
		return
	}

	c.JSON(http.StatusOK, gin.H{"message": "Digest newsletter sent", "recipients": len(recipients), "type": t})
}

// UpdateNewsletterAutomation toggles the automated newsletter scheduler at runtime (non-persistent)
// PATCH /api/v1/admin/newsletter/enable { enabled: boolean }
func (cc *ContactController) UpdateNewsletterAutomation(c *gin.Context) {
	if c.GetString("userRole") != "admin" {
		c.JSON(http.StatusForbidden, gin.H{"error": "Access denied"})
		return
	}
	var input struct {
		Enabled bool `json:"enabled"`
	}
	if err := c.ShouldBindJSON(&input); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid payload"})
		return
	}
	// Persist to Settings (singleton row)
	var s models.Settings
	_ = cc.DB.First(&s).Error // ignore not found
	if s.ID == 0 {
		s = models.Settings{}
	}
	s.NewsletterEnabled = input.Enabled
	if s.ID == 0 {
		if err := cc.DB.Create(&s).Error; err != nil {
			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to persist setting"})
			return
		}
	} else if err := cc.DB.Save(&s).Error; err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to persist setting"})
		return
	}
	// Flip the in-memory config flag; effective immediately for next tick
	if config.AppConfig != nil {
		config.AppConfig.NewsletterEnabled = input.Enabled
	}
	c.JSON(http.StatusOK, gin.H{"newsletter_enabled": input.Enabled})
}

// GetNewsletterStatus returns basic scheduling/status info for newsletters (admin only)
// @Summary Newsletter status
// @Description Returns subscriber stats and next approximate run time based on interval
// @Tags admin
// @Security Bearer
// @Produce json
// @Success 200 {object} map[string]interface{}
// @Failure 401 {object} map[string]string
// @Failure 403 {object} map[string]string
// @Router /api/v1/admin/newsletter/status [get]
func (cc *ContactController) GetNewsletterStatus(c *gin.Context) {
	if c.GetString("userRole") != "admin" {
		c.JSON(http.StatusForbidden, gin.H{"error": "Access denied"})
		return
	}

	var total int64
	var active int64
	cc.DB.Model(&models.NewsletterSubscription{}).Count(&total)
	cc.DB.Model(&models.NewsletterSubscription{}).Where("is_active = ?", true).Count(&active)

	var subs []models.NewsletterSubscription
	_ = cc.DB.Where("is_active = ?", true).Limit(20).Find(&subs).Error
	sample := make([]string, 0, len(subs))
	for _, s := range subs {
		if s.Email != "" {
			sample = append(sample, s.Email)
		}
	}

	interval := 24 * time.Hour
	if v := strings.TrimSpace(os.Getenv("NEWSLETTER_INTERVAL_HOURS")); v != "" {
		if d, err := time.ParseDuration(v + "h"); err == nil {
			interval = d
		}
	}
	next := time.Now().Add(interval)

	c.JSON(http.StatusOK, gin.H{
		"total_subscribers":  total,
		"active_subscribers": active,
		"sample_recipients":  sample,
		"interval_minutes":   int(interval.Minutes()),
		"next_approximate":   next,
		"newsletter_enabled": config.AppConfig != nil && config.AppConfig.NewsletterEnabled,
	})
}

// PreviewNewsletter builds a digest preview (subject + html) for admin without sending
// @Summary Preview newsletter digest (admin)
// @Description Returns subject and HTML for a digest newsletter using current cache and optional preferences
// @Tags admin
// @Security Bearer
// @Accept json
// @Produce json
// @Param prefs body map[string]interface{} false "Optional { preferences: { blogs, matches, events, scores, competitions } }"
// @Success 200 {object} map[string]string
// @Failure 401 {object} map[string]string
// @Failure 403 {object} map[string]string
// @Router /api/v1/admin/newsletter/preview [post]
func (cc *ContactController) PreviewNewsletter(c *gin.Context) {
	if c.GetString("userRole") != "admin" {
		c.JSON(http.StatusForbidden, gin.H{"error": "Access denied"})
		return
	}
	var input struct {
		Preferences map[string]interface{} `json:"preferences"`
	}
	_ = c.ShouldBindJSON(&input)

	// Normalize preferences to NewsletterPrefs
	prefs := services.NewsletterPrefs{
		Email:        "preview@local",
		ContentTypes: []string{},
		Competitions: []string{},
		Frequency:    "daily",
	}
	if m := input.Preferences; m != nil {
		if b, ok := m["blogs"].(bool); ok && b {
			prefs.ContentTypes = append(prefs.ContentTypes, "blogs")
		}
		if b, ok := m["events"].(bool); ok && b {
			prefs.ContentTypes = append(prefs.ContentTypes, "events")
		}
		if b, ok := m["matches"].(bool); ok && b {
			prefs.ContentTypes = append(prefs.ContentTypes, "matches")
		}
		if b, ok := m["scores"].(bool); ok && b {
			prefs.ContentTypes = append(prefs.ContentTypes, "scores")
		}
		if cs, ok := m["competitions"].(string); ok && strings.TrimSpace(cs) != "" {
			parts := strings.Split(cs, ",")
			for _, p := range parts {
				if v := strings.TrimSpace(p); v != "" {
					prefs.Competitions = append(prefs.Competitions, v)
				}
			}
		}
	}

	cacheDir := "cache/prefetch"
	subj, html := services.BuildNewsletterDigest(cacheDir, prefs)
	c.JSON(http.StatusOK, gin.H{"subject": subj, "html": html})
}

// GetNewsletterPreferencesByToken returns subscriber preferences using a token (no auth required)
// GET /api/v1/newsletter/preferences?token=...
func (cc *ContactController) GetNewsletterPreferencesByToken(c *gin.Context) {
	token := strings.TrimSpace(c.Query("token"))
	if token == "" {
		c.JSON(http.StatusBadRequest, gin.H{"error": "token is required"})
		return
	}

	emailStr, err := utils.ParseSubscriberToken(token)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid or expired token"})
		return
	}

	var sub models.NewsletterSubscription
	if err := cc.DB.Where("email = ?", emailStr).First(&sub).Error; err != nil {
		c.JSON(http.StatusNotFound, gin.H{"error": "Subscription not found"})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"email":       sub.Email,
		"is_active":   sub.IsActive,
		"preferences": sub.Preferences,
	})
}

// SaveNewsletterPreferencesByToken saves subscriber preferences using a token (no auth required)
// POST /api/v1/newsletter/preferences { token, preferences }
func (cc *ContactController) SaveNewsletterPreferencesByToken(c *gin.Context) {
	var input struct {
		Token       string                 `json:"token" binding:"required"`
		Preferences map[string]interface{} `json:"preferences" binding:"required"`
	}
	if err := c.ShouldBindJSON(&input); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid payload"})
		return
	}

	emailStr, err := utils.ParseSubscriberToken(input.Token)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid or expired token"})
		return
	}

	var sub models.NewsletterSubscription
	if err := cc.DB.Where("email = ?", emailStr).First(&sub).Error; err != nil {
		c.JSON(http.StatusNotFound, gin.H{"error": "Subscription not found"})
		return
	}

	jm := datatypes.JSONMap{}
	for key, raw := range input.Preferences {
		switch v := raw.(type) {
		case bool:
			jm[key] = v
		case string:
			jm[key] = strings.TrimSpace(v)
		case []interface{}:
			compiled := make([]string, 0, len(v))
			for _, item := range v {
				if s, ok := item.(string); ok {
					if trimmed := strings.TrimSpace(s); trimmed != "" {
						compiled = append(compiled, trimmed)
					}
				}
			}
			jm[key] = strings.Join(compiled, ", ")
		case float64, int, int64:
			jm[key] = v
		case nil:
			jm[key] = nil
		default:
			c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("Unsupported preference type for %s", key)})
			return
		}
	}

	if compVal, ok := jm["competitions"]; ok {
		if compStr, ok := compVal.(string); ok {
			comp := strings.TrimSpace(compStr)
			jm["competitions"] = comp
			if comp != "" {
				if catVal, exists := jm["categories"]; !exists {
					jm["categories"] = comp
				} else if catStr, ok := catVal.(string); ok && strings.TrimSpace(catStr) == "" {
					jm["categories"] = comp
				}
			}
		}
	}

	sub.Preferences = jm
	sub.UpdatedAt = time.Now()
	if err := cc.DB.Save(&sub).Error; err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to save preferences"})
		return
	}

	c.JSON(http.StatusOK, gin.H{"message": "Preferences saved"})
}

// UnsubscribeByToken disables newsletter using a token (no auth required)
// POST /api/v1/newsletter/unsubscribe-token { token }
func (cc *ContactController) UnsubscribeByToken(c *gin.Context) {
	var input struct {
		Token string `json:"token" binding:"required"`
	}
	if err := c.ShouldBindJSON(&input); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid payload"})
		return
	}
	emailStr, err := utils.ParseSubscriberToken(input.Token)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid or expired token"})
		return
	}
	if err := cc.DB.Model(&models.NewsletterSubscription{}).Where("email = ?", emailStr).Update("is_active", false).Error; err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to unsubscribe"})
		return
	}
	c.JSON(http.StatusOK, gin.H{"message": "You have been unsubscribed"})
}

// DeleteNewsletterSubscriber deletes a newsletter subscriber (admin only)
// @Summary Delete newsletter subscriber
// @Description Deletes a newsletter subscriber by ID (admin only)
// @Tags admin
// @Security Bearer
// @Produce json
// @Param id path int true "Subscriber ID"
// @Success 200 {object} map[string]string
// @Failure 400 {object} map[string]string
// @Failure 401 {object} map[string]string
// @Failure 403 {object} map[string]string
// @Failure 404 {object} map[string]string
// @Router /api/v1/admin/newsletter/subscribers/{id} [delete]
func (cc *ContactController) DeleteNewsletterSubscriber(c *gin.Context) {
	if c.GetString("userRole") != "admin" {
		c.JSON(http.StatusForbidden, gin.H{"error": "Access denied"})
		return
	}

	id, err := strconv.Atoi(c.Param("id"))
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid subscriber ID"})
		return
	}

	result := cc.DB.Delete(&models.NewsletterSubscription{}, id)
	if result.Error != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to delete subscriber"})
		return
	}
	if result.RowsAffected == 0 {
		c.JSON(http.StatusNotFound, gin.H{"error": "Subscriber not found"})
		return
	}
	c.JSON(http.StatusOK, gin.H{"message": "Subscriber deleted successfully"})
}

// UpdateNewsletterSubscriberStatus toggles a subscriber's active status (admin only)
// @Summary Update newsletter subscriber status
// @Description Updates the is_active status of a newsletter subscriber (admin only)
// @Tags admin
// @Security Bearer
// @Accept json
// @Produce json
// @Param id path int true "Subscriber ID"
// @Param input body map[string]bool true "{ is_active: boolean }"
// @Success 200 {object} models.NewsletterSubscription
// @Failure 400 {object} map[string]string
// @Failure 401 {object} map[string]string
// @Failure 403 {object} map[string]string
// @Failure 404 {object} map[string]string
// @Router /api/v1/admin/newsletter/subscribers/{id}/status [patch]
func (cc *ContactController) UpdateNewsletterSubscriberStatus(c *gin.Context) {
	if c.GetString("userRole") != "admin" {
		c.JSON(http.StatusForbidden, gin.H{"error": "Access denied"})
		return
	}

	id, err := strconv.Atoi(c.Param("id"))
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid subscriber ID"})
		return
	}

	var input struct {
		IsActive bool `json:"is_active" binding:"required"`
	}
	if err := c.ShouldBindJSON(&input); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request body"})
		return
	}

	var sub models.NewsletterSubscription
	if err := cc.DB.First(&sub, id).Error; err != nil {
		if err == gorm.ErrRecordNotFound {
			c.JSON(http.StatusNotFound, gin.H{"error": "Subscriber not found"})
		} else {
			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to fetch subscriber"})
		}
		return
	}

	sub.IsActive = input.IsActive
	sub.UpdatedAt = time.Now()
	if err := cc.DB.Save(&sub).Error; err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to update subscriber"})
		return
	}

	c.JSON(http.StatusOK, sub)
}

// UpdateNewsletterSubscriberPreferences updates subscriber preferences (admin only)
// @Summary Update newsletter subscriber preferences
// @Description Updates the preferences JSON for a subscriber (admin only)
// @Tags admin
// @Security Bearer
// @Accept json
// @Produce json
// @Param id path int true "Subscriber ID"
// @Param input body map[string]bool true "Preferences map"
// @Success 200 {object} models.NewsletterSubscription
// @Failure 400 {object} map[string]string
// @Failure 401 {object} map[string]string
// @Failure 403 {object} map[string]string
// @Failure 404 {object} map[string]string
// @Router /api/v1/admin/newsletter/subscribers/{id}/preferences [patch]
func (cc *ContactController) UpdateNewsletterSubscriberPreferences(c *gin.Context) {
	if c.GetString("userRole") != "admin" {
		c.JSON(http.StatusForbidden, gin.H{"error": "Access denied"})
		return
	}

	id, err := strconv.Atoi(c.Param("id"))
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid subscriber ID"})
		return
	}

	var prefs map[string]bool
	if err := c.ShouldBindJSON(&prefs); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid preferences payload"})
		return
	}

	var sub models.NewsletterSubscription
	if err := cc.DB.First(&sub, id).Error; err != nil {
		if err == gorm.ErrRecordNotFound {
			c.JSON(http.StatusNotFound, gin.H{"error": "Subscriber not found"})
		} else {
			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to fetch subscriber"})
		}
		return
	}

	// convert map[string]bool to datatypes.JSONMap
	jm := datatypes.JSONMap{}
	for k, v := range prefs {
		jm[k] = v
	}
	sub.Preferences = jm
	sub.UpdatedAt = time.Now()
	if err := cc.DB.Save(&sub).Error; err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to update preferences"})
		return
	}

	c.JSON(http.StatusOK, sub)
}

// SendNewsletterTest sends a test newsletter email to a single recipient (admin only)
// @Summary Send test newsletter email
// @Description Sends a test newsletter email to a single recipient (admin only)
// @Tags admin
// @Security Bearer
// @Accept json
// @Produce json
// @Param input body map[string]string false "Optional {email} to send test to"
// @Success 200 {object} map[string]string
// @Failure 400 {object} map[string]string
// @Failure 401 {object} map[string]string
// @Failure 403 {object} map[string]string
// @Router /api/v1/admin/newsletter/test [post]
func (cc *ContactController) SendNewsletterTest(c *gin.Context) {
	if c.GetString("userRole") != "admin" {
		c.JSON(http.StatusForbidden, gin.H{"error": "Access denied"})
		return
	}

	var input struct {
		Email  string   `json:"email"`
		Emails []string `json:"emails"`
		Type   string   `json:"type"`
	}
	_ = c.ShouldBindJSON(&input)

	// Resolve recipients (emails > email > admin)
	recipients := make([]string, 0)
	if len(input.Emails) > 0 {
		for _, e := range input.Emails {
			if v := strings.TrimSpace(e); v != "" {
				recipients = append(recipients, v)
			}
		}
	}
	if len(recipients) == 0 {
		if v := strings.TrimSpace(input.Email); v != "" {
			recipients = append(recipients, v)
		}
	}
	if len(recipients) == 0 {
		if v := strings.TrimSpace(config.AppConfig.AdminEmail); v != "" {
			recipients = append(recipients, v)
		}
	}
	if len(recipients) == 0 {
		c.JSON(http.StatusBadRequest, gin.H{"error": "No recipient email provided"})
		return
	}

	t := strings.ToLower(strings.TrimSpace(input.Type))
	if t == "" {
		t = "newsletter"
	}

	logger.Info("[SendNewsletterTest] type=%s recipients=%v", t, recipients)

	switch t {
	case "newsletter":
		testHTML := `<p>Toto je testovací newsletter z Fotbal Club. Nastavení SMTP funguje.</p>`
		data := &email.NewsletterData{Subject: "Test newsletter", Content: testHTML, Recipients: recipients}
		logger.Debug("[SendNewsletterTest] invoking emailService.SendNewsletter for %d recipient(s)", len(recipients))
		if err := cc.emailService.SendNewsletter(data); err != nil {
			logger.Error("Failed to send test newsletter: %v", err)
			if config.AppConfig != nil && config.AppConfig.AppEnv != "production" {
				c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to send test newsletter", "details": err.Error()})
			} else {
				c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to send test newsletter"})
			}
			return
		}
	case "welcome":
		for _, r := range recipients {
			w := &email.NewsletterWelcomeData{Email: r, UnsubscribeLink: ""}
			if err := cc.emailService.SendNewsletterWelcome(w); err != nil {
				logger.Error("Failed to send welcome test to %s: %v", r, err)
			}
		}
	case "welcome_back":
		for _, r := range recipients {
			w := &email.NewsletterWelcomeBackData{Email: r}
			if err := cc.emailService.SendNewsletterWelcomeBack(w); err != nil {
				logger.Error("Failed to send welcome back test to %s: %v", r, err)
			}
		}
	case "setup":
		// Test subscription setup email with token
		for _, r := range recipients {
			token, tErr := utils.GenerateSubscriberToken(r, 60*24)
			if tErr != nil {
				logger.Error("Failed to generate token for setup test: %v", tErr)
				continue
			}
			baseFE := strings.TrimSuffix(config.AppConfig.FrontendBaseURL, "/")
			setupURL := baseFE + "/newsletter/setup?token=" + url.QueryEscape(token)
			setupEmail := &email.EmailData{
				Subject:  "Test: Nastavte svůj newsletter",
				To:       []string{r},
				Template: "newsletter_setup",
				Data:     struct{ SetupURL string }{SetupURL: setupURL},
			}
			if err := cc.emailService.SendEmail(setupEmail); err != nil {
				logger.Error("Failed to send setup test to %s: %v", r, err)
			}
		}
	case "match_reminder_48h":
		// Test 48h match reminder
		testHTML := `
<div style="max-width: 600px; margin: 0 auto; font-family: Arial, sans-serif;">
	<h2 style="color: #1e3a8a; margin-bottom: 20px;">Připomínáme nadcházející zápas:</h2>
	<div style="border-left: 4px solid #38a169; padding: 20px; background: #f0fff4; margin: 20px 0;">
		<h3 style="margin: 0 0 10px 0; color: #1e3a8a; font-size: 24px;">FC Test vs SK Example</h3>
		<p style="color: #276749; margin: 5px 0;"><strong>Datum:</strong> 2025-10-02</p>
		<p style="color: #276749; margin: 5px 0;"><strong>Čas:</strong> 17:00</p>
		<p style="color: #276749; margin: 5px 0;"><strong>Soutěž:</strong> MFS A</p>
		<p style="color: #276749; margin: 5px 0;"><strong>Místo:</strong> Sportovní areál Test</p>
	</div>
	<p style="color: #4a5568; margin-top: 20px;">Zápas začíná za 48 hodin. Nezapomeňte!</p>
</div>`
		data := &email.NewsletterData{Subject: "Test: Nadcházející zápas za 48 hodin", Content: testHTML, Recipients: recipients}
		if err := cc.emailService.SendNewsletter(data); err != nil {
			logger.Error("Failed to send match reminder test: %v", err)
			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to send test"})
			return
		}
	case "match_reminder_today":
		// Test day-of match reminder
		testHTML := `
<div style="max-width: 600px; margin: 0 auto; font-family: Arial, sans-serif;">
	<h2 style="color: #1e3a8a; margin-bottom: 20px;">Zápas je dnes!</h2>
	<div style="border-left: 4px solid #38a169; padding: 20px; background: #f0fff4; margin: 20px 0;">
		<h3 style="margin: 0 0 10px 0; color: #1e3a8a; font-size: 24px;">FC Test vs SK Example</h3>
		<p style="color: #276749; margin: 5px 0;"><strong>Datum:</strong> Dnes</p>
		<p style="color: #276749; margin: 5px 0;"><strong>Čas:</strong> 17:00</p>
		<p style="color: #276749; margin: 5px 0;"><strong>Soutěž:</strong> MFS A</p>
		<p style="color: #276749; margin: 5px 0;"><strong>Místo:</strong> Sportovní areál Test</p>
	</div>
	<p style="color: #4a5568; margin-top: 20px;">Přijďte fandit!</p>
</div>`
		data := &email.NewsletterData{Subject: "Test: Zápas dnes", Content: testHTML, Recipients: recipients}
		if err := cc.emailService.SendNewsletter(data); err != nil {
			logger.Error("Failed to send match today test: %v", err)
			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to send test"})
			return
		}
	case "blog_notification":
		// Test blog release notification
		testHTML := `
<div style="max-width: 600px; margin: 0 auto; font-family: Arial, sans-serif;">
	<h2 style="color: #1e3a8a; margin-bottom: 20px;">Nový článek na webu</h2>
	<div style="border-left: 4px solid #2563eb; padding: 20px; background: #f8fafc; margin: 20px 0;">
		<h3 style="margin: 0 0 15px 0; color: #1e3a8a;">Testovací článek: Zajímavosti ze sezóny</h3>
		<p style="color: #4a5568; line-height: 1.6; margin: 0 0 15px 0;">Toto je ukázkový výňatek z nového článku na našem webu. Přečtěte si celý příběh a dozvíte se více zajímavostí ze sezóny.</p>
		<a href="https://example.com/news/test" style="display: inline-block; padding: 12px 24px; background: #2563eb; color: white; text-decoration: none; border-radius: 6px; font-weight: 600;">Číst článek</a>
	</div>
</div>`
		data := &email.NewsletterData{Subject: "Test: Nový článek - Zajímavosti ze sezóny", Content: testHTML, Recipients: recipients}
		if err := cc.emailService.SendNewsletter(data); err != nil {
			logger.Error("Failed to send blog notification test: %v", err)
			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to send test"})
			return
		}
	case "match_result":
		// Test match result notification
		testHTML := `
<div style="max-width: 600px; margin: 0 auto; font-family: Arial, sans-serif;">
	<h2 style="color: #1e3a8a; margin-bottom: 20px;">Výsledek zápasu</h2>
	<div style="border-left: 4px solid #d69e2e; padding: 20px; background: #fffbeb; margin: 20px 0;">
		<h3 style="margin: 0 0 10px 0; color: #1e3a8a; font-size: 24px;">FC Test <span style="color: #d69e2e;">3:2</span> SK Example</h3>
		<p style="color: #975a16; margin: 5px 0;"><strong>Datum:</strong> 2025-09-30</p>
		<p style="color: #975a16; margin: 5px 0;"><strong>Soutěž:</strong> MFS A</p>
		<p style="color: #975a16; margin: 10px 0 0 0;">Gratulujeme týmu k vítězství!</p>
	</div>
</div>`
		data := &email.NewsletterData{Subject: "Test: Výsledek - FC Test 3:2 SK Example", Content: testHTML, Recipients: recipients}
		if err := cc.emailService.SendNewsletter(data); err != nil {
			logger.Error("Failed to send match result test: %v", err)
			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to send test"})
			return
		}
	// Predefined digest test types mapped to content sections
	case "blogs", "events", "matches", "scores", "weekly":
		prefs := services.NewsletterPrefs{
			Email:        recipients[0],
			ContentTypes: []string{},
			Competitions: []string{},
			Frequency:    "daily",
		}
		if t == "weekly" {
			prefs.ContentTypes = []string{"blogs", "events", "matches", "scores"}
			prefs.Frequency = "weekly"
		} else {
			prefs.ContentTypes = []string{t}
		}
		cacheDir := "cache/prefetch"
		subj, html := services.BuildNewsletterDigest(cacheDir, prefs)
		if subj == "" {
			subj = "Test digest"
		}
		if html == "" {
			html = "<p>Momentálně žádný obsah pro zvolený typ.</p>"
		}
		data := &email.NewsletterData{Subject: subj, Content: html, Recipients: recipients}
		if err := cc.emailService.SendNewsletter(data); err != nil {
			logger.Error("Failed to send digest test: %v", err)
			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to send digest test"})
			return
		}
	default:
		c.JSON(http.StatusBadRequest, gin.H{"error": "Unknown test type"})
		return
	}

	c.JSON(http.StatusOK, gin.H{"message": "Test email(s) sent", "recipients": recipients, "type": t})
}

func NewContactController(db *gorm.DB, emailService email.EmailService) *ContactController {
	return &ContactController{
		DB:           db,
		emailService: emailService,
	}
}

type ContactFormRequest struct {
	Name    string `json:"name" binding:"required"`
	Email   string `json:"email" binding:"required,email"`
	Subject string `json:"subject" binding:"required"`
	Message string `json:"message" binding:"required"`
	Source  string `json:"source"` // e.g., "contact", "sponsor"
}

// SubmitContactForm handles contact form submissions
// @Summary Submit contact form
// @Description Handles contact form submissions and sends an email notification
// @Tags contact
// @Accept json
// @Produce json
// @Param input body ContactFormRequest true "Contact form data"
// @Success 200 {object} map[string]string
// @Failure 400 {object} map[string]string
// @Router /api/v1/contact [post]
func (cc *ContactController) SubmitContactForm(c *gin.Context) {
	var input ContactFormRequest
	if err := c.ShouldBindJSON(&input); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	// Normalize source field
	source := strings.TrimSpace(input.Source)
	if source == "" {
		source = "contact"
	}

	// Save to database
	contactMessage := models.ContactMessage{
		Name:      input.Name,
		Email:     input.Email,
		Subject:   input.Subject,
		Message:   input.Message,
		Source:    source,
		IPAddress: c.ClientIP(),
		UserAgent: c.Request.UserAgent(),
		IsRead:    false,
	}

	if err := cc.DB.Create(&contactMessage).Error; err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to save contact message"})
		return
	}

	// Send email notification asynchronously to prevent frontend timeout
	go func() {
		emailData := &email.ContactFormData{
			Name:      input.Name,
			Email:     input.Email,
			Subject:   input.Subject,
			Message:   input.Message,
			IPAddress: c.ClientIP(),
			UserAgent: c.Request.UserAgent(),
		}

		if err := cc.emailService.SendContactForm(emailData); err != nil {
			logger.Error("Failed to send contact form email: %v", err)
		}
	}()

	c.JSON(http.StatusOK, gin.H{"message": "Your message has been sent successfully"})
}

type NewsletterSubscriptionRequest struct {
	Email       string          `json:"email" binding:"required,email"`
	Preferences map[string]bool `json:"preferences"`
}

// SubscribeToNewsletter handles newsletter subscriptions
// @Summary Subscribe to newsletter
// @Description Handles newsletter subscription requests
// @Tags newsletter
// @Accept json
// @Produce json
// @Param input body NewsletterSubscriptionRequest true "Subscription data"
// @Success 200 {object} map[string]string
// @Failure 400 {object} map[string]string
// @Router /api/v1/newsletter/subscribe [post]
func (cc *ContactController) SubscribeToNewsletter(c *gin.Context) {
	var input NewsletterSubscriptionRequest
	if err := c.ShouldBindJSON(&input); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	// Check if email already exists
	var subscription models.NewsletterSubscription
	result := cc.DB.Where("email = ?", input.Email).First(&subscription)

	if result.Error == nil {
		if !subscription.IsActive {
			// Reactivate existing subscription
			subscription.IsActive = true
			subscription.UpdatedAt = time.Now()
			// Update preferences if provided (convert to JSONMap)
			if input.Preferences != nil {
				jm := datatypes.JSONMap{}
				for k, v := range input.Preferences {
					jm[k] = v
				}
				subscription.Preferences = jm
			}
			if err := cc.DB.Save(&subscription).Error; err != nil {
				c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to update subscription"})
				return
			}

			// Send welcome back email in a goroutine
			go func(sub models.NewsletterSubscription) {
				manageURL := ""
				unsubscribeURL := ""
				token, tErr := utils.GenerateSubscriberToken(sub.Email, 60*24)
				if tErr != nil {
					logger.Error("Failed to generate subscriber token: %v", tErr)
				} else {
					baseFE := strings.TrimSuffix(config.AppConfig.FrontendBaseURL, "/")
					if baseFE != "" {
						link := baseFE + "/newsletter/preferences?token=" + url.QueryEscape(token)
						manageURL = link
						unsubscribeURL = link
					}
				}

				emailData := &email.NewsletterWelcomeBackData{
					Email:           sub.Email,
					ManageURL:       manageURL,
					UnsubscribeURL:  unsubscribeURL,
				}
				if err := cc.emailService.SendNewsletterWelcomeBack(emailData); err != nil {
					logger.Error("Failed to send welcome back email: %v", err)
				}
			}(subscription)

			c.JSON(http.StatusOK, gin.H{"message": "Welcome back! You have been resubscribed to our newsletter."})
			return
		}

		c.JSON(http.StatusOK, gin.H{"message": "You are already subscribed to our newsletter"})
		return
	}

	// Create new subscription. Default: enable everything if preferences omitted
	prefs := input.Preferences
	if prefs == nil {
		prefs = map[string]bool{"weekly": true, "matches": true, "blogs": true, "events": true}
	}
	// convert to datatypes.JSONMap
	jm := datatypes.JSONMap{}
	for k, v := range prefs {
		jm[k] = v
	}
	subscription = models.NewsletterSubscription{
		Email:       input.Email,
		IsActive:    true,
		Preferences: jm,
		CreatedAt:   time.Now(),
		UpdatedAt:   time.Now(),
	}

	if err := cc.DB.Create(&subscription).Error; err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to subscribe to newsletter"})
		return
	}

	// Generate a subscriber token to include in follow-up emails (preferences links)
	token, _ := utils.GenerateSubscriberToken(subscription.Email, 60*24) // 1 day
	baseFE := strings.TrimSuffix(config.AppConfig.FrontendBaseURL, "/")
	setupURL := baseFE + "/newsletter/setup?token=" + url.QueryEscape(token)
	unsubscribeURL := baseFE + "/newsletter/preferences?token=" + url.QueryEscape(token)

	// Auto-create fan user account if not exists
	var existingUser models.User
	if err := cc.DB.Where("LOWER(email) = LOWER(?)", subscription.Email).First(&existingUser).Error; err == gorm.ErrRecordNotFound {
		// Generate a strong random password (16 chars, mixed set)
		genPassword := func(n int) string {
			const letters = "abcdefghijklmnopqrstuvwxyz"
			const upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
			const digits = "0123456789"
			const symbols = "!@#$%^&*()-_=+[]{}?"
			pool := letters + upper + digits + symbols
			b := make([]byte, n)
			for i := 0; i < n; i++ {
				var rb [1]byte
				if _, err := rand.Read(rb[:]); err != nil {
					b[i] = pool[(time.Now().UnixNano()+int64(i))%int64(len(pool))]
					continue
				}
				b[i] = pool[int(rb[0])%len(pool)]
			}
			return string(b)
		}
		plain := genPassword(16)
		hashed, hErr := utils.HashPassword(plain)
		if hErr == nil {
			u := models.User{
				Email:     strings.TrimSpace(strings.ToLower(subscription.Email)),
				Password:  hashed,
				FirstName: "",
				LastName:  "",
				Role:      "fan",
				IsActive:  true,
			}
			if err := cc.DB.Create(&u).Error; err != nil {
				logger.Error("Failed to auto-create fan user for newsletter: %v", err)
			} else {
				// Send credentials email
				data := map[string]interface{}{
					"Email":        subscription.Email,
					"Password":     plain,
					"LoginURL":     baseFE + "/login",
					"ResetURL":     baseFE + "/forgot-password",
					"ManageURL":    setupURL,
					"UnsubscribeURL": unsubscribeURL,
				}
				credEmail := &email.EmailData{
					Subject:  "Váš fan účet byl vytvořen",
					To:       []string{subscription.Email},
					Template: "fan_account_created",
					Data:     data,
				}
				if err := cc.emailService.SendEmail(credEmail); err != nil {
					logger.Error("Failed to send fan account created email: %v", err)
				}
			}
		}
	}

	// Send setup email (link with token) AND welcome introduction email in goroutines
	go func() {
		// 1) Setup email
		setupEmail := &email.EmailData{
			Subject:  "Nastavte svůj newsletter",
			To:       []string{subscription.Email},
			Template: "newsletter_setup",
			Data:     struct{ SetupURL string }{SetupURL: setupURL},
		}
		if err := cc.emailService.SendEmail(setupEmail); err != nil {
			logger.Error("Failed to send setup email: %v", err)
		}

		// 2) Welcome introduction email (includes unsubscribe/manage link)
		welcome := &email.NewsletterWelcomeData{
			Email:           subscription.Email,
			UnsubscribeLink: unsubscribeURL,
		}
		if err := cc.emailService.SendNewsletterWelcome(welcome); err != nil {
			logger.Error("Failed to send welcome email: %v", err)
		}
	}()

	c.JSON(http.StatusOK, gin.H{"message": "Thank you for subscribing to our newsletter! Please check your email to confirm your subscription."})
}

// SetupNewsletterPreferences accepts a subscriber token and preferences to save choices
// ... (rest of the code remains the same)
// @Summary Setup newsletter preferences
// @Description Accepts token and preferences to save subscriber choices
// @Accept json
// @Produce json
// @Param input body map[string]interface{} true "{ token: string, preferences: { .. } }"
// @Success 200 {object} map[string]string
// @Failure 400 {object} map[string]string
// @Router /api/v1/newsletter/setup [post]
func (cc *ContactController) SetupNewsletterPreferences(c *gin.Context) {
	var input struct {
		Token       string          `json:"token" binding:"required"`
		Preferences map[string]bool `json:"preferences" binding:"required"`
	}
	if err := c.ShouldBindJSON(&input); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid payload"})
		return
	}

	emailStr, err := utils.ParseSubscriberToken(input.Token)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid or expired token"})
		return
	}

	var sub models.NewsletterSubscription
	if err := cc.DB.Where("email = ?", emailStr).First(&sub).Error; err != nil {
		c.JSON(http.StatusNotFound, gin.H{"error": "Subscription not found"})
		return
	}

	// convert map[string]bool to datatypes.JSONMap
	jm := datatypes.JSONMap{}
	for k, v := range input.Preferences {
		jm[k] = v
	}
	sub.Preferences = jm
	sub.UpdatedAt = time.Now()
	if err := cc.DB.Save(&sub).Error; err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to save preferences"})
		return
	}

	c.JSON(http.StatusOK, gin.H{"message": "Preferences saved"})
}

// GetContactMessages returns a list of contact messages (admin only)
// @Summary Get contact messages
// @Description Returns a paginated list of contact messages (admin only)
// @Tags admin
// @Security Bearer
// @Produce json
// @Param page query int false "Page number" default(1)
// @Param limit query int false "Items per page" default(10)
// @Success 200 {object} map[string]interface{}
// @Failure 401 {object} map[string]string
// @Failure 403 {object} map[string]string
// @Router /api/v1/admin/contact-messages [get]
func (cc *ContactController) GetContactMessages(c *gin.Context) {
	// Check if user is admin
	if c.GetString("userRole") != "admin" {
		c.JSON(http.StatusForbidden, gin.H{"error": "Access denied"})
		return
	}

	// Get pagination parameters
	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
	limit, _ := strconv.Atoi(c.DefaultQuery("limit", "10"))
	offset := (page - 1) * limit

	var messages []models.ContactMessage
	var total int64

	// Get total count
	if err := cc.DB.Model(&models.ContactMessage{}).Count(&total).Error; err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to fetch messages"})
		return
	}

	// Get paginated messages
	if err := cc.DB.Offset(offset).Limit(limit).Order("created_at DESC").Find(&messages).Error; err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to fetch messages"})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"data": messages,
		"pagination": gin.H{
			"total":    total,
			"page":     page,
			"limit":    limit,
			"pages":    (int(total) + limit - 1) / limit,
			"has_more": offset+limit < int(total),
		},
	})
}

// MarkMessageAsRead marks a contact message as read (admin only)
// @Summary Mark message as read
// @Description Marks a contact message as read (admin only)
// @Tags admin
// @Security Bearer
// @Produce json
// @Param id path int true "Message ID"
// @Success 200 {object} map[string]string
// @Failure 400 {object} map[string]string
// @Failure 401 {object} map[string]string
// @Failure 403 {object} map[string]string
// @Failure 404 {object} map[string]string
// @Router /api/v1/admin/contact-messages/{id}/read [patch]
func (cc *ContactController) MarkMessageAsRead(c *gin.Context) {
	// Check if user is admin
	if c.GetString("userRole") != "admin" {
		c.JSON(http.StatusForbidden, gin.H{"error": "Access denied"})
		return
	}

	var message models.ContactMessage
	if err := cc.DB.First(&message, c.Param("id")).Error; err != nil {
		c.JSON(http.StatusNotFound, gin.H{"error": "Message not found"})
		return
	}

	message.IsRead = true
	message.ReadAt = time.Now()

	if err := cc.DB.Save(&message).Error; err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to update message"})
		return
	}

	c.JSON(http.StatusOK, gin.H{"message": "Message marked as read"})
}

// GetNewsletterSubscribers returns a list of newsletter subscribers (admin only)
// @Summary Get newsletter subscribers
// @Description Returns a list of all newsletter subscribers (admin only)
// @Tags admin
// @Security Bearer
// @Produce json
// @Success 200 {object} []models.NewsletterSubscription
// @Failure 401 {object} map[string]string
// @Failure 403 {object} map[string]string
// @Router /api/v1/admin/newsletter/subscribers [get]
func (cc *ContactController) GetNewsletterSubscribers(c *gin.Context) {
	if c.GetString("userRole") != "admin" {
		c.JSON(http.StatusForbidden, gin.H{"error": "Access denied"})
		return
	}

	var subscribers []models.NewsletterSubscription
	if err := cc.DB.Find(&subscribers).Error; err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to fetch subscribers"})
		return
	}

	c.JSON(http.StatusOK, subscribers)
}

// SendNewsletter sends a newsletter to all active subscribers (admin only)
// @Summary Send newsletter
// @Description Sends a newsletter to all active subscribers (admin only)
// @Tags admin
// @Security Bearer
// @Accept json
// @Produce json
// @Param input body map[string]string true "Newsletter content (subject and body)"
// @Success 200 {object} map[string]string
// @Failure 400 {object} map[string]string
// @Failure 401 {object} map[string]string
// @Failure 403 {object} map[string]string
// @Router /api/v1/admin/newsletter/send [post]
func (cc *ContactController) SendNewsletter(c *gin.Context) {
	if c.GetString("userRole") != "admin" {
		c.JSON(http.StatusForbidden, gin.H{"error": "Access denied"})
		return
	}

	var input struct {
		Subject string `json:"subject" binding:"required"`
		Body    string `json:"body"`
		Content string `json:"content"`
	}

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

	// Support both 'body' (backend) and 'content' (frontend variant)
	bodyText := strings.TrimSpace(input.Body)
	if bodyText == "" {
		bodyText = strings.TrimSpace(input.Content)
	}
	if bodyText == "" {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Newsletter body/content is required"})
		return
	}

	// Fetch active subscribers
	var subscribers []models.NewsletterSubscription
	if err := cc.DB.Where("is_active = ?", true).Find(&subscribers).Error; err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to load subscribers"})
		return
	}

	if len(subscribers) == 0 {
		c.JSON(http.StatusBadRequest, gin.H{"error": "No active subscribers"})
		return
	}

	// Build recipient list
	recipients := make([]string, 0, len(subscribers))
	for _, s := range subscribers {
		if s.Email != "" {
			recipients = append(recipients, s.Email)
		}
	}

	if len(recipients) == 0 {
		c.JSON(http.StatusBadRequest, gin.H{"error": "No valid recipient emails"})
		return
	}

	logger.Info("[SendNewsletter] sending to %d active subscribers", len(recipients))

	// Send via email service
	data := &email.NewsletterData{
		Subject:    input.Subject,
		Content:    bodyText,
		Recipients: recipients,
	}

	if err := cc.emailService.SendNewsletter(data); err != nil {
		logger.Error("Failed to send newsletter: %v", err)
		if config.AppConfig != nil && config.AppConfig.AppEnv != "production" {
			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to send newsletter", "details": err.Error()})
		} else {
			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to send newsletter"})
		}
		return
	}

	c.JSON(http.StatusOK, gin.H{"message": "Newsletter sent successfully", "recipients": len(recipients)})
}

// UnsubscribeFromNewsletter handles newsletter unsubscription
// @Summary Unsubscribe from newsletter
// @Description Handles newsletter unsubscription requests
// @Tags newsletter
// @Produce json
// @Param email path string true "Subscriber email"
// @Success 200 {object} map[string]string
// @Failure 400 {object} map[string]string
// @Router /api/v1/newsletter/unsubscribe/{email} [post]
func (cc *ContactController) UnsubscribeFromNewsletter(c *gin.Context) {
	email := c.Param("email")
	if email == "" {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Email is required"})
		return
	}

	// Set subscription as inactive instead of deleting
	result := cc.DB.Model(&models.NewsletterSubscription{}).Where("email = ?", email).Update("is_active", false)
	if result.Error != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to unsubscribe"})
		return
	}

	if result.RowsAffected == 0 {
		c.JSON(http.StatusNotFound, gin.H{"error": "Subscription not found"})
		return
	}

	c.JSON(http.StatusOK, gin.H{"message": "Successfully unsubscribed from newsletter"})
}

// GetContactMessage returns a single contact message by ID (admin only)
// @Summary Get contact message
// @Description Returns a single contact message by ID (admin only)
// @Tags admin
// @Security Bearer
// @Produce json
// @Param id path int true "Message ID"
// @Success 200 {object} models.ContactMessage
// @Failure 400 {object} map[string]string
// @Failure 401 {object} map[string]string
// @Failure 403 {object} map[string]string
// @Failure 404 {object} map[string]string
// @Router /api/v1/admin/contact-messages/{id} [get]
func (cc *ContactController) GetContactMessage(c *gin.Context) {
	id, err := strconv.Atoi(c.Param("id"))
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid message ID"})
		return
	}

	var message models.ContactMessage
	if err := cc.DB.First(&message, id).Error; err != nil {
		if err == gorm.ErrRecordNotFound {
			c.JSON(http.StatusNotFound, gin.H{"error": "Message not found"})
		} else {
			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to fetch message"})
		}
		return
	}

	c.JSON(http.StatusOK, message)
}

// DeleteContactMessage deletes a contact message (admin only)
// @Summary Delete contact message
// @Description Deletes a contact message by ID (admin only)
// @Tags admin
// @Security Bearer
// @Produce json
// @Param id path int true "Message ID"
// @Success 200 {object} map[string]string
// @Failure 400 {object} map[string]string
// @Failure 401 {object} map[string]string
// @Failure 403 {object} map[string]string
// @Router /api/v1/admin/contact-messages/{id} [delete]
func (cc *ContactController) DeleteContactMessage(c *gin.Context) {
	id, err := strconv.Atoi(c.Param("id"))
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid message ID"})
		return
	}

	result := cc.DB.Delete(&models.ContactMessage{}, id)
	if result.Error != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to delete message"})
		return
	}

	if result.RowsAffected == 0 {
		c.JSON(http.StatusNotFound, gin.H{"error": "Message not found"})
		return
	}

	c.JSON(http.StatusOK, gin.H{"message": "Message deleted successfully"})
}

// DeleteContactMessages deletes multiple contact messages (admin only)
// @Summary Delete multiple contact messages
// @Description Deletes multiple contact messages by their IDs (admin only)
// @Tags admin
// @Security Bearer
// @Accept json
// @Produce json
// @Param ids body []int true "Array of message IDs to delete"
// @Success 200 {object} map[string]string
// @Failure 400 {object} map[string]string
// @Failure 401 {object} map[string]string
// @Failure 403 {object} map[string]string
// @Router /api/v1/admin/contact-messages [delete]
func (cc *ContactController) DeleteContactMessages(c *gin.Context) {
	var ids []int
	if err := c.ShouldBindJSON(&ids); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request body"})
		return
	}

	if len(ids) == 0 {
		c.JSON(http.StatusBadRequest, gin.H{"error": "No message IDs provided"})
		return
	}

	result := cc.DB.Delete(&models.ContactMessage{}, ids)
	if result.Error != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to delete messages"})
		return
	}

	if result.RowsAffected == 0 {
		c.JSON(http.StatusNotFound, gin.H{"error": "No messages found with the provided IDs"})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"message": fmt.Sprintf("Successfully deleted %d message(s)", result.RowsAffected),
	})
}

// ForwardContactMessage forwards a contact message to a specified email (admin only)
// @Summary Forward contact message
// @Description Forwards a contact message to a specified email address (admin only)
// @Tags admin
// @Security Bearer
// @Accept json
// @Produce json
// @Param id path int true "Message ID"
// @Param input body map[string]string true "{ to_email: string }"
// @Success 200 {object} map[string]string
// @Failure 400 {object} map[string]string
// @Failure 401 {object} map[string]string
// @Failure 403 {object} map[string]string
// @Failure 404 {object} map[string]string
// @Router /api/v1/admin/contact-messages/{id}/forward [post]
func (cc *ContactController) ForwardContactMessage(c *gin.Context) {
	if c.GetString("userRole") != "admin" {
		c.JSON(http.StatusForbidden, gin.H{"error": "Access denied"})
		return
	}

	id, err := strconv.Atoi(c.Param("id"))
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid message ID"})
		return
	}

	var input struct {
		ToEmail string `json:"to_email" binding:"required,email"`
	}
	if err := c.ShouldBindJSON(&input); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Valid email address is required"})
		return
	}

	// Fetch the message
	var message models.ContactMessage
	if err := cc.DB.First(&message, id).Error; err != nil {
		if err == gorm.ErrRecordNotFound {
			c.JSON(http.StatusNotFound, gin.H{"error": "Message not found"})
		} else {
			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to fetch message"})
		}
		return
	}

	// Prepare email data for forwarding
	forwardData := &email.EmailData{
		Subject: fmt.Sprintf("Fwd: Contact Form - %s", message.Subject),
		To:      []string{input.ToEmail},
		Template: "contact_form",
		Data: struct {
			Name    string
			Email   string
			Subject string
			Message string
			Time    string
			IP      string
			Agent   string
		}{
			Name:    message.Name,
			Email:   message.Email,
			Subject: message.Subject,
			Message: message.Message,
			Time:    message.CreatedAt.Format(time.RFC1123Z),
			IP:      message.IPAddress,
			Agent:   message.UserAgent,
		},
	}

	// Send email asynchronously
	go func() {
		if err := cc.emailService.SendEmail(forwardData); err != nil {
			logger.Error("Failed to forward contact message %d to %s: %v", id, input.ToEmail, err)
		} else {
			logger.Info("Contact message %d forwarded to %s", id, input.ToEmail)
		}
	}()

	c.JSON(http.StatusOK, gin.H{"message": "Message is being forwarded to " + input.ToEmail})
}

// ForwardAllContactMessages forwards all contact messages to a specified email (admin only)
// @Summary Forward all contact messages
// @Description Forwards all contact messages to a specified email address (admin only)
// @Tags admin
// @Security Bearer
// @Accept json
// @Produce json
// @Param input body map[string]string true "{ to_email: string }"
// @Success 200 {object} map[string]string
// @Failure 400 {object} map[string]string
// @Failure 401 {object} map[string]string
// @Failure 403 {object} map[string]string
// @Router /api/v1/admin/contact-messages/forward-all [post]
func (cc *ContactController) ForwardAllContactMessages(c *gin.Context) {
	if c.GetString("userRole") != "admin" {
		c.JSON(http.StatusForbidden, gin.H{"error": "Access denied"})
		return
	}

	var input struct {
		ToEmail string `json:"to_email" binding:"required,email"`
	}
	if err := c.ShouldBindJSON(&input); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Valid email address is required"})
		return
	}

	// Fetch all messages
	var messages []models.ContactMessage
	if err := cc.DB.Order("created_at DESC").Find(&messages).Error; err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to fetch messages"})
		return
	}

	if len(messages) == 0 {
		c.JSON(http.StatusBadRequest, gin.H{"error": "No messages to forward"})
		return
	}

	// Forward all messages asynchronously
	go func(msgs []models.ContactMessage, toEmail string) {
		successCount := 0
		for _, message := range msgs {
			forwardData := &email.EmailData{
				Subject: fmt.Sprintf("Fwd: Contact Form - %s", message.Subject),
				To:      []string{toEmail},
				Template: "contact_form",
				Data: struct {
					Name    string
					Email   string
					Subject string
					Message string
					Time    string
					IP      string
					Agent   string
				}{
					Name:    message.Name,
					Email:   message.Email,
					Subject: message.Subject,
					Message: message.Message,
					Time:    message.CreatedAt.Format(time.RFC1123Z),
					IP:      message.IPAddress,
					Agent:   message.UserAgent,
				},
			}

			if err := cc.emailService.SendEmail(forwardData); err != nil {
				logger.Error("Failed to forward contact message %d to %s: %v", message.ID, toEmail, err)
			} else {
				successCount++
			}
		}
		logger.Info("Forwarded %d of %d contact messages to %s", successCount, len(msgs), toEmail)
	}(messages, input.ToEmail)

	c.JSON(http.StatusOK, gin.H{
		"message": fmt.Sprintf("Forwarding %d message(s) to %s", len(messages), input.ToEmail),
		"count":   len(messages),
	})
}