package controllers

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

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

	"fotbal-club/internal/models"
	"fotbal-club/internal/services"
	"fotbal-club/pkg/email"
)

type SweepstakesController struct {
	DB    *gorm.DB
	Email email.EmailService
}

// Public: visualization data for a specific sweepstake (within visibility window)
// GET /api/v1/sweepstakes/:id/visual
func (sc *SweepstakesController) PublicVisualData(c *gin.Context) {
    id := strings.TrimSpace(c.Param("id"))
    var s models.Sweepstake
    if err := sc.DB.First(&s, id).Error; err != nil { c.JSON(http.StatusNotFound, gin.H{"error":"Not found"}); return }
    now := time.Now()
    if s.VisibilityUntil == nil || now.After(*s.VisibilityUntil) || now.Before(s.EndAt) {
        c.JSON(http.StatusNotFound, gin.H{"error":"Not available"}); return
    }
    var winners []struct{ UserID uint `json:"user_id"`; PrizeName string `json:"prize_name"` }
    _ = sc.DB.Table("sweepstake_winners").Select("user_id, prize_name").Where("sweepstake_id = ?", id).Order("id ASC").Scan(&winners).Error
    type entryRow struct {
        UserID      uint   `json:"user_id"`
        DisplayName string `json:"display_name"`
        AvatarURL   string `json:"avatar_url"`
    }
    var entries []entryRow
    q := sc.DB.Table("sweepstake_entries AS e").
        Select("e.user_id, TRIM(CONCAT(COALESCE(u.first_name,''),' ',COALESCE(u.last_name,''))) AS display_name, COALESCE(up.animated_avatar_url, up.avatar_url, '') AS avatar_url").
        Joins("JOIN users u ON u.id = e.user_id").
        Joins("LEFT JOIN user_profiles up ON up.user_id = u.id").
        Where("e.sweepstake_id = ?", id)
    _ = q.Scan(&entries).Error
    c.JSON(http.StatusOK, gin.H{ "sweepstake": s, "entries": entries, "winners": winners })
}

// Admin: set or change prize for a specific winner
// PATCH /api/v1/admin/sweepstakes/:id/winners/:winner_id/prize  { "prize_id": 123 }
func (sc *SweepstakesController) AdminSetWinnerPrize(c *gin.Context) {
    wid := strings.TrimSpace(c.Param("winner_id"))
    var body struct{ PrizeID uint `json:"prize_id"` }
    if err := c.ShouldBindJSON(&body); err != nil || body.PrizeID == 0 { c.JSON(http.StatusBadRequest, gin.H{"error":"Invalid prize"}); return }
    // Load prize name
    var p models.SweepstakePrize
    if err := sc.DB.First(&p, body.PrizeID).Error; err != nil { c.JSON(http.StatusNotFound, gin.H{"error":"Prize not found"}); return }
    updates := map[string]interface{}{ "prize_id": p.ID, "prize_name": strings.TrimSpace(p.Name) }
    if err := sc.DB.Model(&models.SweepstakeWinner{}).Where("id = ?", wid).Updates(updates).Error; err != nil { c.JSON(http.StatusInternalServerError, gin.H{"error":"Failed"}); return }
    c.JSON(http.StatusOK, gin.H{"ok": true})
}

