/*
  Dinasty live data adapter.
  Preserves the user's existing UI contract: window.DINASTY stays the data shape.
  Secrets stay server-side; this adapter only calls the authenticated dashboard API.
*/
(function () {
  const ROLE_BY_SLOT = ["Core", "Core", "Hedge", "Scout", "Grid", "Recovery", "Hedge", "Scout"];
  const HEDGE_COLORS = ["#ECBA5A", "#5ED1C7", "#D9A6E2", "#36D98F", "#F2A35E", "#7FB2F0"];

  const num = (value, fallback = 0) => {
    const n = Number(value);
    return Number.isFinite(n) ? n : fallback;
  };

  const text = (value, fallback = "") => {
    if (value === null || value === undefined || value === "") return fallback;
    return String(value);
  };

  const pad2 = (n) => String(n).padStart(2, "0");

  const cleanSymbol = (symbol) => text(symbol, "XAUUSD").replace(/c$/i, "");

  const setId = (row, index) => {
    const raw = text(row.set_id || row.account_code || row.full_magic, "");
    if (/^A\d{2}-\d{2}$/i.test(raw)) return raw.toUpperCase();
    if (/^A\d{2}$/i.test(raw)) return `${raw.toUpperCase()}-${pad2(num(row.slot_no, 1))}`;
    return `LIVE-${pad2(index + 1)}`;
  };

  const slotFromId = (id, fallback) => {
    const m = String(id).match(/-(\d{2})$/);
    if (!m) return fallback;
    const slot = Number(m[1]);
    return Number.isFinite(slot) && slot > 0 ? slot : fallback;
  };

  const sideFromPositions = (positions) => {
    let buy = 0;
    let sell = 0;
    for (const p of positions) {
      if (text(p.direction).toUpperCase() === "BUY") buy += num(p.volume);
      else sell += num(p.volume);
    }
    return buy >= sell ? "BUY" : "SELL";
  };

  const ageText = (value) => {
    if (!value) return "live";
    const dt = new Date(value);
    if (Number.isNaN(dt.getTime())) return "live";
    const mins = Math.max(0, Math.round((Date.now() - dt.getTime()) / 60000));
    if (mins < 60) return `${mins}m`;
    return `${Math.floor(mins / 60)}h ${mins % 60}m`;
  };

  const groupBy = (items, keyFn) => {
    const out = new Map();
    for (const item of items || []) {
      const key = keyFn(item);
      if (!out.has(key)) out.set(key, []);
      out.get(key).push(item);
    }
    return out;
  };

  const recFor = (floating, closedProfit, openPos) => {
    if (floating <= -500 || closedProfit <= -1000) return "PAUSE";
    if (floating <= -150 || openPos >= 5) return "REDUCE";
    return "NORMAL";
  };

  function makeRows(summary, fallback) {
    const livePositions = summary.positions || [];
    const deals = summary.deals || [];
    const sets = summary.sets || [];
    const byKey = groupBy(livePositions, (p) => `${text(p.vps)}|${text(p.account_code)}|${text(p.set_id || p.full_magic || p.ticket)}`);
    for (const d of deals) {
      const key = `${text(d.vps)}|${text(d.account_code)}|${text(d.set_id || d.account_code)}`;
      if (!byKey.has(key)) byKey.set(key, []);
    }
    for (const s of sets) {
      const key = `${text(s.vps)}|${text(s.account_code)}|${text(s.set_id || s.full_magic || s.account_code)}`;
      if (!byKey.has(key)) byKey.set(key, []);
    }

    const dealByKey = new Map();
    for (const d of deals) {
      const key = `${text(d.vps)}|${text(d.account_code)}|${text(d.set_id || d.account_code)}`;
      dealByKey.set(key, d);
    }
    const setByKey = new Map();
    for (const s of sets) {
      const key = `${text(s.vps)}|${text(s.account_code)}|${text(s.set_id || s.full_magic || s.account_code)}`;
      setByKey.set(key, s);
    }

    const rows = [];
    for (const [key, positions] of byKey) {
      const [vpsRaw, accountRaw] = key.split("|");
      const first = positions[0] || {};
      const deal = dealByKey.get(key) || {};
      const setMeta = setByKey.get(key) || {};
      const id = setId(first.set_id ? first : (deal.set_id ? deal : setMeta), rows.length);
      const slot = num(setMeta.slot_no, slotFromId(id, rows.length + 1));
      const openPos = positions.length;
      const floating = positions.reduce((sum, p) => sum + num(p.profit), 0);
      const closedProfit = num(deal.closed_profit);
      const rec = recFor(floating, closedProfit, openPos);
      const symbol = cleanSymbol(first.symbol || deal.symbol);
      const lots = positions.reduce((sum, p) => sum + num(p.volume), 0);
      const pf = closedProfit < 0 ? 0.75 : closedProfit > 0 ? 1.25 : 1;
      const winrate = closedProfit < 0 ? 42 : closedProfit > 0 ? 58 : 50;
      const drawdown = Math.min(15, Math.round(Math.abs(Math.min(floating, 0)) / 100));
      const lossStreak = closedProfit < 0 ? 3 : 0;
      rows.push({
        id,
        vps: text(vpsRaw, first.vps || deal.vps || "VPS-1"),
        account: text(accountRaw, first.account_code || deal.account_code || "LIVE"),
        role: text(setMeta.slot_role, ROLE_BY_SLOT[(slot - 1) % ROLE_BY_SLOT.length]),
        slot,
        mode: slot % 3 === 0 ? "REVERSAL" : "NORMAL",
        symbol,
        openPos,
        side: sideFromPositions(positions),
        lots: Math.round(lots * 100) / 100,
        pl: Math.round(closedProfit + floating),
        floating: Math.round(floating),
        drawdown,
        lossStreak,
        winrate,
        pf,
        rec,
        risky: rec !== "NORMAL",
      });
    }
    return rows.length ? rows : (fallback.rows || []);
  }

  function makePositions(summary, rows, fallback) {
    const rowByKey = new Map(rows.map((r) => [`${r.vps}|${r.account}|${r.id}`, r]));
    const positions = (summary.positions || []).map((p, index) => {
      const id = setId(p, index);
      const row = rowByKey.get(`${text(p.vps)}|${text(p.account_code)}|${id}`);
      const symbol = cleanSymbol(p.symbol || (row && row.symbol));
      const side = text(p.direction, "BUY").toUpperCase();
      const entry = num(p.entry_price);
      const cur = num(p.current_price, entry);
      const lots = num(p.volume);
      const profit = num(p.profit);
      const pips = entry ? Math.round((cur - entry) * (side === "BUY" ? 1 : -1) * 10) : 0;
      return {
        ticket: text(p.ticket, `LIVE-${index + 1}`),
        set: id,
        symbol,
        side,
        lots,
        entry: entry ? entry.toFixed(symbol.includes("JPY") ? 3 : 2) : "-",
        cur: cur ? cur.toFixed(symbol.includes("JPY") ? 3 : 2) : "-",
        pips,
        swap: 0,
        age: ageText(p.open_time || p.collected_at),
        pl: Math.round(profit),
      };
    });
    return positions.length ? positions : (fallback.positions || []);
  }

  function makeOverview(summary, rows, positions, fallback) {
    const snapshots = summary.snapshots || [];
    const exposure = summary.exposure || [];
    const totalEquity = snapshots.reduce((sum, s) => sum + num(s.equity), 0) || (fallback.overview && fallback.overview.totalEquity) || 0;
    const floatingPL = exposure.reduce((sum, e) => sum + num(e.floating_profit), 0) || positions.reduce((sum, p) => sum + num(p.pl), 0);
    const dailyPL = rows.reduce((sum, r) => sum + num(r.pl), 0);
    const pause = rows.filter((r) => r.rec === "PAUSE").length;
    const reduce = rows.filter((r) => r.rec === "REDUCE").length;
    const normal = rows.filter((r) => r.rec === "NORMAL").length;
    const risky = rows.filter((r) => r.risky).length;
    const openSets = rows.filter((r) => r.openPos > 0).length;
    const openPositions = positions.length;
    const aiStatus = pause ? "PAUSE" : reduce ? "REDUCE" : "NORMAL";
    return {
      ...fallback.overview,
      totalEquity,
      floatingPL,
      dailyPL,
      ddPct: Math.max(...rows.map((r) => num(r.drawdown)), 0),
      ddAmount: Math.round(Math.abs(Math.min(floatingPL, 0))),
      aiStatus,
      counts: { pause, reduce, normal, risky, openSets, openPositions, total: rows.length },
    };
  }

  function makeEquityCurve(overview, fallback) {
    const base = fallback.equityCurve || [];
    if (!base.length) return [overview.totalEquity];
    const last = base[base.length - 1] || 1;
    const scale = last ? overview.totalEquity / last : 1;
    return base.map((p) => Math.round(p * scale));
  }

  function makeAlerts(rows, summary) {
    const latest = summary.generated_at ? new Date(summary.generated_at).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" }) : "live";
    const risky = rows.filter((r) => r.risky).slice(0, 4);
    if (!risky.length) {
      return [{ time: latest, type: "NORMAL", title: "Live Supabase feed", text: "Collector data is flowing through the dashboard API." }];
    }
    return risky.map((r) => ({
      time: latest,
      type: r.rec,
      title: `${r.id} ${r.rec}`,
      text: `${r.symbol} floating ${r.floating >= 0 ? "+" : ""}${r.floating}, ${r.openPos} open positions.`,
    }));
  }

  function makeVpsHealth(rows, summary) {
    const snapshots = summary.snapshots || [];
    const allVps = [...new Set([...rows.map((r) => r.vps), ...snapshots.map((s) => s.vps)].filter(Boolean))];
    return allVps.map((vps) => {
      const rs = rows.filter((r) => r.vps === vps);
      const snap = snapshots.find((s) => s.vps === vps) || {};
      return {
        vps,
        status: "ONLINE",
        equity: num(snap.equity),
        pl: rs.reduce((sum, r) => sum + num(r.pl), 0),
        risky: rs.filter((r) => r.risky).length,
        open: rs.filter((r) => r.openPos > 0).length,
        updated: ageText(snap.collected_at),
      };
    });
  }

  function makeMonitor(positions, fallback) {
    const source = positions.length ? positions : (fallback.positions || []);
    return source.map((p, index) => ({
      ticket: p.ticket,
      sym: p.symbol,
      dir: p.side,
      lot: num(p.lots),
      entry: p.entry,
      sl: "-",
      tp: "-",
      r: Math.round(num(p.pl) / 100) / 10,
      trail: num(p.pl) > 0 ? "trailing" : "armed",
      hedge: index % 2 === 1 ? null : { id: `H${(index % 6) + 1}`, partner: p.symbol, color: HEDGE_COLORS[index % HEDGE_COLORS.length] },
    }));
  }

  async function load(fallback) {
    const res = await fetch("/api/summary", { cache: "no-store" });
    if (!res.ok) throw new Error(`summary ${res.status}`);
    const summary = await res.json();
    const rows = makeRows(summary, fallback);
    const positions = makePositions(summary, rows, fallback);
    const overview = makeOverview(summary, rows, positions, fallback);
    return {
      ...fallback,
      rows,
      overview,
      equityCurve: makeEquityCurve(overview, fallback),
      alerts: makeAlerts(rows, summary),
      vpsHealth: makeVpsHealth(rows, summary),
      positions,
      monitor: makeMonitor(positions, fallback),
      liveSummary: summary,
    };
  }

  window.DINASTY_LIVE = { load };
})();