// dashboard/sections.jsx — All section components for the thesis dashboard.
// Exported to window so app.jsx can compose them.

const { useState, useMemo } = React;

const C7B = 'oklch(55% 0.13 250)';
const CRGB = 'oklch(70% 0.13 60)';
const CWIN = 'oklch(52% 0.17 145)'; // significance / win green
const CERR = 'oklch(55% 0.20 25)'; // error red
const C_DIAG = 'oklch(48% 0.13 145)'; // CM diagonal green

const fmt = (n, p = 4) => n == null || isNaN(n) ? '—' : n.toFixed(p);
const ppfmt = (d, p = 1) => (d * 100).toFixed(p) + ' pp';
const pctfmt = (d, p = 2) => (d * 100).toFixed(p) + '%';

// ───────────────────────────────────────────────────────────
// Section shell
// ───────────────────────────────────────────────────────────
function Section({ id, label, eyebrow, title, subtitle, children }) {
  return (
    <section id={id} className="ds-section" data-screen-label={label || title}>
      <div className="sect-hd">
        {eyebrow && <div className="sect-eyebrow">{eyebrow}</div>}
        <h2 className="sect-title">{title}</h2>
        {subtitle && <div className="sect-sub">{subtitle}</div>}
      </div>
      <div className="sect-body">{children}</div>
    </section>);

}

// ───────────────────────────────────────────────────────────
// HERO — title, author, headline finding
// ───────────────────────────────────────────────────────────
function Hero() {
  const m = window.DASH.meta;
  return (
    <div className="hero">
      <div className="hero-l">
        <div className="hero-eyebrow">{m.institution} · {m.lab}</div>
        <h1 className="hero-title">{m.title}</h1>
        <div className="hero-sub">{m.subtitle}</div>
        <div className="hero-meta">
          <div><span>Συγγραφέας</span><b>{m.author}</b></div>
          <div><span>Επιβλέπων</span><b>{m.supervisor}</b></div>
          <div><span>Seed</span><b className="mono">{m.seed}</b></div>
        </div>
      </div>
      <div className="hero-r">
        <div className="hero-kicker">Βασικά ευρήματα — Stage 8 (paired bootstrap)</div>
        <div className="hero-metric-stack">
          <div className="hero-metric">
            <div className="hero-metric-l">ΔOA</div>
            <div className="hero-metric-v mono">+10.61<span className="hero-metric-u">pp</span></div>
            <div className="hero-metric-ci mono">CI [+9.0, +12.2]</div>
          </div>
          <div className="hero-metric">
            <div className="hero-metric-l">ΔMacro-F1</div>
            <div className="hero-metric-v mono">+10.29<span className="hero-metric-u">pp</span></div>
            <div className="hero-metric-ci mono">CI [+8.7, +11.9]</div>
          </div>
          <div className="hero-metric">
            <div className="hero-metric-l">ΔKappa</div>
            <div className="hero-metric-v mono">+10.79<span className="hero-metric-u">pp</span></div>
            <div className="hero-metric-ci mono">CI [+9.0, +12.6]</div>
          </div>
        </div>
        <div className="hero-pills">
          <span className="hero-pill">7-Band ≳ RGB σε όλες τις metrics</span>
          <span className="hero-pill">McNemar p = 8.6 × 10⁻⁴⁰</span>
          <span className="hero-pill">B = 10,000 bootstrap</span>
        </div>
      </div>
    </div>);

}

// ───────────────────────────────────────────────────────────
// KPI strip — four headline numbers
// ───────────────────────────────────────────────────────────
function KPIs() {
  const D = window.DASH;
  const m7 = D.models.sevenBand;
  const mR = D.models.rgb;
  const m2_7 = D.results.find((r) => r.method === 'M2' && r.model === '7B');
  const m2_R = D.results.find((r) => r.method === 'M2' && r.model === 'RGB');
  const items = [
  { label: 'Best validation loss', v7: m7.bestValLoss.toFixed(4), vR: mR.bestValLoss.toFixed(4), delta: '−' + ((mR.bestValLoss - m7.bestValLoss) / mR.bestValLoss * 100).toFixed(1) + '%' },
  { label: 'M2 PyTorch · OA', v7: pctfmt(m2_7.oa), vR: pctfmt(m2_R.oa), delta: '+' + ((m2_7.oa - m2_R.oa) * 100).toFixed(2) + ' pp' },
  { label: 'M2 PyTorch · Macro-F1', v7: pctfmt(m2_7.mf1), vR: pctfmt(m2_R.mf1), delta: '+' + ((m2_7.mf1 - m2_R.mf1) * 100).toFixed(2) + ' pp' },
  { label: 'M2 PyTorch · mIoU', v7: pctfmt(m2_7.miou), vR: pctfmt(m2_R.miou), delta: '+' + ((m2_7.miou - m2_R.miou) * 100).toFixed(2) + ' pp' }];

  return (
    <div className="kpi-row">
      {items.map((it) =>
      <div className="kpi-card" key={it.label}>
          <div className="kpi-lbl">{it.label}</div>
          <div className="kpi-pair">
            <div className="kpi-half">
              <div className="kpi-tag" style={{ background: C7B }}>7-Band</div>
              <div className="kpi-num mono">{it.v7}</div>
            </div>
            <div className="kpi-half kpi-rgb-half">
              <div className="kpi-tag" style={{ background: CRGB }}>RGB</div>
              <div className="kpi-num mono">{it.vR}</div>
            </div>
          </div>
          <div className="kpi-delta mono"><span>Δ</span>{it.delta}</div>
        </div>
      )}
    </div>);

}

// ───────────────────────────────────────────────────────────
// MODEL CARDS — side by side, with link to loss curves
// ───────────────────────────────────────────────────────────
function ModelCards() {
  const D = window.DASH;
  return (
    <div className="model-cards">
      {[D.models.sevenBand, D.models.rgb].map((m, i) => {
        const c = i === 0 ? C7B : CRGB;
        return (
          <div className="model-card" key={m.id} style={{ borderTopColor: c }}>
            <div className="m-hd">
              <div className="m-pill mono" style={{ background: c }}>{m.label}</div>
              <div className="m-arch">{m.arch}</div>
            </div>
            <div className="m-bands-section">
              <div className="m-bands-lbl">{m.bandCount} input bands</div>
              <div className="m-bands-chips">
                {m.bands.map((b) => <span key={b} className="m-band-chip mono">{b}</span>)}
              </div>
            </div>
            <dl className="m-stats">
              <dt>Backbone</dt><dd className="mono">{m.backbone}</dd>
              <dt>Learning rate</dt><dd className="mono">{m.learningRate}</dd>
              <dt>Epochs</dt><dd className="mono">{m.epochs}</dd>
              <dt>Best val loss</dt><dd className="mono">{m.bestValLoss.toFixed(4)} @ epoch {m.bestEpoch}</dd>
              <dt>EMD accuracy</dt><dd className="mono">{pctfmt(m.finalAccuracy, 2)}</dd>
            </dl>
            <a className="m-link" href={m.lossCurvesHref}>View training loss curves →</a>
          </div>);

      })}
    </div>);

}

