// dashboard/extra-sections.jsx — Two new sections:
//   1. MetricsExplained — formulas + intuition for OA, Kappa, P/R/F1, mIoU
//   2. NullDistributionExplorer — interactive McNemar null-distribution histogram per class
//   3. ResultsViz — explanatory diagram showing the "shape" of the global results table

const { useState: eUseState, useMemo: eUseMemo } = React;

const E_C7B = 'oklch(55% 0.13 250)';
const E_CRGB = 'oklch(70% 0.13 60)';
const E_CWIN = 'oklch(52% 0.17 145)';
const E_CERR = 'oklch(55% 0.20 25)';

// ── log Choose for binomial PMF ─────────────────────────────
function logChoose(n, k) {
  let r = 0;
  for (let i = 1; i <= k; i++) r += Math.log(n - k + i) - Math.log(i);
  return r;
}
function binomPMF(n, k, p = 0.5) {
  if (k < 0 || k > n) return 0;
  return Math.exp(logChoose(n, k) + k * Math.log(p) + (n - k) * Math.log(1 - p));
}

// ─────────────────────────────────────────────────────────────────────
// 1. METRICS EXPLAINED — formulas + a tiny visual confusion-matrix diagram
// ─────────────────────────────────────────────────────────────────────
function MetricsExplained() {
  const metrics = [
  {
    id: 'oa',
    name: 'Overall Accuracy',
    symbol: 'OA',
    formula: <span>OA = <span className="mfrac"><span>TP<sub>total</sub></span><span>N</span></span></span>,
    desc: 'Το ποσοστό σωστών pixels πάνω στο σύνολο. Απλή και ευανάγνωστη μετρική, αλλά παραπλανητική σε imbalanced dataset — ένα μοντέλο που προβλέπει πάντα τη κυρίαρχη κλάση (Bare Soil 55%) μπορεί να έχει «τυπικά καλό» OA χωρίς πραγματική learning.',
    diagram: <CMHint highlight="diag" label="κάθε διαγώνιο cell = TP" />
  },
  {
    id: 'kappa',
    name: 'Cohen\u2019s Kappa',
    symbol: 'κ',
    formula: <span>κ = <span className="mfrac"><span>p<sub>o</sub> − p<sub>e</sub></span><span>1 − p<sub>e</sub></span></span></span>,
    desc: 'Διορθώνει το OA αφαιρώντας τη συμφωνία που θα προέκυπτε τυχαία (p_e). Τιμωρεί μοντέλα που κερδίζουν από class imbalance — κ = 1 σημαίνει τέλεια συμφωνία, κ = 0 σημαίνει «καθόλου καλύτερο από τυχαία».',
    diagram: <KappaHint />
  },
  {
    id: 'pr',
    name: 'Precision & Recall',
    symbol: 'P, R',
    formula:
    <div className="formula-pair">
          <span>P<sub>c</sub> = <span className="mfrac"><span>TP</span><span>TP + FP</span></span></span>
          <span>R<sub>c</sub> = <span className="mfrac"><span>TP</span><span>TP + FN</span></span></span>
        </div>,

    desc: 'Per-class metrics: Precision = «από αυτά που είπα κλάση c, πόσα ήταν»; Recall = «από αυτά που πραγματικά ήταν c, πόσα έπιασα». Συχνά υπάρχει trade-off — υψηλό P συνήθως σημαίνει χαμηλό R και αντίστροφα.',
    diagram: <PRHint />
  },
  {
    id: 'f1',
    name: 'F1 score',
    symbol: 'F1',
    formula: <span>F1<sub>c</sub> = 2 · <span className="mfrac"><span>P · R</span><span>P + R</span></span></span>,
    desc: 'Αρμονικός μέσος όρος Precision και Recall για κάθε κλάση — τιμωρεί το «μονόπλευρο» μοντέλο όπου η μία τιμή είναι υψηλή και η άλλη χαμηλή. F1 = 1 σημαίνει τέλεια P και R, F1 = 0 τουλάχιστον μία από τις δύο = 0.',
    diagram: <F1Hint />
  },
  {
    id: 'macro-f1',
    name: 'Macro-averaged F1',
    symbol: 'Macro-F1',
    formula: <span>Macro-F1 = <span className="mfrac"><span>1</span><span>C</span></span> · Σ<sub>c</sub> F1<sub>c</sub></span>,
    desc: 'Αστάθμητος μέσος όρος των per-class F1 — δίνει ίδιο βάρος σε κάθε κλάση ανεξάρτητα από pixel share. Στο imbalanced setting μας (Bare Soil 55%, Vehicle 0.80%), η κυρίαρχη κλάση δεν μπορεί να καμουφλάρει την υποαπόδοση σπάνιων κλάσεων. Είναι η κύρια μετρική σύγκρισης 7-Band vs RGB στη διπλωματική.',
    diagram: <MacroF1Hint />
  },
  {
    id: 'iou',
    name: 'IoU & mIoU',
    symbol: 'IoU',
    formula: <span>IoU<sub>c</sub> = <span className="mfrac"><span>TP</span><span>TP + FP + FN</span></span></span>,
    desc: 'Jaccard index — ο λόγος του overlap προς την union (πρόβλεψη ∪ αλήθεια). Αυστηρότερο από F1 (τιμωρεί περισσότερο τα boundary errors). mIoU = μέσος όρος των IoU όλων των κλάσεων· είναι το standard metric για semantic segmentation.',
    diagram: <IoUHint />
  }];


  return (
    <div className="metrics-explained">
      <div className="metrics-grid">
        {metrics.map((m) =>
        <div className="metric-def-card" key={m.id}>
            <div className="met-hd">
              <div>
                <div className="met-sym mono">{m.symbol}</div>
                <div className="met-name">{m.name}</div>
              </div>
              <div className="met-diagram">{m.diagram}</div>
            </div>
            <div className="met-formula">{m.formula}</div>
            <p className="met-desc">{m.desc}</p>
          </div>
        )}
      </div>
      <div className="callout">
        Όλες οι μετρικές βασίζονται στον <b>confusion matrix</b>: TP (true positives) στη διαγώνιο,
        FP/FN στα off-diagonal κελιά. Στο imbalanced setting μας (Bare Soil = 55% των pixels,
        Vehicle = 0.80%), η <b>Macro-F1</b> και η <b>mIoU</b> είναι πιο αντιπροσωπευτικές
        από την OA.
      </div>
    </div>);

}