// Admin: update winner status (claim/delivered/pending)
// PATCH /api/v1/admin/sweepstakes/:id/winners/:winner_id { "claim_status": "claimed|delivered|pending", "claim_note":"..." }
func (sc *SweepstakesController) AdminUpdateWinner(c *gin.Context) {
    wid := strings.TrimSpace(c.Param("winner_id"))
    var body struct{
        ClaimStatus string `json:"claim_status"`
        ClaimNote   string `json:"claim_note"`
    }
    if err := c.ShouldBindJSON(&body); err != nil { c.JSON(http.StatusBadRequest, gin.H{"error":"Invalid payload"}); return }
    st := strings.ToLower(strings.TrimSpace(body.ClaimStatus))
    if st == "" { st = "pending" }
    switch st {
    case "pending","claimed","delivered":
    default:
        c.JSON(http.StatusBadRequest, gin.H{"error":"Invalid status"}); return
    }
    // Load winner to evaluate prize awarding
    var w models.SweepstakeWinner
    if err := sc.DB.First(&w, wid).Error; err != nil { c.JSON(http.StatusNotFound, gin.H{"error":"Not found"}); return }
    // Update fields
    updates := map[string]interface{}{ "claim_status": st }
    if strings.TrimSpace(body.ClaimNote) != "" { updates["claim_note"] = strings.TrimSpace(body.ClaimNote) }
    // Award non-physical prizes only once when moving to claimed/delivered
    shouldAward := (st == "claimed" || st == "delivered") && (w.AwardedAt == nil)
    if shouldAward && w.PrizeID != nil {
        var p models.SweepstakePrize
        if err := sc.DB.First(&p, *w.PrizeID).Error; err == nil {
            if p.Kind == "points" || p.Kind == "xp" || p.Kind == "points_xp" {
                svc := services.NewEngagementService(sc.DB)
                var pointsDelta, xpDelta int64
                switch p.Kind {
                case "points": pointsDelta, xpDelta = p.Points, 0
                case "xp": pointsDelta, xpDelta = 0, p.XP
                case "points_xp": pointsDelta, xpDelta = p.Points, p.XP
                }
                if pointsDelta != 0 || xpDelta != 0 {
                    _, _ = svc.AwardPointsAndXP(w.UserID, pointsDelta, xpDelta, "sweepstake_prize", map[string]interface{}{"prize_id": p.ID, "sweepstake_id": w.SweepstakeID})
                }
                now := time.Now()
                updates["awarded_at"] = &now
            }
        }
    }
    if err := sc.DB.Model(&models.SweepstakeWinner{}).Where("id = ?", wid).Updates(updates).Error; err != nil { c.JSON(http.StatusInternalServerError, gin.H{"error":"Failed"}); return }
    c.JSON(http.StatusOK, gin.H{"ok": true})
}

// Admin: list prizes
// GET /api/v1/admin/sweepstakes/:id/prizes
func (sc *SweepstakesController) AdminListPrizes(c *gin.Context) {
    id := c.Param("id")
    var items []models.SweepstakePrize
    if err := sc.DB.Where("sweepstake_id = ?", id).Order("display_order ASC, id ASC").Find(&items).Error; err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error":"Failed"}); return
    }
    c.JSON(http.StatusOK, gin.H{"items": items})
}

// Admin: create prize
// POST /api/v1/admin/sweepstakes/:id/prizes
func (sc *SweepstakesController) AdminCreatePrize(c *gin.Context) {
    sid := strings.TrimSpace(c.Param("id"))
    var s models.Sweepstake
    if err := sc.DB.First(&s, sid).Error; err != nil { c.JSON(http.StatusNotFound, gin.H{"error":"Sweepstake not found"}); return }
    var body struct{
        Name string `json:"name"`
        Description string `json:"description"`
        ImageURL string `json:"image_url"`
        Value string `json:"value"`
        Quantity int `json:"quantity"`
        DisplayOrder int `json:"display_order"`
        Kind string `json:"kind"`
        Points int64 `json:"points"`
        XP int64 `json:"xp"`
    }
    if err := c.ShouldBindJSON(&body); err != nil || strings.TrimSpace(body.Name) == "" {
        c.JSON(http.StatusBadRequest, gin.H{"error":"Invalid payload"}); return
    }
    // Normalize prize kind/values
    kind := strings.ToLower(strings.TrimSpace(body.Kind))
    switch kind {
    case "", "physical", "points", "xp", "points_xp":
        if kind == "" { kind = "physical" }
    default:
        c.JSON(http.StatusBadRequest, gin.H{"error":"Invalid prize kind"}); return
    }
    if body.Points < 0 { body.Points = 0 }
    if body.XP < 0 { body.XP = 0 }
    p := models.SweepstakePrize{ SweepstakeID: s.ID, Name: strings.TrimSpace(body.Name), Description: strings.TrimSpace(body.Description), ImageURL: strings.TrimSpace(body.ImageURL), Value: strings.TrimSpace(body.Value), Quantity: body.Quantity, DisplayOrder: body.DisplayOrder, Kind: kind, Points: body.Points, XP: body.XP }
    if err := sc.DB.Create(&p).Error; err != nil { c.JSON(http.StatusInternalServerError, gin.H{"error":"Failed"}); return }
    c.JSON(http.StatusOK, p)
}

