show_answer_2 = {
  // written into the card's slot, so the sliders are never re-inserted mid-drag
  const slot = settings_card.querySelector("#pm-answer-2")
  if (slot) slot.replaceChildren(answer)
  return answer
}

hist = {
  // which draws the histogram shows, and which of them the answer counts
  let all, lo, hi, mean, cut = null, cut_label = "", counted
  if (q === 5) {
    all = diff.draws; mean = diff.mean; lo = diff.lo; hi = diff.hi
    cut = threshold; cut_label = `Δ rate ${threshold} ml/hr`
    counted = all.filter(v => v > threshold)
  } else if (q === 3) {
    all = x_here.filter(v => v !== null); mean = inv.mean; lo = inv.lo; hi = inv.hi
    counted = all.filter(v => v >= lo && v <= hi)
  } else if (q === 4) {
    all = x_keep === null ? y_here : y_at(x_keep)
    mean = d3.mean(all); lo = d3.quantile(all, lo_q); hi = d3.quantile(all, hi_q)
    cut = limit; cut_label = `limit ${limit} ml/hr`
    counted = all.filter(v => v < limit)
  } else if (q === 2) {
    all = y_here; mean = pred.mean; lo = pred.lo; hi = pred.hi
    cut = limit; cut_label = `limit ${limit} ml/hr`
    counted = all.filter(v => v < limit)
  } else {
    all = y_here; mean = pred.mean; lo = pred.lo; hi = pred.hi
    counted = all.filter(v => v >= lo && v <= hi)
  }
  const inside = q === 5 ? (x => x > threshold) : (q === 2 || q === 4) ? (x => x < limit) : (x => x >= lo && x <= hi)
  return {all, counted, mean, lo, hi, cut, cut_label, curve: kde(all, inside)}
}

kde = (values, inside) => {
  // gaussian kernel density, Silverman bandwidth. Draws are binned first and the
  // bins smoothed, so the cost is bins x kernel width instead of draws x grid.
  const n = values.length, sd = d3.deviation(values)
  const iqr = d3.quantile(values, 0.75) - d3.quantile(values, 0.25)
  const h = 0.9 * Math.min(sd, iqr / 1.34) * Math.pow(n, -0.2)
  const lo = d3.min(values) - 3 * h, hi = d3.max(values) + 3 * h
  const m = 240, step = (hi - lo) / m
  const counts = new Float64Array(m)
  for (const v of values) { const k = Math.floor((v - lo) / step); if (k >= 0 && k < m) counts[k] += 1 }
  const half = Math.ceil(3 * h / step)
  const kern = d3.range(-half, half + 1).map(j => Math.exp(-0.5 * (j * step / h) ** 2))
  const out = []
  for (let i = 0; i < m; i++) {
    let sum = 0
    for (let j = -half; j <= half; j++) { const k = i + j; if (k >= 0 && k < m) sum += counts[k] * kern[j + half] }
    const x = lo + (i + 0.5) * step
    out.push({x, y: sum / (n * h * Math.sqrt(2 * Math.PI)), counted: inside(x)})
  }
  return out
}

viewof question = Inputs.radio(
  ["1. At this pressure, what will the rate be?",
   "2. At this pressure, how likely is it for the rate to stay below the limit?",
   "3. What pressure gives the target rate?",
   "4. What is the highest pressure that keeps the rate below the limit?",
   "5. At this pressure, how likely is it for blood flow 300 to add more than Δ rate over 200?"],
  {value: "1. At this pressure, what will the rate be?", label: ""})

viewof pressure_in = Inputs.range([0.2, 3.2], {value: 1.5, step: 0.05, label: "pressure (dmHg)"})

pressure = throttle(viewof pressure_in)

viewof blood_flow = Inputs.radio([200, 300], {value: 300, label: "blood flow (ml/min)"})

viewof who = Inputs.select(["all dialyzers", ...d3.range(1, 21).map(String)], {value: "all dialyzers", label: "dialyzer"})