// ───────────────────────────────────────────────────────────
// GT class distribution — donut chart with interactive legend
// ───────────────────────────────────────────────────────────
function ClassDistribution() {
  const D = window.DASH;
  const dist = D.classDistribution;
  const colors = D.meta.classColors;
  const total = dist.reduce((s, d) => s + d.pixels, 0);

  const [hover, setHover] = useState(null);
  const active = hover ? dist.find((d) => d.cls === hover) : null;

  // Donut geometry
  const W = 320,H = 320;
  const cx = W / 2,cy = H / 2;
  const rOuter = 130,rInner = 72;

  let cum = 0;
  const slices = dist.map((d) => {
    const a0 = cum / total * Math.PI * 2 - Math.PI / 2;
    cum += d.pixels;
    const a1 = cum / total * Math.PI * 2 - Math.PI / 2;
    const large = a1 - a0 > Math.PI ? 1 : 0;
    const x0 = cx + rOuter * Math.cos(a0),y0 = cy + rOuter * Math.sin(a0);
    const x1 = cx + rOuter * Math.cos(a1),y1 = cy + rOuter * Math.sin(a1);
    const ix0 = cx + rInner * Math.cos(a0),iy0 = cy + rInner * Math.sin(a0);
    const ix1 = cx + rInner * Math.cos(a1),iy1 = cy + rInner * Math.sin(a1);
    const path = `M ${x0} ${y0} A ${rOuter} ${rOuter} 0 ${large} 1 ${x1} ${y1} L ${ix1} ${iy1} A ${rInner} ${rInner} 0 ${large} 0 ${ix0} ${iy0} Z`;
    const mid = (a0 + a1) / 2;
    const labelR = (rOuter + rInner) / 2;
    return {
      ...d,
      path,
      color: colors[d.cls],
      labelX: cx + labelR * Math.cos(mid),
      labelY: cy + labelR * Math.sin(mid)
    };
  });

  return (
    <div className="dist-card">
      <div className="dist-hd">
        <div>
          <div className="kicker">Ground-truth raster</div>
          <div className="dist-title">Class distribution</div>
        </div>
        <div className="dist-total mono">
          <span>Σύνολο</span>
          <b>{total.toLocaleString()} px</b>
        </div>
      </div>

      <div className="dist-donut-wrap">
        <div className="dist-donut">
          <svg viewBox={`0 0 ${W} ${H}`} className="dist-donut-svg">
            {slices.map((s) =>
            <path key={s.cls}
            d={s.path}
            fill={s.color}
            stroke="var(--panel)"
            strokeWidth="2"
            onMouseEnter={() => setHover(s.cls)}
            onMouseLeave={() => setHover(null)}
            style={{
              cursor: 'pointer',
              opacity: hover && hover !== s.cls ? 0.35 : 1,
              transition: 'opacity 0.15s ease'
            }} />
            )}
            {/* In-slice percent labels for slices ≥ 4% */}
            {slices.filter((s) => s.pct >= 4).map((s) =>
            <text key={'l-' + s.cls}
            x={s.labelX} y={s.labelY + 4}
            textAnchor="middle"
            className="donut-slice-label"
            style={{ pointerEvents: 'none' }}>
                {s.pct.toFixed(1) + '%'}
              </text>
            )}
            {/* Center text */}
            <text x={cx} y={cy - 8} textAnchor="middle" className="donut-center-l">
              {active ? active.cls : '7 classes'}
            </text>
            <text x={cx} y={cy + 14} textAnchor="middle" className="donut-center-v">
              {active ? active.pct.toFixed(2) + '%' : total.toLocaleString()}
            </text>
            <text x={cx} y={cy + 30} textAnchor="middle" className="donut-center-s">
              {active ? active.pixels.toLocaleString() + ' px' : 'GT pixels'}
            </text>
          </svg>
        </div>

        <div className="dist-legend">
          {dist.map((d) =>
          <button key={d.cls}
          className={'dist-leg-row' + (hover === d.cls ? ' on' : '')}
          onMouseEnter={() => setHover(d.cls)}
          onMouseLeave={() => setHover(null)}>
              <span className="dist-leg-dot" style={{ background: colors[d.cls] }} />
              <span className="dist-leg-cls">{d.cls}</span>
              <span className="dist-leg-pct mono">{d.pct.toFixed(2)}%</span>
              <span className="dist-leg-px mono">{d.pixels.toLocaleString()}</span>
            </button>
          )}
        </div>
      </div>

      <div className="dist-caption">
        Έντονη class imbalance: <b>Bare Soil 54.87%</b>, <b>Vehicle μόνο 0.80%</b>.
        Γι&apos; αυτό η Macro-F1 προτιμάται έναντι OA — δίνει ίδιο βάρος σε όλες τις κλάσεις,
        ανεξάρτητα από το pixel share.
      </div>
    </div>);

}

// ───────────────────────────────────────────────────────────
// METHOD DESCRIPTION CARDS — M1..M4
// ───────────────────────────────────────────────────────────
function MethodCards() {
  return (
    <div className="meth-grid">
      {window.DASH.methods.map((m) =>
      <div className="meth-card" key={m.id}>
          <div className="meth-id mono">{m.id}</div>
          <div className="meth-name">{m.name}</div>
          <div className="meth-short">{m.shortDesc}</div>
          <p className="meth-desc">{m.desc}</p>
        </div>
      )}
    </div>);

}

