viewof question = Inputs.radio(
  ["1. What will the rate be at a pressure?",
   "2. How likely is the rate to stay below a limit?",
   "3. What pressure gives a target rate?",
   "4. What is the highest pressure that keeps the rate below a limit?",
   "5. How likely is the rate at blood flow 300 to exceed the rate at 200 by more than Δ rate?"],
  {value: "1. What will the rate be at a pressure?", label: ""})

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

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

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

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

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

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

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

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

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}` : `dialyzer ${one} (blood flow ${bf})`
  const pct = d3.format(".0%")(ci)
  const kind = "measured rate"
  if (q === 1) return html`<b>${f1(pred.mean)}</b> &nbsp; ${pct} interval ${f1(pred.lo)} to ${f1(pred.hi)}<br><small>${kind} at pressure ${pressure}, ${whom}</small>`
  if (q === 2) return html`<b>P(rate below ${limit}) = ${f2(pred.p_below)}</b><br><small>${kind} at pressure ${pressure}, ${whom}</small>`
  if (q === 3) return inv.mean === null
    ? html`<b>rate ${target} is not reachable</b><br><small>the measured rate never gets there for ${whom}</small>`
    : html`<b>pressure ${f2(inv.mean)}</b> &nbsp; ${pct} interval ${f2(inv.lo)} to ${f2(inv.hi)}<br><small>for a measured rate of ${target}, ${whom}, reachable in ${d3.format(".0%")(inv.reach)} of draws</small>`
  if (q === 5) return html`<b>${f1(diff.mean)}</b> &nbsp; ${pct} interval ${f1(diff.lo)} to ${f1(diff.hi)}<br><b>P(Δ rate above ${threshold}) = ${f2(diff.p_above)}</b><br><small>measured rate at pressure ${pressure} at blood flow 300 minus at 200, ${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}) at ${prob}</b>`
    : html`<b>pressure ${f2(x_keep)}</b><br><small>highest pressure with P(rate below ${limit}) ≥ ${prob}, ${whom}</small>`
}

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 = Inputs.range([0.5, 0.99], {value: 0.9, step: 0.01, label: "credible interval"})

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})<br>${what}<br><small>${pct} interval ${fmt(d.lo)} to ${fmt(d.hi)}</small><br>P(lowest) = ${f2(d.p_low)} &nbsp; P(highest) = ${f2(d.p_high)}`
}