// Admin: update prize
// PUT /api/v1/admin/sweepstakes/:id/prizes/:prize_id
func (sc *SweepstakesController) AdminUpdatePrize(c *gin.Context) {
    pid := strings.TrimSpace(c.Param("prize_id"))
    var body map[string]interface{}
    if err := c.ShouldBindJSON(&body); err != nil { c.JSON(http.StatusBadRequest, gin.H{"error":"Invalid payload"}); return }
    allowed := map[string]bool{"name":true,"description":true,"image_url":true,"value":true,"quantity":true,"display_order":true,"kind":true,"points":true,"xp":true}
    upd := map[string]interface{}{}
    for k,v := range body { if allowed[k] { upd[k] = v } }
    // Validate kind if present
    if v, ok := upd["kind"]; ok {
        sv := strings.ToLower(strings.TrimSpace(toString(v)))
        switch sv {
        case "physical","points","xp","points_xp":
            upd["kind"] = sv
        default:
            c.JSON(http.StatusBadRequest, gin.H{"error":"Invalid prize kind"}); return
        }
    }
    // Coerce points/xp to non-negative integers if present
    if v, ok := upd["points"]; ok { upd["points"] = toNonNegInt64(v) }
    if v, ok := upd["xp"]; ok { upd["xp"] = toNonNegInt64(v) }
    if len(upd) == 0 { c.JSON(http.StatusBadRequest, gin.H{"error":"No changes"}); return }
    if err := sc.DB.Model(&models.SweepstakePrize{}).Where("id = ?", pid).Updates(upd).Error; err != nil { c.JSON(http.StatusInternalServerError, gin.H{"error":"Failed"}); return }
    c.JSON(http.StatusOK, gin.H{"ok": true})
}

// Admin: delete prize
// DELETE /api/v1/admin/sweepstakes/:id/prizes/:prize_id
func (sc *SweepstakesController) AdminDeletePrize(c *gin.Context) {
    pid := strings.TrimSpace(c.Param("prize_id"))
    if err := sc.DB.Delete(&models.SweepstakePrize{}, "id = ?", pid).Error; err != nil { c.JSON(http.StatusInternalServerError, gin.H{"error":"Failed"}); return }
    c.JSON(http.StatusOK, gin.H{"ok": true})
}

// Admin: reorder prizes
// POST /api/v1/admin/sweepstakes/:id/prizes/reorder  { "order": [prize_id...] }
func (sc *SweepstakesController) AdminReorderPrizes(c *gin.Context) {
    sid := strings.TrimSpace(c.Param("id"))
    var body struct{ Order []uint `json:"order"` }
    if err := c.ShouldBindJSON(&body); err != nil || len(body.Order) == 0 { c.JSON(http.StatusBadRequest, gin.H{"error":"Invalid order"}); return }
    tx := sc.DB.Begin()
    for i, id := range body.Order {
        if err := tx.Model(&models.SweepstakePrize{}).Where("id = ? AND sweepstake_id = ?", id, sid).Update("display_order", i).Error; err != nil { tx.Rollback(); c.JSON(http.StatusInternalServerError, gin.H{"error":"Failed"}); return }
    }
    if err := tx.Commit().Error; err != nil { c.JSON(http.StatusInternalServerError, gin.H{"error":"Failed"}); return }
    c.JSON(http.StatusOK, gin.H{"ok": true})
}

