// Generated, do not edit. sha256:74e4ed13a040cfe4e2dc4c23217c88607a06c14c8cc97aceaf7026b8d073ba91
import { CONFIG } from '../../shared/config.js';

const LADDERS = CONFIG.AI.BUCKET_LADDERS;

function bodemVan(ladderNaam) {
  const min = CONFIG.AI.BUCKET_MIN_VALUES[ladderNaam] || 0;
  if (!min) return 0;
  const ladder = LADDERS[ladderNaam];
  let smalst = Infinity;
  for (let i = 0; i < ladder.length; i++) {
    const onder = ladder[i];
    const boven = i + 1 < ladder.length ? ladder[i + 1] : 10;
    smalst = Math.min(smalst, (boven - onder) / onder);
  }
  return min / smalst;
}

export function bucket(waarde, ladderNaam = 'COARSE') {
  const ladder = LADDERS[ladderNaam];
  if (!ladder) throw new Error(`unknown ladder: ${ladderNaam}`);
  if (typeof waarde !== 'number' || !Number.isFinite(waarde)) return null;

  if (waarde === 0) return { from: 0, to: 0, exact: true };

  const negatief = waarde < 0;
  const abs = Math.abs(waarde);

  const bodem = Number.isInteger(waarde) ? bodemVan(ladderNaam) : 0;
  if (bodem && abs < bodem) {
    return negatief
      ? { from: -bodem, to: 0, exact: false, floor: true }
      : { from: 0, to: bodem, exact: false, floor: true };
  }

  const orde = Math.floor(Math.log10(abs));
  const schaal = 10 ** orde;
  const genormaliseerd = Math.min(Math.max(abs / schaal, 1), 9.999999999);

  let onder = ladder[0];
  let boven = 10;
  for (let i = 0; i < ladder.length; i++) {
    if (genormaliseerd >= ladder[i]) {
      onder = ladder[i];
      boven = i + 1 < ladder.length ? ladder[i + 1] : 10;
    }
  }

  const van = onder * schaal;
  const tot = boven * schaal;
  return negatief ? { from: -tot, to: -van, exact: false } : { from: van, to: tot, exact: false };
}

export function bucketLabel(waarde, ladderNaam = 'COARSE') {
  const b = bucket(waarde, ladderNaam);
  if (!b) return null;
  if (b.exact) return String(b.from);
  if (b.floor) return b.to === 0 ? `meer dan ${getal(b.from)}` : `minder dan ${getal(b.to)}`;
  return `${getal(b.from)} tot ${getal(b.to)}`;
}

function getal(n) {
  return Number.isInteger(n) ? String(n) : String(Math.round(n * 100) / 100);
}

export function shareBucket(pct) {
  const grenzen = CONFIG.AI.SHARE_BUCKETS;
  if (typeof pct !== 'number' || !Number.isFinite(pct) || pct < 0) return null;
  if (pct === 0) return { from: 0, to: 0, below: false };
  if (pct < grenzen[0]) return { from: 0, to: grenzen[0], below: true };

  let onder = grenzen[0];
  let boven = grenzen[grenzen.length - 1];
  for (let i = 0; i < grenzen.length; i++) {
    if (pct >= grenzen[i]) {
      onder = grenzen[i];
      boven = i + 1 < grenzen.length ? grenzen[i + 1] : grenzen[i];
    }
  }
  if (onder === boven) return { from: 100, to: 100, below: false };
  return { from: onder, to: boven, below: false };
}

export function shareLabel(pct) {
  const b = shareBucket(pct);
  if (!b) return null;
  if (b.from === b.to) return `${b.from}%`;
  if (b.below) return `minder dan ${b.to}%`;
  return `${b.from} tot ${b.to}%`;
}