viewof ci_in = Inputs.range([0.5, 0.99], {value: 0.9, step: 0.01, label: "credible interval"})

ci = throttle(viewof ci_in)

viewof limit_in = Inputs.range([10, 80], {value: 50, step: 1, label: "rate limit (ml/hr)"})

limit = throttle(viewof limit_in)

viewof target_in = Inputs.range([10, 80], {value: 45, step: 1, label: "target rate (ml/hr)"})

target = throttle(viewof target_in)

viewof prob_in = Inputs.range([0.5, 0.99], {value: 0.9, step: 0.01, label: "probability"})

prob = throttle(viewof prob_in)

viewof threshold_in = Inputs.range([0, 30], {value: 10, step: 0.5, label: "Δ rate (ml/hr)"})

threshold = throttle(viewof threshold_in)

q = Number(question[0])

one = who === "all dialyzers" ? null : Number(who)

bf = one === null ? blood_flow : obs.find(d => d.dialyzer === one).blood_flow

lo_q = (1 - ci) / 2

hi_q = 1 - (1 - ci) / 2

draws = FileAttachment("explore_draws_model3.csv").csv({typed: true})

obs = FileAttachment("explore_data.csv").csv({typed: true})

z = {
  const r = d3.randomNormal.source(d3.randomLcg(42))(0, 1)
  if (one === null) return draws.map(() => ({b: r(), c: r(), e: r(), e2: r()}))
  const bf1 = obs.find(d => d.dialyzer === one).blood_flow
  return draws.map(d => ({
    b: (d[`b_${one}`] - (d.b_0 + d.b_blood_flow * bf1)) / d.sigma_b,
    c: (Math.log(d[`c_${one}`]) - (d.c_0 + d.c_blood_flow * bf1)) / d.sigma_c,
    e: r(),
    e2: r()
  }))
}

params_at = (flow) => draws.map((d, i) => ({
  a: d.a,
  b: d.b_0 + d.b_blood_flow * flow + d.sigma_b * z[i].b,
  c: Math.exp(d.c_0 + d.c_blood_flow * flow + d.sigma_c * z[i].c),
  sigma: d.sigma
}))

diff = {
  const hi = params_at(300), lo = params_at(200)
  const d = hi.map((p, i) => (curve(p, pressure) + p.sigma * z[i].e) - (curve(lo[i], pressure) + lo[i].sigma * z[i].e2))
  return {
    draws: d,
    mean: d3.mean(d),
    lo: d3.quantile(d, lo_q),
    hi: d3.quantile(d, hi_q),
    p_above: d3.mean(d, v => v > threshold ? 1 : 0)
  }
}

params = params_at(bf)

curve = (p, x) => p.a * (1 - Math.exp(-p.c * x)) + p.b

use_noise = true

y_at = (x) => params.map((p, i) => curve(p, x) + (use_noise ? p.sigma * z[i].e : 0))

y_here = y_at(pressure)

pred = {
  const ys = y_here
  return {
    mean: d3.mean(ys),
    lo: d3.quantile(ys, lo_q),
    hi: d3.quantile(ys, hi_q),
    p_below: d3.mean(ys, v => v < limit ? 1 : 0)
  }
}

band = d3.range(0.2, 3.21, 0.05).map(x => {
  const ys = y_at(x)
  return {x: x, mean: d3.mean(ys), lo: d3.quantile(ys, lo_q), hi: d3.quantile(ys, hi_q), p_below: d3.mean(ys, v => v < limit ? 1 : 0)}
})

band_both = ["200", "300"].flatMap(bf => {
  const ps = params_at(Number(bf))
  return d3.range(0.2, 3.21, 0.05).map(x => {
    const ys = ps.map(p => curve(p, x))
    return {bf, x, mean: d3.mean(ys), lo: d3.quantile(ys, lo_q), hi: d3.quantile(ys, hi_q)}
  })
})