// Mini confusion-matrix hint diagrams
function CMHint({ highlight }) {
  const cells = Array.from({ length: 9 }, (_, i) => {
    const r = Math.floor(i / 3),c = i % 3;
    const diag = r === c;
    let fill = '#eaecf0';
    if (highlight === 'diag' && diag) fill = E_CWIN;
    return { r, c, fill };
  });
  return (
    <svg viewBox="0 0 60 60" width="56" height="56">
      <text x="30" y="9" textAnchor="middle" className="cmhint-axis">prediction</text>
      <text x="3" y="36" transform="rotate(-90 3 36)" textAnchor="middle" className="cmhint-axis">truth</text>
      {cells.map((c, i) =>
      <rect key={i} x={14 + c.c * 14} y={14 + c.r * 14} width="12" height="12" rx="1.5" fill={c.fill} />
      )}
    </svg>);

}

function KappaHint() {
  // tiny illustration: two filled bars, "observed" vs "chance"
  return (
    <svg viewBox="0 0 60 60" width="56" height="56">
      <rect x="6" y="42" width="48" height="6" fill="#eaecf0" rx="1" />
      <rect x="6" y="42" width="36" height="6" fill={E_CWIN} rx="1" />
      <text x="6" y="38" className="cmhint-axis">p_o (observed)</text>
      <rect x="6" y="22" width="48" height="6" fill="#eaecf0" rx="1" />
      <rect x="6" y="22" width="14" height="6" fill="oklch(75% 0.06 250)" rx="1" />
      <text x="6" y="18" className="cmhint-axis">p_e (chance)</text>
    </svg>);

}

