// © 2026 TechnoLibre (http://www.technolibre.ca)
// License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl)

// Épreuves des seuils du banc (§ 19.10, § 19.4, § 6.2) : la dichotomie du
// plus grand tenant sur des prédicats écrits, dont le seuil se lit à la main ;
// le seuil d'une courbe de temps par image sur des courbes écrites ; la
// tolérance de la chaîne témoin sur des longueurs écrites. Les prédicats
// comptent leurs appels : une dichotomie qui balaierait tout l'intervalle se
// verrait.
import assert from 'node:assert/strict';
import { describe, test } from '../../test/lanceur.js';
import { CRITERE_TEMPS_IMAGE_MS, plusGrandTenant, seuilDepuisCourbe, toleranceTemoin } from './seuils.js';

// Un prédicat qui note chaque n reçu, dans l'ordre des appels.
function compte(predicat) {
  const appels = [];
  const enveloppe = (n) => {
    appels.push(n);
    return predicat(n);
  };
  return { enveloppe, appels };
}

describe('le critère du temps par image', () => {
  test('33 ms, le choix de l’utilisateur, écrit ici et non au registre', () => {
    assert.equal(CRITERE_TEMPS_IMAGE_MS, 33);
  });
});

describe('plusGrandTenant : la dichotomie, la monotonie vérifiée', () => {
  test('un seuil connu, 17 sur [2, 200] : rendu tel quel, en treize appels au plus', async () => {
    const { enveloppe, appels } = compte((n) => n <= 17);
    assert.equal(await plusGrandTenant(enveloppe, 2, 200), 17);
    assert.ok(appels.length <= 13, `${appels.length} appels : ${appels.join(' ')}`);
    assert.deepEqual(appels.slice(-3), [16, 17, 18], 'le résultat et ses deux voisins sont relus');
  });

  test('un prédicat asynchrone vaut un prédicat synchrone', async () => {
    assert.equal(await plusGrandTenant(async (n) => n <= 41, 2, 200), 41);
  });

  test('chaque seuil de [2, 40] se retrouve, bornes comprises', async () => {
    for (let seuil = 2; seuil <= 40; seuil += 1) {
      assert.equal(await plusGrandTenant((n) => n <= seuil, 2, 40), seuil, String(seuil));
    }
  });

  test('tenu partout : le maximum', async () => {
    assert.equal(await plusGrandTenant(() => true, 2, 200), 200);
  });

  test('jamais vrai : null', async () => {
    assert.equal(await plusGrandTenant(() => false, 2, 200), null);
  });

  test('un intervalle d’un seul entier : lui, ou null', async () => {
    assert.equal(await plusGrandTenant(() => true, 5, 5), 5);
    assert.equal(await plusGrandTenant(() => false, 5, 5), null);
  });

  test('non monotone sous le résultat : un trou à 19 sous un seuil de 20 lève en nommant le voisin', async () => {
    const trou = (n) => n <= 20 && n !== 19;
    await assert.rejects(plusGrandTenant(trou, 1, 40), { name: 'RangeError', message: /non monotone.*19/ });
  });

  test('non monotone au-dessus du résultat : un prédicat qui change d’avis à la relecture lève', async () => {
    // Le premier appel en 21 répond « tient », le second « ne tient pas » :
    // la dichotomie le croit tenu, la relecture du voisin le dément.
    const vus = new Map();
    const instable = (n) => {
      const fois = (vus.get(n) ?? 0) + 1;
      vus.set(n, fois);
      return n <= 20 || (n === 21 && fois === 1);
    };
    await assert.rejects(plusGrandTenant(instable, 1, 40), { name: 'RangeError', message: /non monotone/ });
  });

  test('croissant plutôt que décroissant : faux au minimum, vrai au maximum, lève', async () => {
    await assert.rejects(plusGrandTenant((n) => n >= 10, 2, 200), { name: 'RangeError', message: /non monotone/ });
  });

  test('un prédicat qui rend autre chose qu’un booléen est refusé', async () => {
    await assert.rejects(plusGrandTenant(() => 1, 2, 10), TypeError);
    await assert.rejects(plusGrandTenant(async () => undefined, 2, 10), TypeError);
  });

  test('des bornes qui ne sont pas des entiers, ou inversées, sont refusées avant tout appel', async () => {
    const { enveloppe, appels } = compte(() => true);
    for (const [min, max] of [[2.5, 10], [2, Number.POSITIVE_INFINITY], [10, 2], ['2', 10]]) {
      await assert.rejects(plusGrandTenant(enveloppe, min, max), RangeError, `${min}, ${max}`);
    }
    await assert.rejects(plusGrandTenant(null, 2, 10), TypeError);
    assert.deepEqual(appels, []);
  });
});