// ───────────────────────────────────────────────────────────
// GLOBAL RESULTS — methods × metrics × models
// ───────────────────────────────────────────────────────────
function GlobalResults() {
  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' }];

  const best = {};
  metrics.forEach((m) => {
    best[m.id] = {
      '7B': Math.max(...D.results.filter((r) => r.model === '7B' && r[m.id] != null).map((r) => r[m.id])),
      'RGB': Math.max(...D.results.filter((r) => r.model === 'RGB' && r[m.id] != null).map((r) => r[m.id]))
    };
  });
  return (
    <div>
      <table className="results-table">
        <thead>
          <tr className="grp-row">
            <th rowSpan="2">Method</th>
            {metrics.map((m) => <th key={m.id} colSpan="2">{m.label}</th>)}
          </tr>
          <tr>
            {metrics.map((m) =>
            <React.Fragment key={m.id}>
                <th className="th-7b">7B</th>
                <th className="th-rgb">RGB</th>
              </React.Fragment>
            )}
          </tr>
        </thead>
        <tbody>
          {methods.map((mid) => {
            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 meth = D.methods.find((m) => m.id === mid);
            return (
              <tr key={mid}>
                <td className="meth-cell">
                  <b className="mono">{mid}</b>
                  <span className="meth-cell-name">{meth.shortDesc}</span>
                </td>
                {metrics.map((m) => {
                  const v7 = r7[m.id],vR = rR[m.id];
                  const b7 = v7 === best[m.id]['7B'];
                  const bR = vR === best[m.id]['RGB'];
                  return (
                    <React.Fragment key={m.id}>
                      <td className={'mono cell-7b' + (b7 ? ' best' : '')}>
                        {v7 == null ? '—' : v7.toFixed(4)}{b7 && <span className="star">★</span>}
                      </td>
                      <td className={'mono cell-rgb' + (bR ? ' best' : '')}>
                        {vR == null ? '—' : vR.toFixed(4)}{bR && <span className="star">★</span>}
                      </td>
                    </React.Fragment>);

                })}
              </tr>);

          })}
        </tbody>
      </table>
      <div className="callout">
        <b>★</b> = υψηλότερη τιμή ανά metric και μοντέλο. M1 δεν αναφέρει Kappa/mIoU
        (το ArcGIS internal validation loop δεν τα υπολογίζει). Το <b>M2 (PyTorch)</b>
        επιτυγχάνει το top score σε κάθε metric για κάθε μοντέλο.
      </div>
    </div>);

}

// ───────────────────────────────────────────────────────────
// METHOD-BY-METHOD BARS — visualise OA per method
// ───────────────────────────────────────────────────────────
function MethodBars() {
  const D = window.DASH;
  const methods = ['M1', 'M2', 'M3', 'M4'];
  return (
    <div className="mb-grid">
      {methods.map((mid) => {
        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 dl = ((r7.oa - rR.oa) * 100).toFixed(2);
        const meth = D.methods.find((m) => m.id === mid);
        return (
          <div className="mb-card" key={mid}>
            <div className="mb-hd">
              <span className="mb-tag mono">{mid}</span>
              <span className="mb-name">{meth.name}</span>
            </div>
            <div className="mb-bars">
              <div className="mb-bar-row">
                <span className="mb-l">7-Band</span>
                <div className="mb-track">
                  <div className="mb-bar" style={{ width: `${r7.oa * 100}%`, background: C7B }} />
                </div>
                <span className="mb-v mono">{pctfmt(r7.oa)}</span>
              </div>
              <div className="mb-bar-row">
                <span className="mb-l">RGB</span>
                <div className="mb-track">
                  <div className="mb-bar" style={{ width: `${rR.oa * 100}%`, background: CRGB }} />
                </div>
                <span className="mb-v mono">{pctfmt(rR.oa)}</span>
              </div>
            </div>
            <div className="mb-delta">
              <span>ΔOA</span>
              <b className="mono" style={{ color: CWIN }}>+{dl} pp</b>
            </div>
          </div>);

      })}
    </div>);

}

// ───────────────────────────────────────────────────────────
// PER-CLASS F1 — side-by-side bars (mean of M1..M4)
// ───────────────────────────────────────────────────────────
function PerClassF1() {
  const D = window.DASH;
  // sort by 7B F1 descending so columns align by class
  const sorted = D.meta.classes.slice().sort((a, b) =>
  D.meanPerClassF1['7B'][b] - D.meanPerClassF1['7B'][a]);
  return (
    <div className="pc-grid">
      {['7B', 'RGB'].map((mid) =>
      <div className="pc-col" key={mid}>
          <div className="pc-col-hd">
            <span className="pc-pill mono" style={{ background: mid === '7B' ? C7B : CRGB }}>
              {mid === '7B' ? '7-Band' : 'RGB'}
            </span>
            <span>Mean F1 across M1–M4</span>
          </div>
          {sorted.map((c) => {
          const v = D.meanPerClassF1[mid][c];
          return (
            <div className="pc-row" key={c}>
                <div className="pc-cls">{c}</div>
                <div className="pc-track">
                  <div className="pc-bar" style={{
                  width: `${v * 100}%`,
                  background: mid === '7B' ? C7B : CRGB
                }} />
                </div>
                <div className="pc-v mono">{v.toFixed(3)}</div>
              </div>);

        })}
        </div>
      )}
    </div>);

}

// ───────────────────────────────────────────────────────────
// DELTA CHART — per-class F1 advantage of 7-Band over RGB
// ───────────────────────────────────────────────────────────
function DeltaChart() {
  const D = window.DASH;
  const max = Math.max(...D.delta.map((d) => d.delta));
  return (
    <div className="delta-card">
      <div className="delta-bars">
        {D.delta.map((d) =>
        <div className="delta-row" key={d.cls}>
            <div className="delta-cls">{d.cls}</div>
            <div className="delta-track">
              <div className="delta-bar" style={{
              width: `${d.delta / max * 100}%`,
              background: CWIN
            }} />
            </div>
            <div className="delta-v mono">+{(d.delta * 100).toFixed(1)} pp</div>
            <div className="delta-ctx mono">
              <span style={{ color: C7B }}>{d.sevenB.toFixed(3)}</span>
              <span className="dim"> vs </span>
              <span style={{ color: CRGB }}>{d.rgb.toFixed(3)}</span>
            </div>
          </div>
        )}
      </div>
      <div className="callout">
        <b>Shadow-Noise</b> και <b>Vehicle</b> κερδίζουν 16–20 pp.
        Αυτές είναι ακριβώς οι κλάσεις όπου το <b>nDSM</b> (γεωμετρική) και το <b>Thermal</b>
        band λύνουν structural ambiguities που το RGB δεν μπορεί να χειριστεί.
      </div>
    </div>);

}