function PRHint() {
  return (
    <svg viewBox="0 0 60 60" width="56" height="56">
      <circle cx="22" cy="32" r="14" fill={E_C7B} fillOpacity="0.6" />
      <circle cx="38" cy="32" r="14" fill={E_CRGB} fillOpacity="0.6" />
      <text x="14" y="55" className="cmhint-axis">truth</text>
      <text x="36" y="55" className="cmhint-axis">pred</text>
    </svg>);

}

function F1Hint() {
  // harmonic mean curve, two endpoints
  return (
    <svg viewBox="0 0 60 60" width="56" height="56">
      <path d="M 8 50 Q 30 8 52 50" fill="none" stroke={E_CWIN} strokeWidth="2" />
      <circle cx="30" cy="22" r="3" fill={E_CWIN} />
      <text x="30" y="56" textAnchor="middle" className="cmhint-axis">P · R balance</text>
    </svg>);

}

function IoUHint() {
  return (
    <svg viewBox="0 0 60 60" width="56" height="56">
      <circle cx="22" cy="32" r="14" fill={E_C7B} fillOpacity="0.5" stroke={E_C7B} strokeWidth="1.5" />
      <circle cx="38" cy="32" r="14" fill={E_CRGB} fillOpacity="0.5" stroke={E_CRGB} strokeWidth="1.5" />
      <path d="M 30 18.6 A 14 14 0 0 1 30 45.4 A 14 14 0 0 1 30 18.6 Z" fill={E_CWIN} fillOpacity="0.85" />
      <text x="30" y="56" textAnchor="middle" className="cmhint-axis">∩ / ∪</text>
    </svg>);

}

function MacroF1Hint() {
  // 7 thin bars at equal height — "all classes weighted equally" visual cue
  const hues = [145, 25, 260, 230, 130, 70, 305];
  return (
    <svg viewBox="0 0 60 60" width="56" height="56">
      <line x1="6" y1="14" x2="54" y2="14" stroke="#4a4f5a" strokeWidth="1.2" strokeDasharray="2 2" />
      <text x="30" y="11" textAnchor="middle" className="cmhint-axis">avg · ίδιο βάρος</text>
      {hues.map((h, i) =>
      <rect key={i} x={5.5 + i * 7} y={20} width={5.4} height={32} fill={`oklch(60% 0.12 ${h})`} rx={0.6} />
      )}
    </svg>);

}

// ─────────────────────────────────────────────────────────────────────
// 2. NULL DISTRIBUTION EXPLORER — interactive histogram per class
// ─────────────────────────────────────────────────────────────────────
// Per-class commentary for the null-distribution callout.
const classCallouts = {
  'Tree': <>
    <b>Tree — n.s. (οριακή τάση προς RGB).</b> Με b = 5 και c = 17, η παρατηρούμενη γραμμή b
    βρίσκεται αριστερά του κέντρου (RGB επικρατεί στις discordant). Το unadjusted p = 0.017
    θα ήταν σημαντικό, αλλά μετά την <b>Holm correction (×7)</b> σταματάει στο 0.061 —
    πιθανότατα boundary noise από NIR/RedEdge για δένδρα σε buffer points.
  </>,
  'Building': <>
    <b>Building — αδιαμφισβήτητη επικράτηση 7-Band.</b> b = 69, c = 0 — καμία
    περίπτωση όπου μόνο το RGB έπιασε τις στέγες. Το <b>nDSM</b> είναι το killer feature
    — διαχωρίζει τις στέγες από άλλες impervious surfaces με έναν τρόπο που το spectral
    information απλά δεν μπορεί.
  </>,
  'Road': <>
    <b>Road — n.s.</b> Με b = 2 και c = 3, τα δύο μοντέλα διαφωνούν μόνο σε 5
    από 300 points. p_Holm = 1.0 — οι δρόμοι έχουν τόσο χαρακτηριστικό spectral
    signature και γεωμετρία που το RGB είναι ήδη επαρκές.
  </>,
  'Vehicle': <>
    <b>Vehicle — ισχυρή επικράτηση 7-Band.</b> b = 47 vs c = 3, odds ratio = 15.7.
    Συνδυασμός <b>nDSM</b> (τα οχήματα έχουν ύψος άνω του εδάφους) + <b>Thermal</b>
    (ζεστοί κινητήρες) — δύο ανεξάρτητα cues που το RGB απλώς δεν έχει.
  </>,
  'Grass': <>
    <b>Grass — n.s. αφού Holm.</b> b = 34, c = 16 — υπάρχει τάση υπέρ 7-Band
    (p προ-Holm = 0.015) αλλά δεν επιβιώνει της πολλαπλής σύγκρισης. Το NDVI
    προσφέρει marginal benefit, αλλά το RGB texture είναι ήδη επαρκές για το χλοοτάπητα.
  </>,
  'Bare Soil': <>
    <b>Bare Soil — n.s.</b> b = 7 vs c = 4 σε 11 συνολικά discordant pairs. Τα
    λάθη εμφανίζονται όμοια και στα δύο μοντέλα — δεν είναι spectral πρόβλημα.
  </>,
  'Shadow-Noise': <>
    <b>Shadow-Noise — το πιο εντυπωσιακό εύρημα.</b> b = 104, c = 2,
    odds ratio = 52. Το <b>Thermal</b> «βλέπει» την επιφάνεια κάτω από τη σκιά
    (η radiative temperature δεν μεταβάλλεται όσο το visible reflectance). Το RGB μπερδεύει
    shadow-on-tree με shadow-on-road — το 7-Band τα διαχωρίζει σχεδόν τελείως.
  </>
};