// Admin: visualization data for sweepstake (participants and winners)
// GET /api/v1/admin/sweepstakes/:id/visual
func (sc *SweepstakesController) AdminVisualData(c *gin.Context) {
    id := strings.TrimSpace(c.Param("id"))
    var s models.Sweepstake
    if err := sc.DB.First(&s, id).Error; err != nil {
        c.JSON(http.StatusNotFound, gin.H{"error":"Not found"}); return
    }
    // Winners in stable order
    var winners []struct{ ID uint `json:"id"`; UserID uint `json:"user_id"`; PrizeName string `json:"prize_name"`; ClaimStatus string `json:"claim_status"` }
    _ = sc.DB.Table("sweepstake_winners").Select("id, user_id, prize_name, claim_status").Where("sweepstake_id = ?", id).Order("id ASC").Scan(&winners).Error
    // Entries with display names and avatars
    type entryRow struct {
        UserID      uint   `json:"user_id"`
        DisplayName string `json:"display_name"`
        AvatarURL   string `json:"avatar_url"`
    }
    var entries []entryRow
    q := sc.DB.Table("sweepstake_entries AS e").
        Select("e.user_id, TRIM(CONCAT(COALESCE(u.first_name,''),' ',COALESCE(u.last_name,''))) AS display_name, COALESCE(up.animated_avatar_url, up.avatar_url, '') AS avatar_url").
        Joins("JOIN users u ON u.id = e.user_id").
        Joins("LEFT JOIN user_profiles up ON up.user_id = u.id").
        Where("e.sweepstake_id = ?", id)
    _ = q.Scan(&entries).Error
    c.JSON(http.StatusOK, gin.H{
        "sweepstake": s,
        "entries": entries,
        "winners": winners,
    })
}

func NewSweepstakesController(db *gorm.DB, es email.EmailService) *SweepstakesController {
	return &SweepstakesController{DB: db, Email: es}
}

// Public: get current visible sweepstake (upcoming/active/finalized within visibility window)
func (sc *SweepstakesController) GetCurrent(c *gin.Context) {
	now := time.Now()
	var s models.Sweepstake
	q := sc.DB.Where("start_at <= ? AND (visibility_until IS NULL OR visibility_until >= ?)", now, now).
		Order("start_at DESC")
	if err := q.First(&s).Error; err != nil {
		if err == gorm.ErrRecordNotFound {
			c.JSON(http.StatusOK, gin.H{"sweepstake": nil})
			return
		}
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to load sweepstake"})
		return
	}
	// Compute state
	state := "upcoming"
	if now.After(s.StartAt) && now.Before(s.EndAt) {
		state = "active"
	} else if now.After(s.EndAt) {
		state = "finalized"
	}
	// Load prizes (public info)
	var prizes []models.SweepstakePrize
	_ = sc.DB.Where("sweepstake_id = ?", s.ID).Order("display_order ASC, id ASC").Find(&prizes).Error
	// Winners if selected
	var winners []models.SweepstakeWinner
	if s.WinnersSelectedAt != nil {
		_ = sc.DB.Where("sweepstake_id = ?", s.ID).Find(&winners).Error
	}
	// Current user status
	hasEntered := false
	visualPlayedAt := (*time.Time)(nil)
	if uid, ok := c.Get("userID"); ok && uid != nil {
		var e models.SweepstakeEntry
		if err := sc.DB.Where("sweepstake_id = ? AND user_id = ?", s.ID, uid.(uint)).First(&e).Error; err == nil {
			hasEntered = true
			visualPlayedAt = e.VisualPlayedAt
		}
	}
	c.JSON(http.StatusOK, gin.H{
		"sweepstake": s,
		"prizes":     prizes,
		"winners":    winners,
		"state":      state,
		"has_entered": hasEntered,
		"visual_played_at": visualPlayedAt,
	})
}

// Protected: enter/join sweepstake (idempotent)
func (sc *SweepstakesController) Enter(c *gin.Context) {
	id := strings.TrimSpace(c.Param("id"))
	uid, _ := c.Get("userID")
	userID := uid.(uint)
	// Load sweepstake
	var s models.Sweepstake
	if err := sc.DB.First(&s, id).Error; err != nil {
		if err == gorm.ErrRecordNotFound { c.JSON(http.StatusNotFound, gin.H{"error":"Not found"}); return }
		c.JSON(http.StatusInternalServerError, gin.H{"error":"Failed to load"}); return
	}
	now := time.Now()
	if !(now.After(s.StartAt) && now.Before(s.EndAt)) {
		c.JSON(http.StatusBadRequest, gin.H{"error":"Soutěž není aktivní"}); return
	}
	// Idempotent create
	entry := models.SweepstakeEntry{ SweepstakeID: s.ID, UserID: userID, Status: "valid" }
	if err := sc.DB.Where("sweepstake_id = ? AND user_id = ?", s.ID, userID).FirstOrCreate(&entry).Error; err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error":"Failed to join"}); return
	}
	c.JSON(http.StatusOK, gin.H{"ok": true})
}