// ───────────────────────────────────────────────────────────
// CONFUSION MATRIX — interactive (model × method)
// ───────────────────────────────────────────────────────────
function ConfusionMatrixSection() {
  const D = window.DASH;
  const [model, setModel] = useState('7B');
  const [method, setMethod] = useState('M2');
  const cm = D.cms[model][method];
  return (
    <div className="cm-section">
      <div className="cm-controls">
        <div className="cm-ctrl-grp">
          <span className="cm-ctrl-l">Model</span>
          <div className="seg">
            {['7B', 'RGB'].map((m) =>
            <button key={m}
            className={'seg-b' + (model === m ? ' on' : '')}
            style={model === m ? { background: m === '7B' ? C7B : CRGB } : {}}
            onClick={() => setModel(m)}>
                {m === '7B' ? '7-Band' : 'RGB'}
              </button>
            )}
          </div>
        </div>
        <div className="cm-ctrl-grp">
          <span className="cm-ctrl-l">Method</span>
          <div className="seg">
            {['M2', 'M3', 'M4'].map((m) =>
            <button key={m}
            className={'seg-b' + (method === m ? ' on' : '')}
            onClick={() => setMethod(m)}>
                {m}
              </button>
            )}
          </div>
        </div>
      </div>
      <CMGrid cm={cm} />
      <div className="cm-legend">
        <span><span className="sw" style={{ background: C_DIAG }} />Diagonal · recall</span>
        <span><span className="sw" style={{ background: CERR }} />Off-diagonal · confusion</span>
        <span><span className="sw sw-zero" />{'< 0.005'}</span>
      </div>
      <div className="callout">
        Key pattern: στο RGB, η κλάση <b>Vehicle</b> συγχέεται με Road σε 17–24% των cases
        και η <b>Shadow-Noise</b> με Bare Soil σε 18–29%. Και τα δύο confusions
        μειώνονται δραματικά στο 7-Band χάρη στα <b>nDSM</b> και <b>Thermal</b>.
      </div>
    </div>);

}

function CMGrid({ cm }) {
  const D = window.DASH;
  const labels = D.meta.classesShort;
  const full = D.meta.classes;
  return (
    <div className="cm-grid-wrap">
      <table className="cm-grid">
        <thead>
          <tr>
            <th className="cm-corner"></th>
            <th colSpan={7} className="cm-axis-h">Prediction</th>
          </tr>
          <tr>
            <th className="cm-axis-v"><div>Ground truth</div></th>
            {labels.map((l, i) => <th key={i} title={full[i]} className="cm-collab">{l}</th>)}
          </tr>
        </thead>
        <tbody>
          {cm.map((row, r) =>
          <tr key={r}>
              <th title={full[r]} className="cm-rowlab">{labels[r]}</th>
              {row.map((v, c) => {
              const isDiag = r === c;
              const zero = v < 0.005;
              const bg = zero ? '#fff' :
              isDiag ? `oklch(48% 0.13 145 / ${0.18 + v * 0.78})` :
              `oklch(55% 0.20 25 / ${0.10 + v * 0.85})`;
              const fg = isDiag && v > 0.55 || !isDiag && v > 0.5 ? '#fff' : 'var(--ink)';
              return (
                <td key={c}
                className={'cm-cell' + (isDiag ? ' cm-diag' : '') + (zero ? ' cm-zero' : '')}
                style={{ background: bg, color: fg }}>
                    {zero ? '·' : v.toFixed(2)}
                  </td>);

            })}
            </tr>
          )}
        </tbody>
      </table>
    </div>);

}

// ───────────────────────────────────────────────────────────
// MCNEMAR CONTINGENCY — 2x2 table + theory + analysis
// ───────────────────────────────────────────────────────────
function McNemarContingency() {
  const m = window.DASH.significance.mcnemar;
  const total = m.a + m.b + m.c + m.d;
  const pctOf = (n) => (n / total * 100).toFixed(1) + '%';
  return (
    <div>
      <div className="theory-block">
        <div className="theory-title">Θεωρία — McNemar exact test (paired)</div>
        <div className="theory-body">
          <p>
            Όταν δύο classifiers αξιολογούνται στο <b>ίδιο</b> sample, η πληροφορία για το ποιο
            είναι καλύτερο βρίσκεται μόνο στα <b>discordant pairs</b> (b και c) — τα σημεία
            όπου τα μοντέλα διαφωνούν. Tα concordant pairs (a και d) δεν συμβάλλουν.
          </p>
          <div className="theory-hypotheses">
            <div className="theory-h0"><b>H₀</b>: τα δύο μοντέλα έχουν ίδιο error rate. Aν διαφωνήσουν,
              η πιθανότητα το 7-Band να είναι σωστό = 0.5 → <b>b ~ Binomial(b+c, 0.5)</b>.</div>
            <div className="theory-ha"><b>Hₐ</b>: το ένα μοντέλο είναι πραγματικά καλύτερο
              → b και c θα είναι ασύμμετρα.</div>
            <div className="theory-decision">
              <b>Decision rule</b>: αν p-value &lt; 0.05 → reject H₀.
              Υπό H₀ θα περιμέναμε b ≈ (b+c)/2 = {(m.nDiscordant / 2).toFixed(1)}.
              Παρατηρούμε b = <b>{m.b}</b> — τόσο μακριά από το κέντρο που η πιθανότητα γίνεται 10⁻⁴⁰.
            </div>
          </div>
        </div>
      </div>
      <div className="mcn-card">
      <div className="mcn-h">
        <div>
          <div className="kicker">M4 stratified sample · n = 2,100</div>
          <div className="mcn-title">McNemar 2×2 contingency</div>
        </div>
        <div className="mcn-pvalue">
          <span>p-value (exact, two-sided)</span>
          <b className="mono" style={{ color: CWIN }}>8.62 × 10⁻⁴⁰</b>
        </div>
      </div>
      <div className="mcn-grid">
        <div></div>
        <div className="mcn-coltitle">RGB ✓ correct</div>
        <div className="mcn-coltitle">RGB ✗ wrong</div>

        <div className="mcn-rowtitle">7-Band ✓ correct</div>
        <div className="mcn-cell mcn-a">
          <div className="mcn-tag">a · both correct</div>
          <div className="mcn-n mono">{m.a.toLocaleString()}</div>
          <div className="mcn-pct mono">{pctOf(m.a)}</div>
        </div>
        <div className="mcn-cell mcn-b">
          <div className="mcn-tag" style={{ color: C7B }}>b · only 7-Band ✓</div>
          <div className="mcn-n mono">{m.b}</div>
          <div className="mcn-pct mono">{pctOf(m.b)}</div>
        </div>

        <div className="mcn-rowtitle">7-Band ✗ wrong</div>
        <div className="mcn-cell mcn-c">
          <div className="mcn-tag" style={{ color: CRGB }}>c · only RGB ✓</div>
          <div className="mcn-n mono">{m.c}</div>
          <div className="mcn-pct mono">{pctOf(m.c)}</div>
        </div>
        <div className="mcn-cell mcn-d">
          <div className="mcn-tag">d · both wrong</div>
          <div className="mcn-n mono">{m.d}</div>
          <div className="mcn-pct mono">{pctOf(m.d)}</div>
        </div>
      </div>
      <div className="mcn-stats">
        <div>
          <div className="mcn-stat-l">Discordant pairs</div>
          <div className="mcn-stat-v mono">{m.nDiscordant}</div>
        </div>
        <div>
          <div className="mcn-stat-l">Odds ratio b/c</div>
          <div className="mcn-stat-v big mono" style={{ color: CWIN }}>{m.oddsRatio.toFixed(2)}</div>
          <div className="mcn-stat-foot">Όταν διαφωνούν, το 7-Band έχει ~6× πιθανότητες να είναι σωστό</div>
        </div>
        <div>
          <div className="mcn-stat-l">Distance from null</div>
          <div className="mcn-stat-v big mono" style={{ color: CWIN }}>{m.zStdDev}σ</div>
          <div className="mcn-stat-foot">SDs πάνω από null expectation k≈156.5</div>
        </div>
      </div>
      </div>

      <div className="case-analysis">
        <div className="case-hd">Aνάλυση των τεσσάρων κελιών</div>
        <div className="case-grid">
          <div className="case-item">
            <div className="case-tag" style={{background: '#cbd5e1'}}>a · {m.a.toLocaleString()}</div>
            <p><b>Both correct.</b> Όταν ένα σημείο είναι "εύκολο", και τα δύο μοντέλα το πιάνουν.
            81% των σημείων είναι σε αυτή την κατηγορία — δεν συνεισφέρει στη σύγκριση.</p>
          </div>
          <div className="case-item">
            <div className="case-tag" style={{background: 'oklch(55% 0.13 250)', color: '#fff'}}>b · {m.b}</div>
            <p><b>Only 7-Band correct.</b> Aυτή είναι η ευνοϊκή ένδειξη για το 7-Band:
            <b> 268 σημεία</b> όπου τα extra bands (nDSM, Thermal, RedEdge, NIR) λύνουν
            μια ambiguity που το RGB δεν μπορούσε.</p>
          </div>
          <div className="case-item">
            <div className="case-tag" style={{background: 'oklch(70% 0.13 60)', color: '#fff'}}>c · {m.c}</div>
            <p><b>Only RGB correct.</b> Aντίστροφο σενάριο — μόλις <b>45 σημεία</b>.
            Πιθανότατα boundary noise από τα επιπλέον bands στο 7-Band σε αμφίσημες
            θέσεις (πχ buffer points δίπλα σε δέντρα).</p>
          </div>
          <div className="case-item">
            <div className="case-tag" style={{background: '#cbd5e1'}}>d · {m.d}</div>
            <p><b>Both wrong.</b> Aκόμα και τα 7 bands δεν φτάνουν για <b>83 σημεία</b>.
            Πιθανώς συστηματικά δύσκολα κελιά (mixed pixels, edges) ή ground-truth
            labelling errors.</p>
          </div>
        </div>
      </div>
    </div>);

}

