'use strict';

/**
 * ONE SEAM, TWO GATES, AND A DARK DEFAULT.
 */
const sp = require('../../src/services/model/servedProbability');
const pc = require('../../src/services/model/probabilityContract');
const registry = require('../../src/services/model/artifactRegistry');
const gating = require('../../src/utils/snapshotGating');

const ERA = 'engine1@2026-08-07-fullwindow';
const A = registry.load('mlb', 'hits');
const row = (over = {}) => ({ sport: 'mlb', stat_type: 'hits', model_version: ERA,
  p_win: 0.65, confidence: 65, ev_pct: 12.3, value: true, takeable: true, model_odds: -186,
  book_odds: -110, grade: 'C+', side: 'over', player: 'P', line: 0.5, ...over });
const LIVE_ON = { live: 'ON' };

describe('live is OFF by default and that is load-bearing', () => {
  it('the default state is OFF with the flag named as the reason', () => {
    const st = pc.liveState({});
    expect(st.live).toBe('OFF');
    expect(st.flag_set).toBe(false);
    expect(st.blocked_reason).toBe('runtime flag not set');
  });

  it('rows pass through BYTE-IDENTICAL with live off', () => {
    const rows = [row(), row({ p_win: 0.91 }), row({ stat_type: 'total_bases' })];
    const before = JSON.stringify(rows);
    expect(JSON.stringify(sp.applyToRows(rows))).toBe(before);
    expect(JSON.stringify(gating.stripModelPrice(rows, 'desk'))).toBe(before);
  });

  it('only the exact string 1 sets the flag', () => {
    for (const v of ['true', 'yes', 'on', '0', ' 1 ', '', '01']) {
      expect(pc.liveState({ PROBABILITY_CONTRACT_LIVE: v }).flag_set).toBe(false);
    }
    expect(pc.liveState({ PROBABILITY_CONTRACT_LIVE: '1' }).flag_set).toBe(true);
  });
});

describe('BOTH gates are required — neither activates alone', () => {
  it('the runtime flag alone does NOT serve an unapproved artifact', () => {
    const st = pc.liveState({ PROBABILITY_CONTRACT_LIVE: '1' },
      { load: () => ({ ...A, approved_for_live: false }) });
    expect(st.flag_set).toBe(true);
    expect(st.live).toBe('OFF');
    expect(st.blocked_reason).toMatch(/not approved_for_live|not servable/);
  });

  it('the runtime flag alone does NOT serve an unservable artifact', () => {
    const st = pc.liveState({ PROBABILITY_CONTRACT_LIVE: '1' },
      { load: () => ({ ...A, approved_for_live: true, servable: false }) });
    expect(st.live).toBe('OFF');
  });

  it('artifact approval alone does NOT activate behaviour', () => {
    expect(A.approved_for_live).toBe(true);        // it IS promoted
    expect(pc.liveState({}).live).toBe('OFF');     // and behaviour is still off
  });

  it('both together turn it on', () => {
    expect(pc.liveState({ PROBABILITY_CONTRACT_LIVE: '1' }).live).toBe('ON');
  });
});

describe('when live is on', () => {
  it('a CERTIFIED row serves the calibrated number and derives everything from it', () => {
    const [out] = sp.applyToRows([row()], { liveState: LIVE_ON });
    const expected = registry.applyCurve(A, 0.65);
    expect(out.p_win).toBe(Math.round(expected * 1000) / 1000);
    expect(out.confidence).toBe(Math.round(out.p_win * 100));
    expect(out.confidence_basis).toBe('served_probability');
    expect(out.probability_state).toBe(pc.STATE.CERTIFIED_CALIBRATED);
    const { evPct } = require('../../src/utils/devig');
    expect(out.ev_pct).toBe(evPct(out.p_win, -110));
    expect(out.ev_pct).not.toBe(evPct(0.65, -110));      // NOT from raw
    expect(out.raw_model_probability).toBe(0.65);        // raw survives
    expect(out.grade).toBe('C+');                        // grade untouched
    expect(out.side).toBe('over');                       // side untouched
  });

  it('an UNCERTIFIED row loses the number AND every claim derived from it', () => {
    const [out] = sp.applyToRows([row({ p_win: 0.91, grade: 'B+' })], { liveState: LIVE_ON });
    expect(out.p_win).toBeNull();
    expect(out.confidence).toBeNull();
    expect(out.ev_pct).toBeNull();
    expect(out.value).toBeNull();
    expect(out.model_odds).toBeNull();
    expect(out.kelly).toBeNull();
    // and what must survive
    expect(out.raw_model_probability).toBe(0.91);
    expect(out.grade).toBe('B+');
    expect(out.side).toBe('over');
    expect(out.book_odds).toBe(-110);
    expect(out.player).toBe('P');                        // the Read still exists
  });

  it('a stat outside the contract is returned untouched', () => {
    const tb = row({ stat_type: 'total_bases' });
    const [out] = sp.applyToRows([tb], { liveState: LIVE_ON });
    expect(out).toEqual(tb);
  });

  it('a different model era is returned untouched', () => {
    const old = row({ model_version: 'engine1@2026-07-20' });
    const [out] = sp.applyToRows([old], { liveState: LIVE_ON });
    expect(out).toEqual(old);
  });
});