x_keep = {
  const ok = band.filter(b => b.p_below >= prob)
  return ok.length ? d3.max(ok, b => b.x) : null
}

x_here = params.map((p, i) => {
  const f = (target - p.sigma * z[i].e - p.b) / p.a
  return f > 0 && f < 1 ? -Math.log(1 - f) / p.c : null
})

inv = {
  const ok = x_here.filter(v => v !== null)
  return {
    mean: ok.length ? d3.mean(ok) : null,
    lo: ok.length ? d3.quantile(ok, lo_q) : null,
    hi: ok.length ? d3.quantile(ok, hi_q) : null,
    reach: ok.length / x_here.length
  }
}

x_mark = q === 3 ? (inv.mean ?? 0) : q === 4 ? (x_keep ?? 0) : pressure

answer = {
  const f1 = d3.format(".1f"), f2 = d3.format(".2f")
  const whom = one === null ? `a new dialyzer at blood flow ${bf} ml/min` : `dialyzer ${one} (blood flow ${bf} ml/min)`
  const pct = d3.format(".0%")(ci)
  const kind = "measured rate"
  if (q === 1) return html`<b>${f1(pred.mean)} ml/hr</b> &nbsp; ${pct} interval ${f1(pred.lo)} to ${f1(pred.hi)}<br><small>${kind} at pressure ${pressure} dmHg, ${whom}</small>`
  if (q === 2) return html`<b>P(rate below ${limit} ml/hr) = ${f2(pred.p_below)}</b><br><small>${kind} at pressure ${pressure} dmHg, ${whom}</small>`
  if (q === 3) return inv.mean === null
    ? html`<b>rate ${target} ml/hr is not reachable</b><br><small>the measured rate never gets there for ${whom}</small>`
    : html`<b>pressure ${f2(inv.mean)} dmHg</b> &nbsp; ${pct} interval ${f2(inv.lo)} to ${f2(inv.hi)}<br><small>for a measured rate of ${target} ml/hr, ${whom}, reachable in ${d3.format(".0%")(inv.reach)} of draws</small>`
  if (q === 5) return html`<b>${f1(diff.mean)} ml/hr</b> &nbsp; ${pct} interval ${f1(diff.lo)} to ${f1(diff.hi)}<br><b>P(Δ rate above ${threshold} ml/hr) = ${f2(diff.p_above)}</b><br><small>measured rate at pressure ${pressure} dmHg at blood flow 300 minus at 200 ml/min, ${one === null ? "a new dialyzer, same z at both flows" : `dialyzer ${one}'s own effects at both flows`}</small>`
  return x_keep === null
    ? html`<b>no pressure in range keeps P(rate below ${limit} ml/hr) at ${prob}</b>`
    : html`<b>pressure ${f2(x_keep)} dmHg</b><br><small>highest pressure with P(rate below ${limit} ml/hr) ≥ ${prob}, ${whom}</small>`
}

show_answer_3 = {
  const slot = effects_card.querySelector("#pm-answer-3")
  if (slot) slot.replaceChildren(sentence)
  return sentence
}

pooled_curve = kde(pooled, () => false)

picked_curve = {
  // scaled to the pooled curve: one dialyzer holds 1/20 of the pooled draws
  if (picked === null) return []
  return kde(vals[picked], () => false).map(d => ({x: d.x, y: d.y / 20}))
}

viewof model = Inputs.radio(["1: no blood flow", "2: on c", "3: on b and c"], {value: "3: on b and c", label: "model"})

draws1 = FileAttachment("explore_draws_model1.csv").csv({typed: true})

draws2 = FileAttachment("explore_draws_model2.csv").csv({typed: true})

dr = model[0] === "1" ? draws1 : model[0] === "2" ? draws2 : draws

viewof par = Inputs.radio(["b", "c"], {value: "b", label: "parameter"})

viewof show = Inputs.radio(["deviation", "raw"], {value: "deviation", label: "show"})