// ───────────────────────────────────────────────────────────
// BOOTSTRAP — theory block + metric selector + single density chart
// ───────────────────────────────────────────────────────────
const BOOT_METRICS = {
  dOA: {
    id: 'dOA',
    label: 'ΔOverall Accuracy',
    short: 'ΔOA',
    color: 'oklch(55% 0.13 250)',
    desc7B: 'OA_7B = ποσοστό σωστών προβλέψεων του 7-Band στο stratified sample.',
    descRGB: 'OA_RGB = ποσοστό σωστών προβλέψεων του RGB στο ίδιο sample.',
    analysis: () => (
      <>
        <b>Aνάλυση ΔOA.</b> Mean = <b>+10.61 pp</b> με 95% CI [+9.0, +12.2]. Tο CI απέχει
        ~9 σ από το null Δ=0 — ουσιαστικά αδύνατο να προκύψει από τυχαία δειγματοληψία.
        Tι σημαίνει πρακτικά: σε <b>~10.6 από κάθε 100 pixels</b> του χάρτη, το 7-Band
        δίνει σωστή κλάση εκεί που το RGB αποτυγχάνει. Σε mapping job 1 km², αυτό
        αντιστοιχεί σε εκατοντάδες χιλιάδες σωστά classified pixels παραπάνω.
      </>
    ),
  },
  dKappa: {
    id: 'dKappa',
    label: 'ΔCohen’s Kappa',
    short: 'ΔKappa',
    color: 'oklch(60% 0.16 290)',
    desc7B: 'κ_7B = agreement μεταξύ 7-Band και ground-truth, διορθωμένο για chance.',
    descRGB: 'κ_RGB = αντίστοιχα για το RGB.',
    analysis: () => (
      <>
        <b>Aνάλυση ΔKappa.</b> Mean = <b>+10.79 pp</b> με 95% CI [+9.0, +12.6]. Tο Kappa
        διορθώνει για τη συμφωνία που θα προέκυπτε τυχαία (κρίσιμο σε imbalanced datasets
        όπου Bare Soil = 55% των pixels). Tο ότι το ΔKappa είναι πρακτικά ίδιο με το
        ΔOA σημαίνει ότι η υπεροχή του 7-Band <b>δεν προκύπτει από caching της κυρίαρχης
        κλάσης</b> — είναι αληθινή discriminative ικανότητα.
      </>
    ),
  },
  dMacroF1: {
    id: 'dMacroF1',
    label: 'ΔMacro-F1',
    short: 'ΔMacro-F1',
    color: 'oklch(52% 0.17 145)',
    desc7B: 'F1_7B = αρμονικός μέσος όρος Precision/Recall, ίδιο βάρος σε κάθε κλάση.',
    descRGB: 'F1_RGB = αντίστοιχα.',
    analysis: () => (
      <>
        <b>Aνάλυση ΔMacro-F1.</b> Mean = <b>+10.29 pp</b> με 95% CI [+8.7, +11.9].
        Η Macro-F1 αγνοεί το pixel share — Vehicle (0.80% των pixels) μετράει ίδιο
        με Bare Soil (55%). Το ότι το advantage διατηρείται και εδώ δείχνει ότι το
        7-Band <b>βελτιώνει και τις rare classes</b> (Vehicle, Shadow-Noise), όχι μόνο
        τα εύκολα background pixels.
      </>
    ),
  },
};

