d3 = require("d3@7")
party_order = ["left", "spd", "bsw", "greens", "fdp", "fw", "cdu", "afd"]

label_to_party = Object.fromEntries(
  Object.entries(party_names).map(([party, label]) => [label, party])
)

party_to_label = Object.fromEntries(
  Object.entries(label_to_party).map(([label, party]) => [party, label])
)

coalitionParties = label =>
  label.split("-").map(label => label_to_party[label])

partyKey = parties =>
  parties.slice().sort().join("|")

normCoalition = label =>
  partyKey(coalitionParties(label))

labelFromParties = parties =>
  parties.map(party => party_to_label[party] || party).join("-")

// Year ticks for the two time-series x-axes. Plot's own ticks: "year" only
// emits January 1s that fall inside the domain, so a range shorter than a year
// (a fresh scrape, or a single-institute series with few polls) yields no tick
// at all and the axis loses its year label entirely. Fall back to the first
// date in that case, so the year is always shown.
yearTicks = (min, max) => {
  if (min == null || max == null) return []
  const years = d3.utcYears(d3.utcYear.ceil(min), max)
  return years.length ? years : [min]
}

// tickFormat must return a string: a number goes through Plot's locale-aware
// default number formatting, which renders the year as "2,026".
formatYear = d => String(d.getUTCFullYear())

// Every number shown to a reader goes through here: toFixed() is locale-blind
// and would print "11.7". Fixed digits keep a column's decimals aligned.
formatDe = (value, digits = 1) =>
  Number(value).toLocaleString("de-DE", {
    minimumFractionDigits: digits,
    maximumFractionDigits: digits
  })

// Ceiling for the Umfrageverlauf Stimmenanteil axes, per election: the derived
// domain runs to 40 % for the Bundestagswahl, where nothing has polled above 33.
// Per election because the state series really do reach the low 40s; an election
// absent here keeps its derived domain.
//
// Block with an explicit return rather than `= ({ BTW: 35 })`, for the same
// reason as election_files below: Quarto's OJS layer evaluates a cell whose body
// is a parenthesised object literal to undefined.
voteShareYCap = {
  return { BTW: 35 }
}

// Caps `derived`, but never below `dataMax` — a future poll above the cap widens
// the axis again rather than being drawn outside the frame.
capYMax = (derived, dataMax, election) => {
  const cap = voteShareYCap[election]
  return cap == null ? derived : Math.max(Math.min(derived, cap), dataMax)
}

// Coalitions that are mathematically possible but politically off the table —
// no party governs with AfD, and Linke is ruled out by FDP, CDU and BSW alike.
excludedPairs = [
  ["left", "fdp"],
  ["left", "cdu"],
  ["left", "bsw"]
]

// The single exception to "no party governs with AfD": AfD and BSW on their own,
// which from here on is treated like any other coalition — no special display
// rule, so it surfaces wherever the usual thresholds let it. Only that exact
// pair, though: AfD with any other partner stays off the table, and so does
// AfD-BSW with a third party joined to it.
afdBswKey = "afd|bsw"

isViableCoalition = parties =>
  (!parties.includes("afd") || parties.length === 1 || partyKey(parties) === afdBswKey) &&
  !excludedPairs.some(([a, b]) => parties.includes(a) && parties.includes(b))

meanBy = (data, keyFn, valueFn) =>
  Array.from(
    d3.rollup(data, v => d3.mean(v, valueFn), keyFn),
    ([key, value]) => ({ key, value })
  )

cleanShares = (shares, includeOthers = false) => {
  return meanBy(
    shares.filter(d => includeOthers || d.party !== "others"),
    d => d.party,
    d => d.percent
  )
    .map(d => ({
      party: d.key,
      percent: d.value,
      label: party_names[d.key] || d.key
    }))
    .sort((a, b) => {
      const ai = party_order.indexOf(a.party)
      const bi = party_order.indexOf(b.party)
      return (ai === -1 ? Infinity : ai) - (bi === -1 ? Infinity : bi)
    })
}

cleanHurdles = hurdles => {
  return meanBy(
    hurdles.filter(d => d.party !== "others" && d.prob_above_hurdle < 1),
    d => d.party,
    d => d.prob_above_hurdle
  )
    .map(d => ({
      party: d.key,
      prob_above_hurdle: d.value,
      label: party_names[d.key] || d.key
    }))
    .sort((a, b) => b.prob_above_hurdle - a.prob_above_hurdle)
}