function NullDistributionExplorer() {
  const D = window.DASH;
  const CCOL = D.meta.classColors;
  const perClass = D.significance.perClass;
  const [selected, setSelected] = eUseState('Shadow-Noise');
  const cur = perClass.find((p) => p.cls === selected);
  const n = cur.b + cur.c;
  const expected = n / 2;

  // Compute full PMF
  const pmf = eUseMemo(() => {
    const arr = [];
    for (let k = 0; k <= n; k++) arr.push({ k, p: binomPMF(n, k) });
    return arr;
  }, [n]);

  // Determine unadjusted two-sided 0.05 rejection thresholds (approx)
  // Find smallest |k - n/2| s.t. cumulative tail < 0.025
  const tailThresh = eUseMemo(() => {
    let cum = 0,kLow = 0,kHigh = n;
    for (let k = 0; k <= n; k++) {
      cum += pmf[k].p;
      if (cum < 0.025) kLow = k;else
      break;
    }
    cum = 0;
    for (let k = n; k >= 0; k--) {
      cum += pmf[k].p;
      if (cum < 0.025) kHigh = k;else
      break;
    }
    return { kLow, kHigh };
  }, [pmf, n]);

  // SVG geometry
  const W = 720,H = 360;
  const M = { t: 28, r: 24, b: 56, l: 56 };
  const iw = W - M.l - M.r;
  const ih = H - M.t - M.b;

  const xMax = n;
  const yMax = Math.max(...pmf.map((p) => p.p)) * 1.15;
  const sx = (k) => M.l + k / xMax * iw;
  const sy = (p) => M.t + (1 - p / yMax) * ih;

  // x ticks — at most 8 evenly-spaced positions.
  // Avoid placing two ticks closer than tickStep/2 (e.g. 49 + 50 visually merging into "4950").
  const tickStep = Math.max(1, Math.ceil(n / 8));
  const xTicks = [];
  for (let k = 0; k <= n; k += tickStep) xTicks.push(k);
  const last = xTicks[xTicks.length - 1];
  if (last !== n) {
    if (n - last < tickStep / 2) xTicks[xTicks.length - 1] = n;
    else xTicks.push(n);
  }

  // y ticks
  const yTicks = [0, 0.25, 0.5, 0.75, 1].map((t) => t * yMax);

  const decision = cur.sig === '***' ?
  { txt: 'Reject H₀ · 7-Band ✱✱✱', color: E_CWIN } :
  { txt: 'Fail to reject H₀ (Holm-adjusted)', color: 'var(--ink-3)' };

  return (
    <div className="nullx-card">
      <div className="theory-block">
        <div className="theory-title">Θεωρία — Per-class McNemar + Holm correction</div>
        <div className="theory-body">
          <p>
            Τρέχουμε το McNemar exact test ξεχωριστά για κάθε μία από τις 7 κλάσεις.
            Με 7 ταυτόχρονα tests στο α = 0.05, η πιθανότητα <b>έστω και ενός</b> ψευδώς
            θετικού ευρήματος γίνεται 1 − 0.95⁷ ≈ <b>30%</b>. Η Holm-Bonferroni correction
            διορθώνει αυτό το family-wise error rate πολλαπλασιάζοντας τα p-values
            σε αύξουσα σειρά επί m, m−1, m−2... (έως 7, 6, 5...).
          </p>
          <div className="theory-hypotheses">
            <div className="theory-h0"><b>H₀</b>: για την επιλεγμένη κλάση, τα δύο μοντέλα κάνουν
              ίδια λάθη → b θα είναι κοντά στο n/2 (μπλε γκρι κατανομή παρακάτω).</div>
            <div className="theory-ha"><b>Hₐ</b>: ένα μοντέλο πραγματικά πιάνει πιο συχνά αυτή την
              κλάση → η πράσινη γραμμή b θα είναι μακριά από το n/2.</div>
            <div className="theory-decision">
              <b>Decision rule</b>: αν Holm-adjusted p &lt; 0.05 → reject H₀. Παρακάτω,
              μόνο 3/7 κλάσεις περνούν το κατώφλι: <b>Building, Vehicle, Shadow-Noise</b>.
            </div>
          </div>
        </div>
      </div>

      <div className="nullx-class-strip">
        {perClass.map((p) =>
        <button key={p.cls}
        className={'nullx-chip' + (selected === p.cls ? ' active' : '')}
        onClick={() => setSelected(p.cls)}>
            <span className="nullx-chip-dot" style={{ background: CCOL[p.cls] }} />
            <span>{p.cls}</span>
            {p.sig === '***' && <span className="nullx-chip-star">✱</span>}
          </button>
        )}
      </div>

      <div className="nullx-summary">
        <div className="nullx-sumcell">
          <div className="nullx-l">Sample n / class</div>
          <div className="nullx-v mono">300<span className="nullx-foot"> (paired)</span></div>
        </div>
        <div className="nullx-sumcell">
          <div className="nullx-l">Discordant pairs (b + c)</div>
          <div className="nullx-v mono">{n}<span className="nullx-foot"> = test n</span></div>
        </div>
        <div className="nullx-sumcell">
          <div className="nullx-l" style={{ color: E_C7B }}>b · only 7-Band ✓</div>
          <div className="nullx-v big mono" style={{ color: E_C7B }}>{cur.b}</div>
        </div>
        <div className="nullx-sumcell">
          <div className="nullx-l" style={{ color: E_CRGB }}>c · only RGB ✓</div>
          <div className="nullx-v big mono" style={{ color: E_CRGB }}>{cur.c}</div>
        </div>
        <div className="nullx-sumcell">
          <div className="nullx-l">Holm-adjusted p</div>
          <div className="nullx-v mono">{cur.pHolm < 1e-3 ? cur.pHolm.toExponential(2) : cur.pHolm.toFixed(3)}</div>
        </div>
        <div className="nullx-sumcell">
          <div className="nullx-l">Decision (α = 0.05)</div>
          <div className="nullx-v mono" style={{ color: decision.color, fontWeight: 600 }}>{decision.txt}</div>
        </div>
      </div>

      <div className="nullx-help">
        <b>Γιατί n = {n} και όχι 300;</b> Το McNemar test απαιτεί paired design και χρησιμοποιεί μόνο τα <b>discordant pairs</b> (b+c) — τις περιπτώσεις όπου τα δύο μοντέλα διαφωνούν. Τα <b>concordant pairs</b> (a+d) δεν προσφέρουν πληροφορία για το ποιο μοντέλο είναι καλύτερο. Εδώ: <b>300 = sample size</b>, <b>{n} = test statistic n</b> (a = {cur.a}, d = {cur.d}).
      </div>

      <div className="nullx-plot-wrap">
        <svg viewBox={`0 0 ${W} ${H}`} className="nullx-svg">
          {/* y grid + ticks */}
          {yTicks.map((p, i) =>
          <g key={'y' + i}>
              <line x1={M.l} x2={W - M.r} y1={sy(p)} y2={sy(p)}
            stroke="var(--line)" strokeDasharray="2 4" strokeOpacity="0.6" />
              <text x={M.l - 8} y={sy(p) + 4} textAnchor="end" className="nullx-axlabel">
                {p === 0 ? '0' : p.toFixed(3)}
              </text>
            </g>
          )}

          {/* PMF bars */}
          {pmf.map(({ k, p }) => {
            const inRejectLow = k <= tailThresh.kLow;
            const inRejectHigh = k >= tailThresh.kHigh;
            const isObserved = k === cur.b || k === cur.c;
            let fill = 'oklch(70% 0.04 250)';
            if (inRejectLow || inRejectHigh) fill = 'oklch(72% 0.10 25)';
            return (
              <rect key={k}
              x={sx(k) - Math.max(1, iw / (n + 1) / 2)}
              y={sy(p)}
              width={Math.max(1.5, iw / (n + 1) * 0.85)}
              height={M.t + ih - sy(p)}
              fill={fill}
              opacity={isObserved ? 1 : 0.78} />);

          })}

          {/* x axis */}
          <line x1={M.l} x2={W - M.r} y1={M.t + ih} y2={M.t + ih} stroke="var(--ink)" strokeWidth="1.2" />
          {xTicks.map((k, i) =>
          <g key={'x' + i}>
              <line x1={sx(k)} x2={sx(k)} y1={M.t + ih} y2={M.t + ih + 4} stroke="var(--ink-2)" strokeWidth="1" />
              <text x={sx(k)} y={M.t + ih + 18} textAnchor="middle" className="nullx-axlabel">{k}</text>
            </g>
          )}

          {/* Expected (null) line */}
          <line x1={sx(expected)} x2={sx(expected)} y1={M.t} y2={M.t + ih}
          stroke="var(--ink-3)" strokeWidth="1.5" strokeDasharray="6 4" />
          <text x={sx(expected)} y={M.t - 8} textAnchor="middle" className="nullx-anno">
            null expected · k = {expected.toFixed(1)}
          </text>

          {/* Observed b line (green) */}
          <line x1={sx(cur.b)} x2={sx(cur.b)} y1={M.t} y2={M.t + ih}
          stroke={E_CWIN} strokeWidth="2.5" />
          {(() => {
            const bx = sx(cur.b);
            // Clamp inside the plotting area: place to the right of the line
            // unless we're too close to the right edge of the chart.
            const placeRight = bx < M.l + iw - 60;
            return (
              <text x={bx} y={M.t + 14}
                    textAnchor={placeRight ? 'start' : 'end'}
                    dx={placeRight ? 6 : -6}
                    className="nullx-anno-b">b = {cur.b}</text>
            );
          })()}

          {/* Observed c line (orange) */}
          {cur.c !== cur.b &&
          <>
              <line x1={sx(cur.c)} x2={sx(cur.c)} y1={M.t} y2={M.t + ih}
            stroke={E_CRGB} strokeWidth="2.5" />
              {(() => {
                const cx = sx(cur.c);
                // Same clamp logic as b. Also avoid colliding with the b label
                // when b and c are close: nudge to the opposite side from b.
                const bx = sx(cur.b);
                const tooCloseToB = Math.abs(cx - bx) < 40;
                let placeRight = cx < M.l + iw - 60;
                if (tooCloseToB) placeRight = bx >= M.l + iw - 60; // flip relative to b
                return (
                  <text x={cx} y={M.t + 14}
                        textAnchor={placeRight ? 'start' : 'end'}
                        dx={placeRight ? 6 : -6}
                        className="nullx-anno-c">c = {cur.c}</text>
                );
              })()}
            </>
          }

          {/* axis titles */}
          <text x={M.l + iw / 2} y={H - 10} textAnchor="middle" className="nullx-axtitle">
            k · # of discordant pairs where 7-Band wins
          </text>
          <text x={-(M.t + ih / 2)} y={16} transform="rotate(-90)"
          textAnchor="middle" className="nullx-axtitle">
            PMF · Binomial(b+c = {n}, p = 0.5)
          </text>
        </svg>
      </div>

      <div className="nullx-legend">
        <span><span className="sw" style={{ background: 'oklch(70% 0.04 250)' }} />Acceptance region (under H₀)</span>
        <span><span className="sw" style={{ background: 'oklch(72% 0.10 25)' }} />Unadj. α = 0.05 rejection</span>
        <span><span className="sw vline" style={{ background: 'var(--ink-3)' }} />Null expected (n/2)</span>
        <span><span className="sw vline" style={{ background: E_CWIN }} />Observed b</span>
        <span><span className="sw vline" style={{ background: E_CRGB }} />Observed c</span>
      </div>

      <div className="callout">
        {classCallouts[selected]}
      </div>
    </div>);

}