function BootstrapCard() {
  const b = window.DASH.significance.bootstrap;
  const [picked, setPicked] = useState('dOA');
  const meta = BOOT_METRICS[picked];
  const item = { ...meta, data: b[picked] };

  // CI bars on top — show all three so users can see the relative shape
  const allItems = [
    { ...BOOT_METRICS.dOA,     data: b.dOA },
    { ...BOOT_METRICS.dKappa,  data: b.dKappa },
    { ...BOOT_METRICS.dMacroF1, data: b.dMacroF1 },
  ];
  const maxR = 0.14;

  return (
    <div className="bs-card">

      {/* Theory block */}
      <div className="theory-block">
        <div className="theory-title">Θεωρία — Paired bootstrap</div>
        <div className="theory-body">
          <p>
            Σε κάθε replicate, παίρνουμε <b>2,100 σημεία με αντικατάσταση</b> διατηρώντας
            ζευγαρωμένα τα predictions των δύο μοντέλων (paired design). Υπολογίζουμε
            τη μετρική για το 7-Band και το RGB στο ίδιο replicate, και κρατάμε τη διαφορά:
          </p>
          <div className="theory-formula mono">
            Δ̂<sub>b</sub> = Metric(7-Band, replicate b) − Metric(RGB, replicate b)
          </div>
          <p>
            Επαναλαμβάνουμε B = 10,000 φορές. Το 95% percentile CI είναι το διάστημα
            [2.5%, 97.5%] των B τιμών. Αν αυτό <b>δεν περιέχει το 0</b>, απορρίπτουμε το
            null hypothesis ότι τα δύο μοντέλα είναι ισοδύναμα.
          </p>
          <div className="theory-hypotheses">
            <div className="theory-h0"><b>H₀</b>: Δ = 0 — τα δύο μοντέλα έχουν ίδια ακρίβεια.</div>
            <div className="theory-ha"><b>Hₐ</b>: Δ ≠ 0 — υπάρχει πραγματική διαφορά (two-sided).</div>
            <div className="theory-decision">
              <b>Decision rule</b>: αν 0 ∉ 95% CI → reject H₀ σε α = 0.05.
            </div>
          </div>
        </div>
      </div>

      {/* All three CI bars at once for context */}
      <div className="bs-rows">
        {allItems.map((it) => (
          <div className={'bs-row' + (it.id === picked ? ' bs-row-picked' : '')}
               key={it.id}
               onClick={() => setPicked(it.id)}
               style={{cursor: 'pointer'}}>
            <div className="bs-label">{it.label}</div>
            <CIBar data={it.data} maxR={maxR} />
            <div className="bs-num">
              <span className="bs-mean mono">+{(it.data.mean * 100).toFixed(2)} pp</span>
              <span className="bs-ci mono">CI [+{(it.data.ciLo * 100).toFixed(1)}, +{(it.data.ciHi * 100).toFixed(1)}]</span>
            </div>
          </div>
        ))}
      </div>
      <div className="bs-axis">
        <span className="mono bs-null">▲ null Δ=0</span>
        <div className="bs-axis-line" />
        <div className="bs-axis-ticks">
          <span>0</span><span>+5 pp</span><span>+10 pp</span><span>+14 pp</span>
        </div>
      </div>

      {/* Metric selector for the detailed density chart */}
      <div className="bs-picker">
        <span className="bs-picker-l">Density chart</span>
        <div className="seg">
          {Object.keys(BOOT_METRICS).map((k) => (
            <button key={k}
                    className={'seg-b' + (picked === k ? ' on' : '')}
                    style={picked === k ? { background: BOOT_METRICS[k].color, color: '#fff' } : {}}
                    onClick={() => setPicked(k)}>
              {BOOT_METRICS[k].short}
            </button>
          ))}
        </div>
      </div>

      <BootstrapDistribution item={item} />

      {/* Per-metric analysis text */}
      <div className="callout">
        {meta.analysis()}
      </div>
    </div>
  );
}

function CIBar({ data, maxR }) {
  const scale = (v) => v / maxR * 100;
  return (
    <div className="ci-bar-track">
      <div className="ci-zero-line" />
      <div className="ci-bar" style={{
        left: `${scale(data.ciLo)}%`,
        width: `${scale(data.ciHi - data.ciLo)}%`
      }} />
      <div className="ci-mean" style={{ left: `calc(${scale(data.mean)}% - 1px)` }} />
    </div>);

}