cleanCoalitions = (coalitions, shares) => {
  const partyVotes = Object.fromEntries(
    cleanShares(shares).map(d => [d.party, d.percent])
  )

  const byLabel = Array.from(
    d3.rollup(
      coalitions,
      v => d3.mean(v, d => d.probability),
      d => d.label
    ),
    ([label, probability]) => ({
      label,
      probability,
      parties: coalitionParties(label),
      coalition_key: normCoalition(label)
    })
  )

  return Array.from(
    d3.group(
      byLabel.filter(d => isViableCoalition(d.parties)),
      d => d.coalition_key
    ),
    ([coalition_key, rows]) => {
      rows.sort((a, b) =>
        d3.descending(a.probability, b.probability) ||
        d3.ascending(a.label, b.label)
      )

      const probability = d3.sum(rows, d => d.probability)
      const maxMemberVote = d3.max(rows[0].parties, p => partyVotes[p] ?? -Infinity)
      const label = rows
        .filter(d => (partyVotes[d.parties[0]] ?? -Infinity) === maxMemberVote)
        .sort((a, b) => d3.ascending(a.label, b.label))[0]?.label ?? rows[0].label

      const first_party = coalitionParties(label)[0]
      const vote_share  = d3.sum(rows[0].parties, p => partyVotes[p] ?? 0)

      return {
        coalition_key,
        label,
        first_party,
        probability,
        vote_share
      }
    }
  ).sort((a, b) => a.probability - b.probability)
}

// The coalitions the site displays, one entry per exposed leadership variant.
// The variant whose first party has the highest selected/local vote share is
// always exposed (ties broken by label, for stable ordering); the other
// orderings of the same coalition join it whenever they carry probability.
leadershipVariants = (coalitions, shares, pooledShares) => {
  const partyVotes  = Object.fromEntries(cleanShares(shares).map(d => [d.party, d.percent]))
  const pooledVotes = Object.fromEntries(cleanShares(pooledShares).map(d => [d.party, d.percent]))

  const byLabel = Array.from(
    d3.rollup(coalitions, v => d3.mean(v, d => d.probability), d => d.label),
    ([label, probability]) => ({
      label,
      probability,
      parties: coalitionParties(label),
      coalition_key: normCoalition(label)
    })
  )

  const viable = byLabel.filter(d => isViableCoalition(d.parties))

  // A coalition is shown if it currently polls at least 33% combined (based on
  // the recent pooled estimate, not whichever institute is selected) — OR if it
  // has a non-zero majority probability. The probability overrides the share
  // rule: a coalition the simulations give any chance of a majority must never
  // be hidden just because its combined polling looks thin. Only the political
  // exclusions in isViableCoalition() still hide a coalition unconditionally.
  //
  // The R side (derive_dynamic_coalitions() in scripts/calc_coalProbs_helpers.R)
  // computes more broadly (25% combined) than the 33% here, so the override has
  // data to work with in the band between the two.
  const shownKeys = new Set(
    Array.from(
      d3.group(viable, d => d.coalition_key),
      ([coalition_key, rows]) => [
        coalition_key,
        d3.sum(rows[0].parties, p => pooledVotes[p] ?? 0) >= 33 ||
          rows.some(d => d.probability > 0)
      ]
    )
      .filter(([, shown]) => shown)
      .map(([coalition_key]) => coalition_key)
  )

  const eligible = viable.filter(d => shownKeys.has(d.coalition_key))

  // Leadership variants are exposed individually rather than collapsed into the
  // currently leading one. Each ordering is its own series in the probability,
  // density and history data, so collapsing them silently discarded the
  // probability mass sitting on the non-leading orderings — and made the
  // Zeitverlauf line dip whenever leadership changed hands. Exposed are every
  // variant carrying a non-zero probability, plus the leading variant, so a
  // coalition still appears once even when all its orderings sit at 0.
  return Array.from(
    d3.group(eligible, d => d.coalition_key),
    ([coalition_key, rows]) => {
      const parties       = rows[0].parties
      const vote_share    = d3.sum(parties, p => partyVotes[p] ?? 0)
      const maxMemberVote = d3.max(parties, p => partyVotes[p] ?? -Infinity)
      const leader = rows
        .filter(d => (partyVotes[d.parties[0]] ?? -Infinity) === maxMemberVote)
        .sort((a, b) => d3.ascending(a.label, b.label))[0] ?? rows[0]

      return rows
        .filter(d => d.probability > 0 || d === leader)
        .sort((a, b) =>
          d3.descending(a.probability, b.probability) ||
          d3.ascending(a.label, b.label)
        )
        .map(d => ({
          coalition_key,
          label: d.label,
          probability: d.probability,
          first_party: d.parties[0],
          vote_share
        }))
    }
  ).flat()
}

cleanCoalitionHistory = rows => {
  const filtered = rows.filter(d => isViableCoalition(coalitionParties(d.label)))

  // Collapse exact (date, label) duplicates by averaging. A pooled result can
  // occasionally get recomputed more than once for the same poll date.
  const byDateLabel = d3.rollup(
    filtered,
    v => d3.mean(v, d => d.probability),
    d => d.date,
    d => d.label
  )

  return Array.from(byDateLabel, ([date, byLabel]) =>
    Array.from(byLabel, ([label, probability]) => ({
      label,
      first_party: coalitionParties(label)[0],
      date: new Date(date),
      probability
    }))
  ).flat()
}