// Une courbe de temps par image : k en px/cm, p95 en ms.
const courbe = (points) => points.map(([k, p95Ms]) => ({ k, p95Ms }));

describe('seuilDepuisCourbe : le plus petit k au-delà duquel tout k de la courbe tient', () => {
  test('monotone : le premier k qui tient', () => {
    const c = courbe([[0.2, 48], [0.3, 40], [0.4, 33], [0.5, 25], [0.6, 20]]);
    assert.deepEqual(seuilDepuisCourbe(c, 33), { k: 0.4, tenuPartout: false, jamaisTenu: false });
  });

  test('le critère tient à égalité : un p95 de 33 ms tient 33 ms', () => {
    assert.deepEqual(seuilDepuisCourbe(courbe([[0.2, 33.0001], [0.3, 33]]), 33), { k: 0.3, tenuPartout: false, jamaisTenu: false });
  });

  test('non monotone : le seuil est au-delà du dernier échec, non au premier tenant', () => {
    const c = courbe([[0.2, 40], [0.3, 30], [0.4, 36], [0.5, 31], [0.6, 28]]);
    assert.deepEqual(seuilDepuisCourbe(c, 33), { k: 0.5, tenuPartout: false, jamaisTenu: false });
  });

  test('l’ordre de la courbe reçue est sans effet, et elle n’est pas modifiée', () => {
    const c = courbe([[0.6, 28], [0.3, 30], [0.5, 31], [0.2, 40], [0.4, 36]]);
    const copie = structuredClone(c);
    assert.deepEqual(seuilDepuisCourbe(c, 33), { k: 0.5, tenuPartout: false, jamaisTenu: false });
    assert.deepEqual(c, copie);
  });

  test('tout tenu : le plus petit k de la courbe, tenuPartout', () => {
    const c = courbe([[0.4, 20], [0.18, 30], [1, 12]]);
    assert.deepEqual(seuilDepuisCourbe(c, 33), { k: 0.18, tenuPartout: true, jamaisTenu: false });
  });

  test('rien tenu : k null, jamaisTenu', () => {
    assert.deepEqual(seuilDepuisCourbe(courbe([[0.2, 40], [0.5, 34]]), 33), { k: null, tenuPartout: false, jamaisTenu: true });
  });

  test('un échec au plus grand k : k null, sans être jamais tenu', () => {
    assert.deepEqual(seuilDepuisCourbe(courbe([[0.2, 20], [0.5, 34]]), 33), { k: null, tenuPartout: false, jamaisTenu: false });
  });

  test('une courbe vide est refusée : elle ne prouve rien', () => {
    assert.throws(() => seuilDepuisCourbe([], 33), RangeError);
  });

  test('une courbe malformée, un k en double, un critère invalide sont refusés', () => {
    assert.throws(() => seuilDepuisCourbe(null, 33), TypeError);
    assert.throws(() => seuilDepuisCourbe(courbe([[0.2, Number.NaN]]), 33), RangeError);
    assert.throws(() => seuilDepuisCourbe(courbe([[-1, 20]]), 33), RangeError);
    assert.throws(() => seuilDepuisCourbe(courbe([[0.2, 20], [0.2, 40]]), 33), { name: 'RangeError', message: /0\.2/ });
    assert.throws(() => seuilDepuisCourbe(courbe([[0.2, 20]]), 0), RangeError);
    assert.throws(() => seuilDepuisCourbe([{ k: 0.2 }], 33), RangeError);
  });
});