// ───────────────────────────────────────────────────────────
// BOOTSTRAP DISTRIBUTION — single density curve for the selected metric
// ───────────────────────────────────────────────────────────
function BootstrapDistribution({ item }) {
  const items = [item];   // reuse the multi-panel layout for one item
  const [hover, setHover] = useState(null);
  const svgRef = React.useRef(null);

  const W = 760,panelH = 100,gap = 14;
  const M = { t: 12, r: 24, b: 64, l: 96 };
  const H = items.length * panelH + (items.length - 1) * gap + M.t + M.b;
  const iw = W - M.l - M.r;

  const xMin = -0.01,xMax = 0.14;
  const sx = (v) => M.l + (v - xMin) / (xMax - xMin) * iw;
  const sxInv = (px) => xMin + (px - M.l) / iw * (xMax - xMin);

  const ticks = [];
  for (let pp = 0; pp <= 14; pp += 2) ticks.push(pp / 100);

  const N = 240;
  const dx = (xMax - xMin) / N;

  const onMove = (e) => {
    const rect = svgRef.current.getBoundingClientRect();
    const scaleX = W / rect.width;
    const scaleY = H / rect.height;
    const px = (e.clientX - rect.left) * scaleX;
    const py = (e.clientY - rect.top) * scaleY;
    if (px < M.l || px > M.l + iw) {setHover(null);return;}
    let panelIdx = -1;
    for (let i = 0; i < items.length; i++) {
      const top = i * (panelH + gap) + M.t;
      if (py >= top && py <= top + panelH) {panelIdx = i;break;}
    }
    setHover({ panelIdx, xData: sxInv(px) });
  };

  return (
    <div className="bsd-wrap">
      <div className="bsd-hd">
        <div className="kicker">Bootstrap density (Gaussian approx · B = 10,000)</div>
        <div className="bsd-legend">
          <span className="bsd-leg-i"><span className="bsd-leg-sw bsd-leg-sw-ci" />95% CI region</span>
          <span className="bsd-leg-i"><span className="bsd-leg-sw bsd-leg-sw-tail" />Outside CI</span>
          <span className="bsd-leg-i"><span className="bsd-leg-sw bsd-leg-sw-mean" />Mean</span>
          <span className="bsd-leg-i"><span className="bsd-leg-sw bsd-leg-sw-null" />Null Δ=0</span>
        </div>
      </div>
      <svg ref={svgRef} viewBox={`0 0 ${W} ${H}`} className="bsd-svg"
      onMouseMove={onMove} onMouseLeave={() => setHover(null)}>
        <defs>
          {items.map((it, idx) =>
          <clipPath key={'cl' + idx} id={`bsd-ci-clip-${idx}`}>
              <rect
              x={sx(it.data.ciLo)}
              y={idx * (panelH + gap) + M.t}
              width={sx(it.data.ciHi) - sx(it.data.ciLo)}
              height={panelH} />
            </clipPath>
          )}
        </defs>

        {items.map((it, idx) => {
          const top = idx * (panelH + gap) + M.t;
          const mu = it.data.mean;
          const sigma = it.data.se;
          const yMaxAtMean = 1 / (sigma * Math.sqrt(2 * Math.PI));
          const yMax = yMaxAtMean * 1.15;
          const sy = (v) => top + (1 - v / yMax) * panelH;

          const points = [];
          for (let i = 0; i <= N; i++) {
            const x = xMin + i * dx;
            const z = (x - mu) / sigma;
            const f = Math.exp(-0.5 * z * z) / (sigma * Math.sqrt(2 * Math.PI));
            points.push([sx(x), sy(f)]);
          }
          const pathD = 'M ' + points.map(([x, y]) => `${x.toFixed(1)} ${y.toFixed(1)}`).join(' L ');
          const baseY = top + panelH;
          const areaD = pathD + ` L ${sx(xMax).toFixed(1)} ${baseY.toFixed(1)} L ${sx(xMin).toFixed(1)} ${baseY.toFixed(1)} Z`;

          const isHoverHere = hover && hover.panelIdx === idx;
          let hoverDensity = null;
          if (isHoverHere) {
            const z = (hover.xData - mu) / sigma;
            hoverDensity = Math.exp(-0.5 * z * z) / (sigma * Math.sqrt(2 * Math.PI));
          }

          return (
            <g key={it.id}>
              <text x={M.l - 14} y={top + panelH / 2 - 4} textAnchor="end" className="bsd-label">{it.short}</text>
              <text x={M.l - 14} y={top + panelH / 2 + 12} textAnchor="end" className="bsd-label-sub mono">
                μ = +{(mu * 100).toFixed(2)} pp
              </text>
              <rect x={M.l} y={top} width={iw} height={panelH} fill="var(--bg)" rx="3" opacity="0.5" />
              <path d={areaD} fill={it.color} opacity="0.20" />
              <path d={areaD} fill={it.color} opacity="0.75" clipPath={`url(#bsd-ci-clip-${idx})`} />
              <path d={pathD} fill="none" stroke={it.color} strokeWidth="1.8" />
              <line x1={M.l} y1={baseY} x2={M.l + iw} y2={baseY} stroke="var(--ink)" strokeWidth="1" />
              <line x1={sx(0)} y1={top} x2={sx(0)} y2={baseY}
              stroke="oklch(55% 0.20 25)" strokeWidth="1.8" strokeDasharray="3 3" opacity="0.85" />
              <line x1={sx(mu)} y1={top - 4} x2={sx(mu)} y2={baseY}
              stroke="oklch(35% 0.13 145)" strokeWidth="2" />
              <line x1={sx(it.data.ciLo)} y1={baseY + 2} x2={sx(it.data.ciHi)} y2={baseY + 2}
              stroke="oklch(35% 0.13 145)" strokeWidth="2.5" />
              <line x1={sx(it.data.ciLo)} y1={baseY - 2} x2={sx(it.data.ciLo)} y2={baseY + 6}
              stroke="oklch(35% 0.13 145)" strokeWidth="2" />
              <line x1={sx(it.data.ciHi)} y1={baseY - 2} x2={sx(it.data.ciHi)} y2={baseY + 6}
              stroke="oklch(35% 0.13 145)" strokeWidth="2" />
              <text x={sx(it.data.ciLo)} y={baseY + 18} textAnchor="middle" className="bsd-ci-label mono">
                +{(it.data.ciLo * 100).toFixed(1)}
              </text>
              <text x={sx(it.data.ciHi)} y={baseY + 18} textAnchor="middle" className="bsd-ci-label mono">
                +{(it.data.ciHi * 100).toFixed(1)}
              </text>
              {isHoverHere &&
              <g>
                  <line x1={sx(hover.xData)} y1={top} x2={sx(hover.xData)} y2={baseY}
                stroke="var(--ink)" strokeWidth="1" strokeDasharray="2 2" opacity="0.5" />
                  <circle cx={sx(hover.xData)} cy={sy(hoverDensity)} r="3.5"
                fill={it.color} stroke="var(--panel)" strokeWidth="1.5" />
                  {(() => {
                  const xR = sx(hover.xData);
                  const placeRight = xR < M.l + iw - 110;
                  const labX = placeRight ? xR + 8 : xR - 8;
                  const labAnchor = placeRight ? 'start' : 'end';
                  return (
                    <g>
                        <rect x={placeRight ? labX : labX - 100} y={top + 4}
                      width="100" height="30" rx="4"
                      fill="var(--panel)" stroke={it.color} strokeWidth="1" />
                        <text x={labX + (placeRight ? 6 : -6)} y={top + 16}
                      textAnchor={labAnchor} className="bsd-hover-l">
                          x = {hover.xData >= 0 ? '+' : ''}{(hover.xData * 100).toFixed(2)} pp
                        </text>
                        <text x={labX + (placeRight ? 6 : -6)} y={top + 28}
                      textAnchor={labAnchor} className="bsd-hover-v mono">
                          density = {hoverDensity.toFixed(2)}
                        </text>
                      </g>);

                })()}
                </g>
              }
            </g>);

        })}

        {ticks.map((t) =>
        <g key={'tk' + t}>
            <line x1={sx(t)} x2={sx(t)}
          y1={H - M.b + 24} y2={H - M.b + 28}
          stroke="var(--ink-2)" strokeWidth="1" />
            <text x={sx(t)} y={H - M.b + 42} textAnchor="middle" className="bsd-tick mono">
              {t === 0 ? '0' : '+' + (t * 100).toFixed(0)}
            </text>
          </g>
        )}
        <text x={M.l + iw / 2} y={H - 8} textAnchor="middle" className="bsd-axtitle">
          Δ metric (percentage points)
        </text>
      </svg>
    </div>);

}