// ─────────────────────────────────────────────────────────────────────
// 3. RESULTS VIZ — explanatory horizontal-grouped-bar matrix
// (visual complement to the numeric results table)
// ─────────────────────────────────────────────────────────────────────
function ResultsViz() {
  const D = window.DASH;
  const methods = ['M1', 'M2', 'M3', 'M4'];
  const metrics = [
  { id: 'oa', label: 'OA' },
  { id: 'kappa', label: 'Kappa' },
  { id: 'mf1', label: 'Macro-F1' },
  { id: 'miou', label: 'mIoU' }];

  return (
    <div className="rviz-card">
      <div className="rviz-hd">
        <div>
          <div className="kicker">Visual overview</div>
          <div className="rviz-title">Όλες οι μετρικές, σε ένα κοίταγμα</div>
        </div>
        <div className="rviz-legend">
          <span><span className="rviz-dot" style={{ background: E_C7B }} />7-Band</span>
          <span><span className="rviz-dot" style={{ background: E_CRGB }} />RGB</span>
        </div>
      </div>
      <div className="rviz-grid">
        <div className="rviz-corner"></div>
        {metrics.map((m) => <div key={m.id} className="rviz-col-hd">{m.label}</div>)}
        {methods.map((mid) =>
        <React.Fragment key={mid}>
            <div className="rviz-row-hd">{mid}</div>
            {metrics.map((m) => {
            const r7 = D.results.find((r) => r.method === mid && r.model === '7B');
            const rR = D.results.find((r) => r.method === mid && r.model === 'RGB');
            const v7 = r7[m.id],vR = rR[m.id];
            return (
              <div className="rviz-cell" key={m.id}>
                  {v7 == null ? <div className="rviz-na mono">—</div> :
                <>
                      <RvizBar v={v7} color={E_C7B} />
                      <RvizBar v={vR} color={E_CRGB} />
                    </>
                }
                </div>);

          })}
          </React.Fragment>
        )}
      </div>
      <div className="callout">
        Σε κάθε κελί δύο μπάρες (πάνω = 7-Band, κάτω = RGB) γεμίζουν από 0 έως 1. Η σταθερή
        υπεροχή της πάνω μπάρας σε όλες τις μεθόδους × μετρικές δείχνει ότι το 7-Band advantage
        δεν είναι αρτεφάκτο μίας μεθόδου.
      </div>
    </div>);

}

function RvizBar({ v, color }) {
  return (
    <div className="rviz-bar-row">
      <div className="rviz-track">
        <div className="rviz-fill" style={{ width: `${v * 100}%`, background: color }} />
      </div>
      <span className="rviz-v mono">{v.toFixed(3)}</span>
    </div>);

}

Object.assign(window, {
  DMetricsExplained: MetricsExplained,
  DNullDistribution: NullDistributionExplorer,
  DResultsViz: ResultsViz
});