// Protected: mark visualization as played (only once)
func (sc *SweepstakesController) MarkVisualPlayed(c *gin.Context) {
	id := strings.TrimSpace(c.Param("id"))
	uid, _ := c.Get("userID")
	userID := uid.(uint)
	var s models.Sweepstake
	if err := sc.DB.First(&s, id).Error; err != nil { c.JSON(http.StatusNotFound, gin.H{"error":"Not found"}); return }
	now := time.Now()
	if !(now.After(s.EndAt) && (s.VisibilityUntil == nil || now.Before(*s.VisibilityUntil))) {
		c.JSON(http.StatusBadRequest, gin.H{"error":"Vizualizace není dostupná"}); return
	}
	_ = sc.DB.Model(&models.SweepstakeEntry{}).
		Where("sweepstake_id = ? AND user_id = ? AND visual_played_at IS NULL", s.ID, userID).
		Updates(map[string]interface{}{"visual_played_at": time.Now(), "view_count": gorm.Expr("view_count + 1")}).Error
	c.JSON(http.StatusOK, gin.H{"ok": true})
}

// Protected: my wins list
func (sc *SweepstakesController) MyWinnings(c *gin.Context) {
	uid, _ := c.Get("userID")
	userID := uid.(uint)
	var wins []models.SweepstakeWinner
	if err := sc.DB.Where("user_id = ?", userID).Order("created_at DESC").Find(&wins).Error; err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error":"Failed to load"}); return
	}
	c.JSON(http.StatusOK, gin.H{"items": wins})
}

// Admin: list sweepstakes
func (sc *SweepstakesController) AdminList(c *gin.Context) {
	var items []models.Sweepstake
	q := sc.DB.Model(&models.Sweepstake{})
	if v := strings.TrimSpace(c.Query("status")); v != "" { q = q.Where("status = ?", v) }
	if err := q.Order("created_at DESC").Find(&items).Error; err != nil { c.JSON(http.StatusInternalServerError, gin.H{"error":"Failed"}); return }
	c.JSON(http.StatusOK, gin.H{"items": items})
}

// Admin: create sweepstake
func (sc *SweepstakesController) AdminCreate(c *gin.Context) {
	var body struct{
		Title string `json:"title"`
		Description string `json:"description"`
		ImageURL string `json:"image_url"`
		RulesURL string `json:"rules_url"`
		StartAt time.Time `json:"start_at"`
		EndAt time.Time `json:"end_at"`
		PickerStyle string `json:"picker_style"`
		TotalPrizes int `json:"total_prizes"`
		PrizeSummary string `json:"prize_summary"`
	}
	if err := c.ShouldBindJSON(&body); err != nil || strings.TrimSpace(body.Title) == "" {
		c.JSON(http.StatusBadRequest, gin.H{"error":"Invalid payload"}); return
	}
	item := models.Sweepstake{
		Title: strings.TrimSpace(body.Title),
		Description: strings.TrimSpace(body.Description),
		ImageURL: strings.TrimSpace(body.ImageURL),
		RulesURL: strings.TrimSpace(body.RulesURL),
		StartAt: body.StartAt, EndAt: body.EndAt,
		PickerStyle: ifEmpty(body.PickerStyle, "wheel"),
		TotalPrizes: ifZero(body.TotalPrizes, 1),
		PrizeSummary: strings.TrimSpace(body.PrizeSummary),
		Status: "scheduled",
	}
	if time.Now().After(item.StartAt) { item.Status = "active" }
	if err := sc.DB.Create(&item).Error; err != nil { c.JSON(http.StatusInternalServerError, gin.H{"error":"Failed to create"}); return }
	c.JSON(http.StatusOK, item)
}