describe('one seam', () => {
  it('serving routes reach it through stripModelPrice, not by duplicating logic', () => {
    const fs = require('fs'); const path = require('path');
    const gsrc = fs.readFileSync(path.join(__dirname, '../../src/utils/snapshotGating.js'), 'utf8');
    // NOTE: a source grep is NOT proof the seam runs — the first wiring
    // contained this exact require and did nothing. The behavioural proof is in
    // "THE SEAM MUST FIRE THROUGH THE REAL BOUNDARY" below; this only checks
    // that consumers do not duplicate the logic.
    expect(gsrc).toContain("servedProbability').applyToRows(grades)");
    // no consumer may hold calibration logic of its own
    for (const f of ['src/routes/snapshot.js', 'src/routes/heroProp.js', 'src/services/topGradedService.js']) {
      const src = fs.readFileSync(path.join(__dirname, '../../', f), 'utf8')
        .replace(/\/\*[\s\S]*?\*\//g, '').replace(/^\s*\/\/.*$/gm, '');
      for (const forbidden of ['applyCurve', 'applyIsotonic', 'artifactRegistry', 'served_curve']) {
        expect(src).not.toContain(forbidden);
      }
    }
  });
});

describe('THE SEAM MUST FIRE THROUGH THE REAL BOUNDARY', () => {
  /**
   * The first wiring assigned to an undeclared `rows` instead of `grades`,
   * threw a ReferenceError under strict mode, and a bare catch swallowed it.
   * Live reported ON while every row was served raw, for a whole release.
   *
   * The old tests could not see it: they called `applyToRows` directly and
   * grepped the source for the require line. Neither exercises the boundary.
   * These call `stripModelPrice` and assert on its RETURN VALUE.
   */
  const OLD = process.env.PROBABILITY_CONTRACT_LIVE;
  beforeAll(() => { process.env.PROBABILITY_CONTRACT_LIVE = '1'; });
  afterAll(() => {
    if (OLD === undefined) delete process.env.PROBABILITY_CONTRACT_LIVE;
    else process.env.PROBABILITY_CONTRACT_LIVE = OLD;
  });

  const batch = () => ([
    row({ p_win: 0.706, confidence: 71, ev_pct: 8.7, value: false, book_odds: -185, fair_odds: -160, grade: 'B' }),
    row({ p_win: 0.858, confidence: 86, ev_pct: 51.8, value: true, book_odds: -130, fair_odds: -110, grade: 'B+', side: 'under' }),
    row({ stat_type: 'rbi', p_win: 0.65, confidence: 65, ev_pct: 12, value: true, grade: 'C+' }),
  ]);

  it('an ENTITLED caller receives the CALIBRATED rows, not the originals', () => {
    const src = batch();
    const out = gating.stripModelPrice(src, 'desk');
    const expected = registry.applyCurve(A, 0.706);
    expect(out[0].p_win).toBe(Math.round(expected * 1000) / 1000);
    expect(out[0].p_win).not.toBe(0.706);                    // the seam actually ran
    expect(out[0].probability_state).toBe(pc.STATE.CERTIFIED_CALIBRATED);
    expect(out[0].raw_model_probability).toBe(0.706);
  });

  it('EV is recomputed from the served probability at the boundary', () => {
    const out = gating.stripModelPrice(batch(), 'desk');
    const { evPct } = require('../../src/utils/devig');
    expect(out[0].ev_pct).toBe(evPct(out[0].p_win, -185));
    expect(out[0].ev_pct).not.toBe(8.7);                     // the raw-derived value
  });

  it('an UNCERTIFIED row loses its number and its TRUE value badge', () => {
    const out = gating.stripModelPrice(batch(), 'desk');
    expect(out[1].p_win).toBeNull();
    expect(out[1].confidence).toBeNull();
    expect(out[1].ev_pct).toBeNull();
    expect(out[1].value).toBeNull();                          // was true
    expect(out[1].grade).toBe('B+');                          // grade survives
    expect(out[1].raw_model_probability).toBe(0.858);
  });

  it('a non-hits row is untouched at the boundary', () => {
    const out = gating.stripModelPrice(batch(), 'desk');
    expect(out[2].p_win).toBe(0.65);
    expect(out[2].probability_state).toBeUndefined();
  });

  it('an UNENTITLED caller still gets the model fields stripped', () => {
    const out = gating.stripModelPrice(batch(), 'free');
    for (const r of out) {
      expect(r.p_win).toBeUndefined();
      expect(r.ev_pct).toBeUndefined();
      expect(r.value).toBeUndefined();
    }
  });

  it('a throwing seam degrades to uncalibrated rows and SAYS SO', () => {
    const warn = jest.spyOn(console, 'warn').mockImplementation(() => {});
    const mod = require('../../src/services/model/servedProbability');
    const real = mod.applyToRows;
    mod.applyToRows = () => { throw new Error('boom'); };
    try {
      const out = gating.stripModelPrice(batch(), 'desk');
      expect(out[0].p_win).toBe(0.706);                       // unchanged, not lost
      expect(warn).toHaveBeenCalled();                        // and not silent
    } finally { mod.applyToRows = real; warn.mockRestore(); }
  });
});