import test from 'node:test';
import assert from 'node:assert/strict';
import {
  createWorkOrderNteService,
  getWoOpenMinNte,
} from '../src/services/workOrderNteService.js';

test('getWoOpenMinNte defaults to 400', () => {
  const prev = process.env.SC_WO_OPEN_MIN_NTE;
  delete process.env.SC_WO_OPEN_MIN_NTE;
  assert.equal(getWoOpenMinNte(), 400);
  if (prev !== undefined) process.env.SC_WO_OPEN_MIN_NTE = prev;
});

test('getWoOpenMinNte returns 0 when disabled', () => {
  const prev = process.env.SC_WO_OPEN_MIN_NTE;
  process.env.SC_WO_OPEN_MIN_NTE = '0';
  assert.equal(getWoOpenMinNte(), 0);
  if (prev !== undefined) process.env.SC_WO_OPEN_MIN_NTE = prev;
  else delete process.env.SC_WO_OPEN_MIN_NTE;
});

test('ensureWorkOrderMinimumNte skips when NTE is at or above floor', async () => {
  const { ensureWorkOrderMinimumNte } = createWorkOrderNteService({
    getWorkOrderForNte: async () => ({ Nte: 500 }),
    updateWorkOrderNte: async () => {
      throw new Error('should not PATCH');
    },
  });

  const result = await ensureWorkOrderMinimumNte(123, { minNte: 400, hintNte: 500 });
  assert.deepEqual(result, { updated: false, nte: 500 });
});

test('ensureWorkOrderMinimumNte skips when hintNte equals floor', async () => {
  let patched = false;
  const { ensureWorkOrderMinimumNte } = createWorkOrderNteService({
    getWorkOrderForNte: async () => {
      throw new Error('should not GET');
    },
    updateWorkOrderNte: async () => {
      patched = true;
    },
  });

  const result = await ensureWorkOrderMinimumNte(123, { minNte: 400, hintNte: 400 });
  assert.equal(patched, false);
  assert.deepEqual(result, { updated: false, nte: 400 });
});

test('ensureWorkOrderMinimumNte bumps when hintNte is below floor', async () => {
  let patchedTo = null;
  const { ensureWorkOrderMinimumNte } = createWorkOrderNteService({
    getWorkOrderForNte: async () => {
      throw new Error('should not GET');
    },
    updateWorkOrderNte: async (_woId, nte) => {
      patchedTo = nte;
    },
  });

  const result = await ensureWorkOrderMinimumNte(456, { minNte: 400, hintNte: 250 });
  assert.equal(patchedTo, 400);
  assert.deepEqual(result, { updated: true, previousNte: 250, nte: 400 });
});

test('ensureWorkOrderMinimumNte bumps null/zero NTE via GET fallback', async () => {
  let patchedTo = null;
  const { ensureWorkOrderMinimumNte } = createWorkOrderNteService({
    getWorkOrderForNte: async () => ({ Nte: 0 }),
    updateWorkOrderNte: async (_woId, nte) => {
      patchedTo = nte;
    },
  });

  const result = await ensureWorkOrderMinimumNte(789, { minNte: 400 });
  assert.equal(patchedTo, 400);
  assert.deepEqual(result, { updated: true, previousNte: 0, nte: 400 });
});

test('ensureWorkOrderMinimumNte skips when minNte is 0', async () => {
  const { ensureWorkOrderMinimumNte } = createWorkOrderNteService({
    getWorkOrderForNte: async () => ({ Nte: 100 }),
    updateWorkOrderNte: async () => {
      throw new Error('should not PATCH');
    },
  });

  const result = await ensureWorkOrderMinimumNte(123, { minNte: 0, hintNte: 100 });
  assert.deepEqual(result, { updated: false, skipped: true });
});