latestCoalitionProbabilityByLabel = rows => {
  const history = cleanCoalitionHistory(rows)
  const latestDate = d3.max(history, d => d.date)

  if (latestDate == null) return new Map()

  return new Map(
    history
      .filter(d => +d.date === +latestDate)
      .map(d => [d.label, d.probability])
  )
}

// One record per (pollster, date, coalition), carrying that group's whole curve
// as the parallel arrays `seat_share` and `density` — see the nesting step in
// prepare_data.R for why the curve is not stored as 512 separate rows.
densityArray = value => {
  if (Array.isArray(value)) return value
  if (value && typeof value === "object") {
    return Object.keys(value)
      .sort((a, b) => +a - +b)
      .map(key => value[key])
  }
  return value == null ? [] : [value]
}

densityGroups = densityData => {
  const densities = densityData?.densities ?? []
  const rows = Array.isArray(densities)
    ? densities
    : (() => {
        const columns = Object.keys(densities)
        if (columns.length === 0) return []

        const n = densities[columns[0]]?.length ?? 0
        return d3.range(n).map(i =>
          Object.fromEntries(columns.map(column => [column, densities[column][i]]))
        )
      })()

  if (rows.length === 0 || densityArray(rows[0].seat_share).length > 1) return rows

  return Array.from(
    d3.rollup(
      rows,
      values => ({
        ...values[0],
        seat_share: values.map(d => d.seat_share),
        density: values.map(d => d.density)
      }),
      d => `${d.pollster}\u0001${d.date}\u0001${d.coalition}`
    ).values()
  )
}

densityValue = function normalizeDensityValue(value) {
  if (Array.isArray(value)) return normalizeDensityValue(value[0])
  if (value && typeof value === "object" && 0 in value) return normalizeDensityValue(value[0])
  if (value && typeof value === "object" && "value" in value) return normalizeDensityValue(value.value)
  if (value && typeof value === "object" && Object.keys(value).length === 1) {
    return normalizeDensityValue(value[Object.keys(value)[0]])
  }
  return +value
}

densitySource = (densityData, selectedInstitute) => {
  const pollster = selectedInstitute === "Pooled" ? "pooled" : selectedInstitute
  const densities = densityGroups(densityData)
  const latestDate = d3.max(
    densities.filter(d => d.pollster === pollster),
    d => new Date(d.date)
  )

  return densities.filter(d =>
    d.pollster === pollster &&
    +new Date(d.date) === +latestDate
  )
}

coalitionDensityOptions = (data, selectedInstitute) => {
  const densities = densitySource(data, selectedInstitute)
  return new Map(
    Array.from(
      d3.rollup(densities, rows => rows[0].label, d => d.coalition),
      ([coalition, label]) => [label, coalition]
    ).sort((a, b) => d3.ascending(a[0], b[0]))
  )
}

// Zips the group's two curve arrays back into the {seat_share, density} points
// the marks below plot. densityValue is applied per element, never to the array
// itself — it unwraps single-element wrappers and would collapse a whole curve
// to its first point.
normalizeDensityCurve = group => {
  const xs = densityArray(group?.seat_share)
  const ys = densityArray(group?.density)

  return xs
    .map((x, i) => ({
      seat_share: densityValue(x),
      density: Math.max(0, densityValue(ys[i]))
    }))
    .filter(d => Number.isFinite(d.seat_share) && Number.isFinite(d.density))
    .sort((a, b) => d3.ascending(a.seat_share, b.seat_share))
}

