/* Moteur de recommandations — Scoring intelligent pour Amazon FBA Canada */

// Fonction de scoring — évalue un produit sur 6 critères
window.calculateProductScore = function(product) {
  if (!product) return 0;
  
  let score = 0;
  let weights = {
    bsr: 0.25,        // 25% — Best Sellers Rank
    margin: 0.25,     // 25% — Marge de profit
    volume: 0.20,     // 20% — Volume mensuel
    price: 0.15,      // 15% — Point de prix
    supplier: 0.10,   // 10% — Qualité du fournisseur
    leadTime: 0.05    // 5% — Délai de livraison
  };
  
  // 1. Score BSR (plus bas = mieux) — normalisé sur 100
  const bsrScore = product.bsr ? Math.max(0, 100 - (product.bsr / 50)) : 0;
  score += bsrScore * weights.bsr;
  
  // 2. Score Marge (plus haut = mieux)
  const marginScore = Math.min(100, (product.margin || 0) * 2.5);
  score += marginScore * weights.margin;
  
  // 3. Score Volume (optimal entre 5k-20k u/mois)
  const vol = product.monthlyVolume || 0;
  let volumeScore = 0;
  if (vol >= 5000 && vol <= 20000) {
    volumeScore = 100 - Math.abs(vol - 12500) / 125;
  } else if (vol > 20000) {
    volumeScore = Math.max(0, 100 - (vol - 20000) / 500);
  } else if (vol > 0) {
    volumeScore = (vol / 5000) * 80;
  }
  score += volumeScore * weights.volume;
  
  // 4. Score Prix (optimal entre $20-$200)
  const priceUSD = (product.amazonPrice || 0) / 100;
  let priceScore = 0;
  if (priceUSD >= 20 && priceUSD <= 200) {
    priceScore = 100 - Math.abs(priceUSD - 99.99) / 2;
  } else if (priceUSD > 200) {
    priceScore = Math.max(0, 100 - (priceUSD - 200) / 10);
  } else if (priceUSD >= 10) {
    priceScore = (priceUSD / 20) * 80;
  }
  score += Math.min(100, priceScore) * weights.price;
  
  // 5. Score Qualité Fournisseur
  const supplierRating = product.supplierRating || 4.5;
  const supplierScore = (supplierRating / 5) * 100;
  score += supplierScore * weights.supplier;
  
  // 6. Score Délai de Livraison (plus rapide = mieux)
  const leadTime = product.leadTime || 5;
  let leadTimeScore = 0;
  if (leadTime <= 3) leadTimeScore = 100;
  else if (leadTime <= 5) leadTimeScore = 80;
  else if (leadTime <= 7) leadTimeScore = 60;
  else leadTimeScore = Math.max(0, 100 - (leadTime - 7) * 10);
  score += leadTimeScore * weights.leadTime;
  
  return Math.round(score);
};

// Générer les raisons du score
window.getScoreReasons = function(product) {
  const reasons = [];
  
  if (product.bsr && product.bsr < 1000) {
    reasons.push(`Excellent BSR: ${product.bsr} (Top 1000)`);
  } else if (product.bsr && product.bsr < 2000) {
    reasons.push(`Good BSR: ${product.bsr}`);
  }
  
  if (product.margin >= 40) {
    reasons.push(`Good margin: ${product.margin}%`);
  } else if (product.margin >= 35) {
    reasons.push(`Decent margin: ${product.margin}%`);
  }
  
  if (product.monthlyVolume >= 10000) {
    reasons.push(`High volume: ${(product.monthlyVolume / 1000).toFixed(1)}k units/month`);
  } else if (product.monthlyVolume >= 5000) {
    reasons.push(`Moderate volume: ${(product.monthlyVolume / 1000).toFixed(1)}k units/month`);
  }
  
  const priceUSD = (product.amazonPrice || 0) / 100;
  if (priceUSD >= 20 && priceUSD <= 200) {
    reasons.push(`Optimal price point: $${priceUSD.toFixed(2)}`);
  } else if (priceUSD < 20) {
    reasons.push(`Budget price: $${priceUSD.toFixed(2)}`);
  } else {
    reasons.push(`Premium price: $${priceUSD.toFixed(2)}`);
  }
  
  if (product.supplierRating >= 4.7) {
    reasons.push(`Quality supplier: ${product.supplier}`);
  }
  
  if (product.leadTime <= 3) {
    reasons.push(`Fastest shipping: ${product.leadTime} days`);
  } else if (product.leadTime <= 5) {
    reasons.push(`Fast shipping: ${product.leadTime} days`);
  }
  
  return reasons;
};