// Admin: update sweepstake
func (sc *SweepstakesController) AdminUpdate(c *gin.Context) {
	id := c.Param("id")
	var body map[string]interface{}
	if err := c.ShouldBindJSON(&body); err != nil { c.JSON(http.StatusBadRequest, gin.H{"error":"Invalid payload"}); return }
	allowed := map[string]bool{"title":true,"description":true,"image_url":true,"rules_url":true,"start_at":true,"end_at":true,"picker_style":true,"total_prizes":true,"prize_summary":true,"status":true}
	upd := map[string]interface{}{}
	for k,v := range body { if allowed[k] { upd[k] = v } }
	if len(upd)==0 { c.JSON(http.StatusBadRequest, gin.H{"error":"No changes"}); return }
	if err := sc.DB.Model(&models.Sweepstake{}).Where("id = ?", id).Updates(upd).Error; err != nil { c.JSON(http.StatusInternalServerError, gin.H{"error":"Failed"}); return }
	c.JSON(http.StatusOK, gin.H{"ok": true})
}

// Admin: delete sweepstake
func (sc *SweepstakesController) AdminDelete(c *gin.Context) {
	id := c.Param("id")
	if err := sc.DB.Delete(&models.Sweepstake{}, "id = ?", id).Error; err != nil { c.JSON(http.StatusInternalServerError, gin.H{"error":"Failed"}); return }
	c.JSON(http.StatusOK, gin.H{"ok": true})
}

// Admin: list entries
func (sc *SweepstakesController) AdminEntries(c *gin.Context) {
	id := c.Param("id")
	var items []models.SweepstakeEntry
	if err := sc.DB.Where("sweepstake_id = ?", id).Order("created_at DESC").Find(&items).Error; err != nil { c.JSON(http.StatusInternalServerError, gin.H{"error":"Failed"}); return }
	c.JSON(http.StatusOK, gin.H{"items": items})
}

// Admin: list winners
func (sc *SweepstakesController) AdminWinners(c *gin.Context) {
	id := c.Param("id")
	var items []models.SweepstakeWinner
	if err := sc.DB.Where("sweepstake_id = ?", id).Order("created_at ASC").Find(&items).Error; err != nil { c.JSON(http.StatusInternalServerError, gin.H{"error":"Failed"}); return }
	c.JSON(http.StatusOK, gin.H{"items": items})
}

// Admin: finalize (pick winners now)
func (sc *SweepstakesController) AdminFinalize(c *gin.Context) {
	id := c.Param("id")
	var s models.Sweepstake
	if err := sc.DB.First(&s, id).Error; err != nil { c.JSON(http.StatusNotFound, gin.H{"error":"Not found"}); return }
	var body struct{ Seed string `json:"seed"` }
	_ = c.ShouldBindJSON(&body)
	svc := services.NewSweepstakesService(sc.DB, sc.Email)
	if err := svc.FinalizeSweepstake(&s, strings.TrimSpace(body.Seed)); err != nil { c.JSON(http.StatusInternalServerError, gin.H{"error":"Failed to finalize"}); return }
	c.JSON(http.StatusOK, gin.H{"ok": true})
}

// Helpers
func ifEmpty(v string, d string) string { if strings.TrimSpace(v)=="" { return d }; return strings.TrimSpace(v) }
func ifZero(v int, d int) int { if v==0 { return d }; return v }

// Helpers for update coercion
func toString(v interface{}) string {
    switch t := v.(type) {
    case string:
        return t
    case []byte:
        return string(t)
    default:
        return strings.TrimSpace(strings.ReplaceAll(strings.TrimSpace(fmt.Sprintf("%v", v)), "\n", " "))
    }
}
func toNonNegInt64(v interface{}) int64 {
    switch n := v.(type) {
    case int64:
        if n < 0 { return 0 }; return n
    case int:
        if n < 0 { return 0 }; return int64(n)
    case float64:
        if n < 0 { return 0 }; return int64(n)
    case float32:
        if n < 0 { return 0 }; return int64(n)
    case string:
        if strings.TrimSpace(n) == "" { return 0 }
        if f, err := strconv.ParseFloat(n, 64); err == nil {
            if f < 0 { return 0 }
            return int64(f)
        }
        return 0
    default:
        return 0
    }
}