// ============================================================
// DEMO SEEDER — génère 60 trades fictifs cohérents pour l'aha
// ============================================================
// Profil du dataset :
//   - 4 assets : EURUSD, BTCUSDT, XAUUSD, SPX500 (multi-marché)
//   - Étalé sur les 90 derniers jours
//   - Win rate global ~55%, R:R moyen ~1.3 → trader légèrement profitable
//   - 1 pattern caché : sessions du soir (>=15h UTC) = win rate 30%
//     C'est exactement le genre d'insight que le debrief IA doit trouver
//
// Toutes les rows sont INSERT en bulk via le client Supabase déjà initialisé.
// Les rows sont marquées is_demo=true (cf. migration 0008).
//
// Le générateur est déterministe par seed (le user_id passé en argument),
// pour que deux appels successifs du même user produisent les mêmes trades.

(function () {
  // Random seedé (mulberry32) — qualité suffisante pour des données démo.
  function makePrng(seedStr) {
    let h = 2166136261 >>> 0;
    for (let i = 0; i < seedStr.length; i++) {
      h = Math.imul(h ^ seedStr.charCodeAt(i), 16777619);
    }
    return function () {
      h = (h + 0x6D2B79F5) | 0;
      let t = h;
      t = Math.imul(t ^ (t >>> 15), t | 1);
      t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
      return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
    };
  }

  const ASSETS = [
    { symbol: "EURUSD",  market: "fx",     basePrice: 1.08,    volRange: [0.001, 0.004] },
    { symbol: "BTCUSDT", market: "crypto", basePrice: 65000,   volRange: [400, 1200] },
    { symbol: "XAUUSD",  market: "fx",     basePrice: 2350,    volRange: [4, 14] },
    { symbol: "SPX500",  market: "index",  basePrice: 5300,    volRange: [8, 22] },
  ];
  const STRATEGIES = ["breakout", "trend-follow", "mean-reversion", "scalp"];

  function sessionFromHour(h) {
    if (h >= 0  && h < 7)  return "ASIA";
    if (h >= 7  && h < 13) return "LONDON";
    if (h >= 13 && h < 21) return "NY";
    return "OFF";
  }

  // Génère le set de 60 trades pour un user_id donné.
  function generateTrades(userId) {
    const prng = makePrng(`nomerus-demo-${userId}`);
    const trades = [];
    const now = Date.now();
    const N = 60;

    for (let i = 0; i < N; i++) {
      const asset = ASSETS[Math.floor(prng() * ASSETS.length)];
      const strat = STRATEGIES[Math.floor(prng() * STRATEGIES.length)];

      // Étalage sur 90 jours, plus dense vers le présent
      const daysAgo = Math.floor((1 - Math.sqrt(prng())) * 90);
      // Heure UTC : biaisée vers 8-20h (évite hour=21 qui retomberait en "OFF")
      const hour = Math.floor(8 + prng() * 13);
      const minute = Math.floor(prng() * 60);
      const date = new Date(now - daysAgo * 86400 * 1000);
      date.setUTCHours(hour, minute, 0, 0);
      const session = sessionFromHour(hour);

      // Direction
      const direction = prng() > 0.5 ? "LONG" : "SHORT";

      // Win/loss : 55% global, MAIS 30% si session = NY après 15h UTC
      // (pattern caché que le debrief IA doit identifier)
      const isEveningNY = hour >= 15 && hour <= 20;
      const winProb = isEveningNY ? 0.30 : 0.62;
      const isWin = prng() < winProb;

      // R-multiple : winners distribués ~Normal(1.3, 0.4), losers ~ -1.0±0.2
      const r = isWin
        ? Math.max(0.3, 1.3 + (prng() - 0.5) * 0.8)
        : -Math.max(0.5, 1.0 + (prng() - 0.5) * 0.4);

      // Stop distance en points → sert UNIQUEMENT à calculer exit_price
      // depuis le R-multiple (pas stocké : la table trades n'a pas de
      // colonne stop_loss, et `market` n'existe pas non plus côté schéma).
      const volMin = asset.volRange[0], volMax = asset.volRange[1];
      const stopDist = volMin + prng() * (volMax - volMin);

      // Entry price proche du base
      const drift = (prng() - 0.5) * asset.basePrice * 0.03;
      const entry = asset.basePrice + drift;
      const exit = direction === "LONG"
        ? entry + (r * stopDist)
        : entry - (r * stopDist);

      // PnL en dollars (taille de position normalisée à 100$ de risque par trade)
      const riskUsd = 100;
      const pnl = +(r * riskUsd).toFixed(2);

      trades.push({
        user_id: userId,
        date: date.toISOString(),
        asset: asset.symbol,
        direction,
        entry_price: +entry.toFixed(asset.symbol === "EURUSD" ? 5 : 2),
        exit_price: +exit.toFixed(asset.symbol === "EURUSD" ? 5 : 2),
        pnl,
        r_multiple: +r.toFixed(2),
        result: isWin ? "WIN" : "LOSS",
        strategy: strat,
        session,
        platform: "DEMO",
        account: "Nomerus Demo",
        volume: 1,
        is_demo: true,
        notes: "",
      });
    }

    // Tri chronologique
    trades.sort((a, b) => new Date(a.date) - new Date(b.date));
    return trades;
  }

  const nomerusDemoSeeder = {
    /**
     * Génère et insère 60 trades démo pour l'utilisateur courant.
     * Retourne { ok: true, count: 60 } ou { ok: false, error: "fr" }.
     */
    async seed() {
      const sb = window.nomerusSb();
      if (!sb) return { ok: false, error: "Connexion Supabase indisponible." };

      const { data: { user }, error: userErr } = await sb.auth.getUser();
      if (userErr || !user) return { ok: false, error: "Utilisateur non authentifié." };

      // Idempotence : si l'utilisateur a déjà des trades démo, on ne re-seed pas.
      const { count: existing, error: countErr } = await sb
        .from("trades")
        .select("id", { count: "exact", head: true })
        .eq("user_id", user.id)
        .eq("is_demo", true);
      if (countErr) {
        console.warn("[demo-seeder] count error:", countErr);
        // On continue quand même — au pire on insère en double, et le user
        // aura 120 trades démo. Pas dramatique pour V1.
      } else if ((existing ?? 0) > 0) {
        return { ok: true, count: existing, alreadySeeded: true };
      }

      const trades = generateTrades(user.id);

      // Bulk insert. Le trigger enforce_free_quota va passer parce que
      // l'utilisateur a initial_import_done=false au signup (cf. P1).
      const { error } = await sb.from("trades").insert(trades);
      if (error) {
        console.warn("[demo-seeder] insert error:", error);
        return { ok: false, error: nomerusDemoSeeder._errorToFr(error), _raw: error };
      }

      return { ok: true, count: trades.length };
    },

    /** Supprime tous les trades démo de l'utilisateur courant. */
    async clear() {
      const sb = window.nomerusSb();
      if (!sb) return { ok: false, error: "Connexion Supabase indisponible." };
      const { data: { user } } = await sb.auth.getUser();
      if (!user) return { ok: false, error: "Utilisateur non authentifié." };
      const { error } = await sb.from("trades").delete()
        .eq("user_id", user.id).eq("is_demo", true);
      if (error) return { ok: false, error: nomerusDemoSeeder._errorToFr(error) };
      return { ok: true };
    },

    _errorToFr(err) {
      const raw = (err && (err.message || String(err))) || "";
      const m = raw.toLowerCase();
      if (m.includes("initial_import_cap_exceeded"))
        return "Cap d'import initial dépassé. Contacte le support.";
      if (m.includes("network") || m.includes("fetch"))
        return "Connexion réseau impossible.";
      return "Erreur lors du chargement des trades démo. Réessaie dans un instant.";
    },

    // Exposé pour permettre de générer des datasets de test sans appel DB.
    _generateTrades: generateTrades,
  };

  window.nomerusDemoSeeder = nomerusDemoSeeder;
})();