package handlers

import (
	"gestion/db"
	"gestion/models"
	"gestion/utils"
	"log"
	"net/http"
	"strings"

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

// eligibleRewardProductIDs détermine, pour un pool donné, quels product_id de
// reward.RewardItems sont éligibles : sa catégorie (via CategoryConfigs) doit
// faire partie des catégories du pool, soit par whitelist explicite (ProductIDs)
// soit par correspondance de catégorie produit (AllProducts).
func eligibleRewardProductIDs(reward *models.PointsReward, poolCategories map[string]bool, productCategories map[int]string) map[int]bool {
	eligible := make(map[int]bool)
	if reward == nil {
		return eligible
	}
	for _, cfg := range reward.CategoryConfigs {
		if !poolCategories[cfg.Category] {
			continue
		}
		if cfg.AllProducts {
			for pid, cat := range productCategories {
				if cat == cfg.Category {
					eligible[pid] = true
				}
			}
		} else {
			for _, pid := range cfg.ProductIDs {
				eligible[pid] = true
			}
		}
	}
	return eligible
}

// GetMyPointsRewards retourne les points et les récompenses disponibles du client connecté.
// La récompense est globale : son seuil s'applique indépendamment à chaque pool.
func GetMyPointsRewards(c *gin.Context) {
	username := c.GetString("username")
	if username == "" {
		c.JSON(http.StatusUnauthorized, gin.H{"error": "Non authentifié"})
		return
	}

	database := c.MustGet("database").(*db.Database)

	settings, err := database.GetSettings()
	if err != nil {
		utils.ServerErr(c, "Erreur lecture paramètres", err)
		return
	}

	if !settings.PointsEnabled || len(settings.PointsPools) == 0 {
		c.JSON(http.StatusOK, gin.H{"enabled": false, "pools": []gin.H{}, "reward": nil})
		return
	}

	pointsExtra, pointsRedeemed, err := database.GetClientPointsAndRewards(username)
	if err != nil {
		utils.ServerErr(c, "Erreur lecture points", err)
		return
	}

	reward := settings.PointsReward

	type EligibleConfigResponse struct {
		Category     string   `json:"category"`
		AllProducts  bool     `json:"all_products"`
		ProductIDs   []int    `json:"product_ids"`
		ProductNames []string `json:"product_names"`
	}

	type RewardItemResponse struct {
		ProductID   int     `json:"product_id"`
		ProductName string  `json:"product_name"`
		Quantity    float64 `json:"quantity"`
		Price       float64 `json:"price"`
	}

	type PoolInfo struct {
		Key                 string                   `json:"key"`
		Name                string                   `json:"name"`
		Points              int                      `json:"points"`
		RewardsEarned       int                      `json:"rewards_earned"`
		RewardsClaimed      int                      `json:"rewards_claimed"`
		RewardsAvailable    int                      `json:"rewards_available"`
		EligibleConfigs     []EligibleConfigResponse `json:"eligible_configs"`
		EligibleRewardItems []RewardItemResponse     `json:"eligible_reward_items"`
	}

	// Collecter tous les product_ids nécessaires en un seul passage
	allProductIDs := make([]int, 0)
	if reward != nil {
		for _, cfg := range reward.CategoryConfigs {
			if !cfg.AllProducts {
				allProductIDs = append(allProductIDs, cfg.ProductIDs...)
			}
		}
		for _, item := range reward.RewardItems {
			if item.ProductID > 0 {
				allProductIDs = append(allProductIDs, item.ProductID)
			}
		}
	}
	productNames, _ := database.GetProductNamesByIDs(allProductIDs)
	productCategories, _ := database.GetProductCategoriesByIDs(allProductIDs)

	pools := make([]PoolInfo, 0, len(settings.PointsPools))
	for _, pool := range settings.PointsPools {
		pts := pointsExtra[pool.Key]
		redeemed := pointsRedeemed[pool.Key]

		var earned, available int
		if reward != nil && reward.Threshold > 0 {
			earned = pts / reward.Threshold
			available = earned - redeemed
			available = max(earned-redeemed, 0)
		}

		poolCats := make(map[string]bool, len(pool.Categories))
		for _, c := range pool.Categories {
			poolCats[c] = true
		}
		eligibleConfigs := make([]EligibleConfigResponse, 0)
		if reward != nil {
			for _, cfg := range reward.CategoryConfigs {
				if !poolCats[cfg.Category] {
					continue
				}
				names := make([]string, 0, len(cfg.ProductIDs))
				for _, pid := range cfg.ProductIDs {
					if n, ok := productNames[pid]; ok {
						names = append(names, n)
					}
				}
				eligibleConfigs = append(eligibleConfigs, EligibleConfigResponse{
					Category:     cfg.Category,
					AllProducts:  cfg.AllProducts,
					ProductIDs:   cfg.ProductIDs,
					ProductNames: names,
				})
			}
		}

		eligibleProductIDs := eligibleRewardProductIDs(reward, poolCats, productCategories)
		eligibleRewardItems := make([]RewardItemResponse, 0)
		if reward != nil {
			for _, item := range reward.RewardItems {
				if !eligibleProductIDs[item.ProductID] {
					continue
				}
				eligibleRewardItems = append(eligibleRewardItems, RewardItemResponse{
					ProductID:   item.ProductID,
					ProductName: productNames[item.ProductID],
					Quantity:    item.Quantity,
					Price:       item.Price,
				})
			}
		}

		pools = append(pools, PoolInfo{
			Key:                 pool.Key,
			Name:                pool.Name,
			Points:              pts,
			RewardsEarned:       earned,
			RewardsClaimed:      redeemed,
			RewardsAvailable:    available,
			EligibleConfigs:     eligibleConfigs,
			EligibleRewardItems: eligibleRewardItems,
		})
	}

	// Construire la liste des produits récompense avec leurs noms
	var rewardMeta gin.H
	if reward != nil {
		rewardItems := make([]RewardItemResponse, 0, len(reward.RewardItems))
		for _, item := range reward.RewardItems {
			if item.ProductID <= 0 {
				continue
			}
			name := productNames[item.ProductID]
			rewardItems = append(rewardItems, RewardItemResponse{
				ProductID:   item.ProductID,
				ProductName: name,
				Quantity:    item.Quantity,
				Price:       item.Price,
			})
		}
		rewardMeta = gin.H{
			"threshold":    reward.Threshold,
			"type":         reward.Type,
			"description":  reward.Description,
			"reward_items": rewardItems,
		}
	}

	c.JSON(http.StatusOK, gin.H{"enabled": true, "pools": pools, "reward": rewardMeta})
}

// ClaimMyReward réclame une récompense sur un pool donné si le client a atteint le seuil.
func ClaimMyReward(c *gin.Context) {
	username := c.GetString("username")
	if username == "" {
		c.JSON(http.StatusUnauthorized, gin.H{"error": "Non authentifié"})
		return
	}

	var req struct {
		PoolKey   string `json:"pool_key" binding:"required"`
		ProductID int    `json:"product_id"`
	}
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "pool_key requis"})
		return
	}

	database := c.MustGet("database").(*db.Database)

	settings, err := database.GetSettings()
	if err != nil {
		utils.ServerErr(c, "Erreur lecture paramètres", err)
		return
	}

	if !settings.PointsEnabled {
		c.JSON(http.StatusForbidden, gin.H{"error": "Système de points désactivé"})
		return
	}

	reward := settings.PointsReward
	if reward == nil || reward.Threshold <= 0 {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Aucune récompense configurée"})
		return
	}

	// Vérifier que le pool existe et récupérer ses catégories
	var selectedPool *models.PointsPool
	for i := range settings.PointsPools {
		if settings.PointsPools[i].Key == req.PoolKey {
			selectedPool = &settings.PointsPools[i]
			break
		}
	}
	if selectedPool == nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Pool introuvable"})
		return
	}

	// Un produit récompense n'est éligible pour ce pool que si sa catégorie
	// fait partie des catégories du pool (via CategoryConfigs) — sans ce
	// filtre, un client pourrait réclamer n'importe quel produit récompense
	// (toutes catégories confondues) avec les points d'un pool quelconque.
	poolCategories := make(map[string]bool, len(selectedPool.Categories))
	for _, cat := range selectedPool.Categories {
		poolCategories[cat] = true
	}

	rewardProductIDs := make([]int, 0, len(reward.RewardItems))
	for _, item := range reward.RewardItems {
		if item.ProductID > 0 {
			rewardProductIDs = append(rewardProductIDs, item.ProductID)
		}
	}
	productCategories, err := database.GetProductCategoriesByIDs(rewardProductIDs)
	if err != nil {
		utils.ServerErr(c, "Erreur lecture catégories produits", err)
		return
	}

	eligibleProductIDs := eligibleRewardProductIDs(reward, poolCategories, productCategories)

	eligibleItems := make([]models.RewardItem, 0, len(reward.RewardItems))
	for _, item := range reward.RewardItems {
		if eligibleProductIDs[item.ProductID] {
			eligibleItems = append(eligibleItems, item)
		}
	}

	itemsToAdd := eligibleItems
	if req.ProductID > 0 {
		itemsToAdd = nil
		for _, item := range eligibleItems {
			if item.ProductID == req.ProductID {
				itemsToAdd = []models.RewardItem{item}
				break
			}
		}
		if itemsToAdd == nil {
			c.JSON(http.StatusForbidden, gin.H{"error": "Ce produit n'est pas éligible pour cette récompense"})
			return
		}
	}

	remaining, added, err := database.ClaimPoolRewardAndAddToBasket(username, req.PoolKey, reward.Threshold, itemsToAdd)
	if err != nil {
		if strings.Contains(err.Error(), "pas de récompense disponible") {
			c.JSON(http.StatusConflict, gin.H{"error": "Pas assez de points pour réclamer une récompense"})
			return
		}
		if strings.Contains(err.Error(), "produit récompense introuvable") {
			log.Printf("❌ [CLAIM] Configuration récompense invalide pour %s: %v", username, err)
			c.JSON(http.StatusConflict, gin.H{"error": "Récompense momentanément indisponible, contactez le support"})
			return
		}
		utils.ServerErr(c, "Erreur réclamation récompense", err)
		return
	}

	productAdded := len(added) > 0
	var productNames []string
	for _, item := range added {
		productNames = append(productNames, item.ProductName)
	}
	if productAdded {
		log.Printf("✅ [CLAIM] %d produit(s) récompense ajoutés au panier de %s", len(added), username)
	}

	c.JSON(http.StatusOK, gin.H{
		"success":           true,
		"description":       reward.Description,
		"remaining_rewards": remaining,
		"product_added":     productAdded,
		"product_names":     productNames,
	})
}

func AdminResetClientRedeemed(c *gin.Context) {
	username := c.Param("username")
	poolKey := c.Query("pool_key")

	database := c.MustGet("database").(*db.Database)
	if err := database.ResetClientRedeemed(username, poolKey); err != nil {
		utils.ServerErr(c, "Erreur reset récompenses", err)
		return
	}

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