// ───────────────────────────────────────────────────────────
// PER-CLASS MCNEMAR table with Holm correction
// ───────────────────────────────────────────────────────────
function PerClassMcNemar() {
  const rows = window.DASH.significance.perClass;
  return (
    <div>
      <table className="pcm-table">
        <thead>
          <tr>
            <th>Class</th>
            <th>n</th>
            <th title="both correct">a</th>
            <th title="only 7-Band correct"><span className="pill-7b-sm">b · 7B</span></th>
            <th title="only RGB correct"><span className="pill-rgb-sm">c · RGB</span></th>
            <th title="both wrong">d</th>
            <th>Odds ratio</th>
            <th>p<sub>Holm</sub></th>
            <th>Sig.</th>
            <th>Driver</th>
          </tr>
        </thead>
        <tbody>
          {rows.map((r) =>
          <tr key={r.cls} className={r.sig === '***' ? 'pcm-sig' : ''}>
              <td><b>{r.cls}</b></td>
              <td className="mono dim">300</td>
              <td className="mono dim">{r.a}</td>
              <td className="mono" style={{ color: r.b > r.c ? C7B : 'inherit', fontWeight: r.b > r.c ? 600 : 400 }}>{r.b}</td>
              <td className="mono" style={{ color: r.c > r.b ? CRGB : 'inherit', fontWeight: r.c > r.b ? 600 : 400 }}>{r.c}</td>
              <td className="mono dim">{r.d}</td>
              <td className="mono">{r.oddsRatio === Infinity ? '∞' : r.oddsRatio.toFixed(2)}</td>
              <td className="mono">{r.pHolm < 1e-3 ? r.pHolm.toExponential(1) : r.pHolm.toFixed(3)}</td>
              <td><span className={'sig-cell sig-' + (r.sig === '***' ? 'yes' : 'no')}>{r.sig === '***' ? '✱✱✱' : 'n.s.'}</span></td>
              <td className="pcm-driver">{r.driver}</td>
            </tr>
          )}
        </tbody>
      </table>
      <div className="callout">
        Holm-Bonferroni correction για 7 simultaneous tests (FWER α = 0.05).
        <b> 3/7 κλάσεις σημαντικές </b>: Building, Vehicle, Shadow-Noise.
        <b> Tree</b> και <b>Grass</b> ξεπερνούν την unadjusted rejection region αλλά
        αποτυγχάνουν στο Holm — προστασία από false discoveries.
      </div>
    </div>);

}

// ───────────────────────────────────────────────────────────
// CONVERGENT VALIDITY — 5 independent tests, all agree
// ───────────────────────────────────────────────────────────
function ConvergentValidity() {
  return (
    <div>
      <table className="conv-table">
        <thead>
          <tr><th>Test</th><th>Result</th><th>Decision</th></tr>
        </thead>
        <tbody>
          {window.DASH.significance.convergent.map((c, i) =>
          <tr key={i}>
              <td>{c.test}</td>
              <td className="mono">{c.result}</td>
              <td className="conv-yes mono">{c.decision}</td>
            </tr>
          )}
        </tbody>
      </table>
      <div className="callout conv-callout">
        Πέντε ανεξάρτητα tests — frequentist exact, asymptotic Z, και resampling-based —
        συμφωνούν στην ίδια κατεύθυνση. Αυτή είναι ισχυρή <b>convergent validity</b>
        που δίνει στη σύγκριση συμπέρασμα που δεν μπορεί να αμφισβητηθεί.
      </div>
    </div>);

}

// ───────────────────────────────────────────────────────────
// FINDINGS cards — narrative takeaways
// ───────────────────────────────────────────────────────────
function FindingsCards() {
  return (
    <div className="find-grid">
      {window.DASH.findings.map((f) =>
      <div className="find-card" key={f.id}>
          <div className="find-num mono">{f.id}</div>
          <h3 className="find-title">{f.title}</h3>
          <p className="find-body">{f.body}</p>
          <ul className="find-stats">
            {f.stats.map((s, i) =>
          <li key={i}><span>{s.k}</span><b className="mono">{s.v}</b></li>
          )}
          </ul>
        </div>
      )}
    </div>);

}

// ───────────────────────────────────────────────────────────
// PIPELINE — link to full SVG with thumbnail
// ───────────────────────────────────────────────────────────
function PipelineDiagram() {
  return (
    <div className="pipe-card">
      <div className="pipe-info">
        <div>
          <div className="kicker">Evaluation pipeline</div>
          <div className="pipe-title">7 stages · 4 methodologies · 2 models</div>
        </div>
        <a className="pipe-btn" href="dashboard/assets/evaluation_pipeline.svg" target="_blank" rel="noopener">
          Open full diagram (SVG) →
        </a>
      </div>
      <div className="pipe-preview">
        <object data="dashboard/assets/evaluation_pipeline.svg" type="image/svg+xml" aria-label="Evaluation pipeline diagram" />
      </div>
    </div>);

}

// ───────────────────────────────────────────────────────────
// PROJECT INFO footer block
// ───────────────────────────────────────────────────────────
function ProjectInfo() {
  const m = window.DASH.meta;
  const items = [
  { k: 'Author', v: m.author },
  { k: 'Supervisor', v: m.supervisor },
  { k: 'Institution', v: m.institution },
  { k: 'Lab', v: m.lab },
  { k: 'Architecture', v: 'DeepLabV3 + PointRend (ResNet-101)', mono: true },
  { k: 'Seed', v: m.seed, mono: true },
  { k: 'CRS', v: m.crs, mono: true },
  { k: 'Cell size', v: m.cellSize, mono: true },
  { k: 'Raster dims', v: m.rasterDims, mono: true },
  { k: 'GT valid pixels', v: m.validPixels.toLocaleString(), mono: true }];

  return (
    <div className="proj-grid">
      {items.map((it) =>
      <div className="proj-row" key={it.k}>
          <span className="proj-k">{it.k}</span>
          <b className={'proj-v' + (it.mono ? ' mono' : '')}>{it.v}</b>
        </div>
      )}
    </div>);

}

// Export everything onto window so app.jsx can pick them up.
Object.assign(window, {
  DSection: Section,
  DHero: Hero,
  DKPIs: KPIs,
  DModelCards: ModelCards,
  DClassDistribution: ClassDistribution,
  DMethodCards: MethodCards,
  DGlobalResults: GlobalResults,
  DMethodBars: MethodBars,
  DPerClassF1: PerClassF1,
  DDeltaChart: DeltaChart,
  DConfusionMatrixSection: ConfusionMatrixSection,
  DMcNemarContingency: McNemarContingency,
  DBootstrapCard: BootstrapCard,
  DPerClassMcNemar: PerClassMcNemar,
  DConvergentValidity: ConvergentValidity,
  DFindingsCards: FindingsCards,
  DPipelineDiagram: PipelineDiagram,
  DProjectInfo: ProjectInfo
});