// Générer les recommandations quotidiennes
window.generateDailyRecommendations = function(products = window.PRODUCTS, limit = 10) {
  if (!products || products.length === 0) return [];
  
  // Calculer le score pour chaque produit
  const scored = products.map(p => ({
    ...p,
    score: window.calculateProductScore(p),
    reasons: window.getScoreReasons(p)
  }));
  
  // Trier par score décroissant
  const sorted = scored.sort((a, b) => b.score - a.score);
  
  // Retourner les top N
  return sorted.slice(0, limit);
};

// Grouper les recommandations par fournisseur
window.getRecommendationsBySupplier = function(products = window.PRODUCTS, limit = 10) {
  const recommendations = window.generateDailyRecommendations(products, limit * 2);
  
  const grouped = {};
  recommendations.forEach(rec => {
    if (!grouped[rec.supplier]) {
      grouped[rec.supplier] = [];
    }
    if (grouped[rec.supplier].length < 3) {
      grouped[rec.supplier].push(rec);
    }
  });
  
  return Object.entries(grouped).map(([supplier, products]) => ({
    supplier,
    products
  })).slice(0, limit);
};

// Générer l'analyse JARVIS
window.generateJarvisAnalysis = function(recommendations = []) {
  if (!recommendations || recommendations.length === 0) {
    return "Bonjour. Aucune opportunité disponible pour aujourd'hui. Continuez à monitorer le marché.";
  }
  
  const topProduct = recommendations[0];
  const topThree = recommendations.slice(0, 3);
  const avgMargin = (topThree.reduce((sum, p) => sum + (p.margin || 0), 0) / topThree.length).toFixed(1);
  
  return `Bonjour Clarens. J'ai analysé les ${recommendations.length} meilleures opportunités du jour.

Recommandation prioritaire : ${topProduct.title} (ASIN: ${topProduct.asin}) offre le meilleur ratio rentabilité/volume avec un score de ${topProduct.score}/100. 
Marge de ${topProduct.margin}%, volume de ${(topProduct.monthlyVolume / 1000).toFixed(1)}k unités/mois, et BSR excellent (#${topProduct.bsr}). Je recommande de commander 500 unités immédiatement.

Stratégie : Diversifier avec 3-4 produits de la liste pour réduire le risque de concentration. 
La marge moyenne des 3 meilleurs produits est de ${avgMargin}%, ce qui est excellent pour Amazon FBA.

Risques à surveiller : Vérifier les avis Amazon et les variations de prix avant de commander. 
Attention à la concurrence sur les produits populaires (BSR < 1000).`;
};

// Hook pour forcer le re-render quand les recommandations changent
window.useRecommendations = function() {
  const { useState, useEffect } = React;
  const [recs, setRecs] = useState([]);
  const [status, setStatus] = useState("loading");
  
  useEffect(() => {
    const fn = () => {
      const daily = window.generateDailyRecommendations(window.PRODUCTS, 10);
      setRecs(daily);
      setStatus(daily.length > 0 ? "ready" : "empty");
    };
    
    // Calculer immédiatement si les données sont déjà chargées
    if (window.PRODUCTS && window.PRODUCTS.length > 0) {
      fn();
    }
    
    // Re-calculer quand les données changent
    window.addEventListener(window.KCC_DATA_LOADED_EVT || "kcc:data-loaded", fn);
    return () => window.removeEventListener(window.KCC_DATA_LOADED_EVT || "kcc:data-loaded", fn);
  }, []);
  
  return { recommendations: recs, status };
};