// Dix mesures identiques d'une longueur.
const dix = (valeur) => Array.from({ length: 10 }, () => valeur);

describe('toleranceTemoin : le quart de l’écart du repli, au moins trois fois la gigue', () => {
  test('sans gigue : le quart de l’écart relatif du repli, arrondi par excès à deux chiffres', () => {
    // Écart du repli : 40 / 1000 = 0,04 ; son quart, 0,01.
    const t = toleranceTemoin({ attenduePx: 1000, embarqueePx: dix(1000), repliPx: dix(1040) });
    assert.deepEqual(t, { valeur: 0.01, ecartRepli: 0.04, gigue: 0, biais: 0, refus: null });
  });

  test('un repli plus court compte comme un plus long : l’écart est en valeur absolue', () => {
    const t = toleranceTemoin({ attenduePx: 1000, embarqueePx: dix(1000), repliPx: dix(950) });
    assert.equal(t.ecartRepli, 0.05);
    assert.equal(t.valeur, 0.013);
  });

  test('une gigue qui dépasse le quart de l’écart l’emporte : trois fois elle', () => {
    // Gigue : (1004 − 1000) / 1000 = 0,004 ; trois fois, 0,012 > 0,01.
    const embarqueePx = [1000, 1004, 1002, 1001, 1003, 1000, 1002, 1001, 1004, 1003];
    const t = toleranceTemoin({ attenduePx: 1000, embarqueePx, repliPx: dix(1040) });
    assert.equal(t.gigue, 0.004);
    assert.equal(t.valeur, 0.012);
    assert.equal(t.refus, null);
  });

  test('la valeur arrondie ne passe jamais sous le plus grand des deux termes', () => {
    const t = toleranceTemoin({ attenduePx: 977, embarqueePx: dix(977), repliPx: dix(1021.3) });
    assert.ok(t.valeur >= t.ecartRepli / 4, `${t.valeur} sous ${t.ecartRepli / 4}`);
    assert.equal(String(t.valeur).replace(/^0\.0*/, '').length <= 2, true, String(t.valeur));
  });

  test('un repli que la gigue couvre est refusé : la tolérance laisserait passer le repli', () => {
    const embarqueePx = [1000, 1010, 1000, 1010, 1000, 1010, 1000, 1010, 1000, 1010];
    const t = toleranceTemoin({ attenduePx: 1000, embarqueePx, repliPx: dix(1020) });
    assert.equal(t.valeur, null);
    assert.match(t.refus, /repli/);
  });

  test('un repli rendu à la longueur de la police embarquée est refusé', () => {
    const t = toleranceTemoin({ attenduePx: 1000, embarqueePx: dix(1000), repliPx: dix(1000) });
    assert.equal(t.valeur, null);
    assert.match(t.refus, /repli/);
  });

  test('une police embarquée rendue loin de ses avances est refusée : ce n’est pas elle que l’on mesure', () => {
    const t = toleranceTemoin({ attenduePx: 1000, embarqueePx: dix(1060), repliPx: dix(1200) });
    assert.equal(t.biais, 0.06);
    assert.equal(t.valeur, null);
    assert.match(t.refus, /embarquée/);
  });

  test('neuf mesures sont refusées, dix acceptées, pour chacune des deux polices', () => {
    const neuf = (valeur) => dix(valeur).slice(1);
    assert.throws(() => toleranceTemoin({ attenduePx: 1000, embarqueePx: neuf(1000), repliPx: dix(1040) }), { name: 'RangeError', message: /embarquée.*10/ });
    assert.throws(() => toleranceTemoin({ attenduePx: 1000, embarqueePx: dix(1000), repliPx: neuf(1040) }), { name: 'RangeError', message: /repli.*10/ });
    assert.equal(toleranceTemoin({ attenduePx: 1000, embarqueePx: dix(1000), repliPx: dix(1040) }).valeur, 0.01);
  });

  test('le biais se lit sur la médiane de la police embarquée : ni son premier élément, ni son min, ni son max', () => {
    // Triées : 1000 1000 1001 1001 1001 | 1003 1003 1003 1003 1009 ; la
    // médiane paire vaut (1001 + 1003) / 2 = 1002, soit un biais de 0,002.
    // Le premier élément donnerait 0,001, le min 0, le max 0,009, le seul
    // élément de droite du milieu 0,003.
    const embarqueePx = [1001, 1009, 1000, 1003, 1001, 1003, 1000, 1003, 1001, 1003];
    const t = toleranceTemoin({ attenduePx: 1000, embarqueePx, repliPx: dix(1040) });
    assert.deepEqual(t, { valeur: 0.027, ecartRepli: 0.04, gigue: 0.009, biais: 0.002, refus: null });
  });

  test('l’écart du repli se lit sur sa médiane : une valeur aberrante ne le déplace pas', () => {
    // Triées : 1020 1030 1030 1030 1030 | 1050 1050 1050 1060 2000 ; médiane
    // (1030 + 1050) / 2 = 1040, soit 0,04. Le premier élément donnerait 0,03,
    // le min 0,02, le max 1, le seul élément de droite du milieu 0,05.
    const repliPx = [1030, 1050, 1020, 1050, 1030, 1060, 1030, 1050, 2000, 1030];
    const t = toleranceTemoin({ attenduePx: 1000, embarqueePx: dix(1000), repliPx });
    assert.deepEqual(t, { valeur: 0.01, ecartRepli: 0.04, gigue: 0, biais: 0, refus: null });
  });

  test('une série de longueur impaire prend l’élément du milieu', () => {
    // Triées : 1020 1030 1030 1030 1030 1040 1050 1050 1050 1060 2000 ; la
    // médiane est 1040, et non (1030 + 1040) / 2.
    const repliPx = [1030, 1050, 1020, 1050, 1030, 1040, 1060, 1030, 1050, 2000, 1030];
    assert.equal(toleranceTemoin({ attenduePx: 1000, embarqueePx: dix(1000), repliPx }).ecartRepli, 0.04);
  });

  test('un biais égal à la tolérance est admis, un biais au-dessus refusé', () => {
    const egal = toleranceTemoin({ attenduePx: 1000, embarqueePx: dix(1010), repliPx: dix(1040) });
    assert.deepEqual(egal, { valeur: 0.01, ecartRepli: 0.04, gigue: 0, biais: 0.01, refus: null });
    const dessus = toleranceTemoin({ attenduePx: 1000, embarqueePx: dix(1011), repliPx: dix(1040) });
    assert.equal(dessus.valeur, null);
    assert.match(dessus.refus, /embarquée/);
  });

  test('une tolérance égale à l’écart du repli est refusée, une tolérance juste en dessous admise', () => {
    // Gigue : 0,02 ; trois fois, 0,06, l'écart même du repli rendu à 1060.
    const alterne = Array.from({ length: 10 }, (_, i) => (i % 2 === 0 ? 1000 : 1020));
    const egal = toleranceTemoin({ attenduePx: 1000, embarqueePx: alterne, repliPx: dix(1060) });
    assert.equal(egal.ecartRepli, 0.06);
    assert.equal(egal.valeur, null);
    assert.match(egal.refus, /repli/);
    const dessous = toleranceTemoin({ attenduePx: 1000, embarqueePx: alterne, repliPx: dix(1061) });
    assert.deepEqual(dessous, { valeur: 0.06, ecartRepli: 0.061, gigue: 0.02, biais: 0.01, refus: null });
  });

  test('moins de dix mesures, une longueur non finie ou nulle sont refusées', () => {
    assert.throws(() => toleranceTemoin({ attenduePx: 1000, embarqueePx: [1000, 1000], repliPx: dix(1040) }), RangeError);
    assert.throws(() => toleranceTemoin({ attenduePx: 0, embarqueePx: dix(1000), repliPx: dix(1040) }), RangeError);
    assert.throws(() => toleranceTemoin({ attenduePx: 1000, embarqueePx: dix(1000), repliPx: [...dix(1040).slice(1), Number.NaN] }), RangeError);
  });
});