plotCoalitionDensity = (group, height = 260) => {
  const dat = normalizeDensityCurve(group)
  const label = group?.label ?? ""
  const coalition = group?.coalition ?? ""
  const isSingleParty = !String(coalition).includes("|")
  const parliamentPresence = densityValue(group?.parliament_presence)
  const parliamentPresenceN = densityValue(group?.parliament_presence_n)
  const simulationN = densityValue(group?.simulation_n)
  const hasParliamentPresence = Number.isFinite(parliamentPresence)
    && Number.isFinite(parliamentPresenceN)
    && Number.isFinite(simulationN)
  const parliamentPresenceLabel = hasParliamentPresence
    ? `${formatDe(parliamentPresenceN, 0)} von ${formatDe(simulationN, 0)} Durchgängen (${formatDe(parliamentPresence * 100)}%)`
    : ""

  if (dat.length < 2 || !Number.isFinite(d3.max(dat, d => d.density))) {
    return html`<div style="font-weight:700">${label}</div>`
  }

  const ciLower = densityValue(group?.ci_lower)
  const ciUpper = densityValue(group?.ci_upper)
  const ciLowerSeats = densityValue(group?.ci_lower_seats)
  const ciUpperSeats = densityValue(group?.ci_upper_seats)
  const maxDensity = d3.max(dat, d => d.density)
  const threshold = 0.5
  const hasInterval = Number.isFinite(ciLower) && Number.isFinite(ciUpper)
  const hasSeatInterval = Number.isFinite(ciLowerSeats) && Number.isFinite(ciUpperSeats)
  const intervalLabel = hasSeatInterval
    ? `${formatDe(ciLowerSeats, 0)} - ${formatDe(ciUpperSeats, 0)}`
    : ""
  const intervalSentence = isSingleParty
    ? html`Für die Partei <b>${label}</b> liegt die Anzahl der Sitze mit 95% Wahrscheinlichkeit im Intervall <b style="color:#f39c12;font-size:1.18rem">${intervalLabel}</b>.`
    : html`Für <b>${label}</b> liegt die Summe der Sitze mit 95% Wahrscheinlichkeit im Intervall <b style="color:#f39c12;font-size:1.18rem">${intervalLabel}</b>.`
  const densityNote = isSingleParty
    ? html`Die Dichte zeigt alle Simulationen. Die Partei war in ${parliamentPresenceLabel} im Parlament vertreten.`
    : html`Die Dichte zeigt alle Simulationen. Parteien, die in einem Simulationsdurchgang nicht im Parlament vertreten sind, tragen in diesem 0 zur Sitzsumme bei.<br>
      Alle ausgewählten Parteien waren in ${parliamentPresenceLabel} im Parlament vertreten.`
  const showSeatCountNotice = election !== "BTW"
  const plot = Plot.plot({
    height,
    width: Math.max(900, window.innerWidth - 430),
    marginTop: 56,
    marginRight: 42,
    marginBottom: 42,
    marginLeft: 42,
    x: {
      label: null,
      domain: [0, 1],
      ticks: [0, 0.25, 0.5, 0.75, 1],
      tickFormat: d => `${formatDe(d * 100, 0)}%`,
      axis: "top"
    },
    y: {
      label: null,
      domain: [-0.12 * maxDensity, maxDensity],
      axis: null
    },
    marks: [
      Plot.ruleX([0, 0.25, 0.5, 0.75, 1], {
        stroke: "#bdbdbd",
        strokeDasharray: "5 6",
        strokeWidth: 1.4
      }),
      Plot.areaY(dat.filter(d => d.seat_share <= threshold), {
        x: "seat_share",
        y1: 0,
        y2: "density",
        fill: "#d1d0ce",
        fillOpacity: 0.95
      }),
      Plot.areaY(dat.filter(d => d.seat_share >= threshold), {
        x: "seat_share",
        y1: 0,
        y2: "density",
        fill: "#0072b6",
        fillOpacity: 0.95
      }),
      Plot.lineY(dat, {
        x: "seat_share",
        y: "density",
        stroke: "#777",
        strokeWidth: 1
      }),
      Plot.ruleY([0], {
        stroke: "#bdbdbd",
        strokeWidth: 5
      }),
      ...(hasInterval ? [
        Plot.ruleY([{ y: -0.085 * maxDensity, x1: ciLower, x2: ciUpper }], {
          y: "y",
          x1: "x1",
          x2: "x2",
          stroke: "#f39c12",
          strokeWidth: 5
        })
      ] : [])
    ]
  })

  return html`
    <div>
      <div style="text-align:center;font-size:1.08rem;line-height:1.2;margin:10px 0 22px 0;position:relative;z-index:1">
        Anteil der Sitze im Parlament
      </div>
      ${plot}
      ${hasSeatInterval ? html`
        <p style="margin:10px 0 0 34px;color:#333;font-size:1.08rem;line-height:1.35;white-space:nowrap">
          ${intervalSentence}
        </p>
      ` : ""}
      ${hasParliamentPresence ? html`
        <div style="
          margin:10px 34px 0 34px;
          padding:10px 12px;
          border-left:4px solid #2b6cb0;
          background:#f7f9fc;
          color:#444;
          font-size:0.88rem;
          line-height:1.45;
        ">
          <div>${densityNote}</div>
          ${showSeatCountNotice ? html`
            <div style="margin-top:8px">
              <b>Beachten Sie:</b> Die angezeigte Sitzanzahl dient der groben Orientierung, da Überhangs- bzw. Ausgleichsmandate nicht berücksichtigt werden. Auf die Mehrheitsverhältnisse wirken sich diese, gemäß aktuellem Wahlrecht, jedoch nur geringfügig aus. Wir gehen bei unserer Analyse von einer Gesamtzahl von ${cur_meta.seats} Sitzen aus.
            </div>
          ` : ""}
        </div>
      ` : ""}
    </div>
  `
}