viewof sort_by = Inputs.radio(["value", "dialyzer"], {value: "value", label: "sort by"})

viewof pick = Inputs.select(["none", ...d3.range(1, 21).map(String)], {value: "none", label: "dialyzer"})

viewof ci2_in = Inputs.range([0.5, 0.99], {value: 0.9, step: 0.01, label: "credible interval"})

ci2 = throttle(viewof ci2_in)

picked = pick === "none" ? null : Number(pick)

flow_of = Object.fromEntries(d3.range(1, 21).map(i => [i, obs.find(d => d.dialyzer === i).blood_flow]))

vals = Object.fromEntries(d3.range(1, 21).map(i => {
  const bf_i = flow_of[i]
  const v = dr.map(d => {
    const raw = d[`${par}_${i}`]
    if (show === "raw") return raw
    if (par === "b") {
      const hat = "b_blood_flow" in d ? d.b_0 + d.b_blood_flow * bf_i : d.mu_b
      return raw - hat
    }
    const hat = "c_blood_flow" in d ? Math.exp(d.c_0 + d.c_blood_flow * bf_i) : Math.exp(d.log_mu_c)
    return raw / hat - 1
  })
  return [i, v]
}))

ranks = {
  const n = dr.length, ids = d3.range(1, 21)
  const low = Object.fromEntries(ids.map(i => [i, 0])), high = Object.fromEntries(ids.map(i => [i, 0]))
  for (let k = 0; k < n; k++) {
    let lo = ids[0], hi = ids[0]
    for (const i of ids) {
      if (vals[i][k] < vals[lo][k]) lo = i
      if (vals[i][k] > vals[hi][k]) hi = i
    }
    low[lo] += 1; high[hi] += 1
  }
  return {low, high, n}
}

per = d3.range(1, 21).map(i => ({
  dialyzer: i,
  blood_flow: flow_of[i],
  mean: d3.mean(vals[i]),
  lo: d3.quantile(vals[i], (1 - ci2) / 2),
  hi: d3.quantile(vals[i], 1 - (1 - ci2) / 2),
  p_low: ranks.low[i] / ranks.n,
  p_high: ranks.high[i] / ranks.n
}))

pooled = d3.range(1, 21).flatMap(i => vals[i])

order = (sort_by === "value" ? per.slice().sort((p, q) => p.mean - q.mean) : per.slice().sort((p, q) => p.dialyzer - q.dialyzer)).map(d => String(d.dialyzer))

fmt = show === "deviation" && par === "c" ? d3.format("+.0%") : show === "deviation" ? d3.format("+.2f") : d3.format(".3g")

sentence = {
  const pct = d3.format(".0%")(ci2), f2 = d3.format(".2f")
  if (picked === null) {
    const lo = per.slice().sort((p, q) => q.p_low - p.p_low)[0], hi = per.slice().sort((p, q) => q.p_high - p.p_high)[0]
    return html`<b>Lowest ${par}: dialyzer ${lo.dialyzer}</b> &nbsp; P = ${f2(lo.p_low)}<br><b>Highest ${par}: dialyzer ${hi.dialyzer}</b> &nbsp; P = ${f2(hi.p_high)}<br><small>pick a dialyzer above for its own numbers</small>`
  }
  const d = per.find(p => p.dialyzer === picked)
  const what = show === "raw" ? `${par} = ${fmt(d.mean)}` :
    par === "b" ? `${par} is ${d3.format(".2f")(Math.abs(d.mean))} ${d.mean < 0 ? "below" : "above"} its blood-flow line`
                : `${par} is ${d3.format(".0%")(Math.abs(d.mean))} ${d.mean < 0 ? "slower" : "faster"} than its blood-flow line`
  return html`<b>Dialyzer ${picked}</b> (blood flow ${d.blood_flow} ml/min)<br>${what}<br><small>${pct} interval ${fmt(d.lo)} to ${fmt(d.hi)}</small>`
}