import assert from 'node:assert/strict';
import test from 'node:test';

import { createPricingProvider, createPricingProviderRegistry } from '../../api/src/modules/pricing/providers/pricing-provider.js';
import { processNextPersistentPricingRefreshJob, runPricingRefreshJob } from '../src/pricing-refresh-worker.js';

test('completes a pricing refresh through the provider and pricing service boundaries', async () => {
  const providerRegistry = createPricingProviderRegistry([
    createPricingProvider({
      id: 'fixture-provider',
      async observe() {
        return [{ priceMinor: 2500, sourceIdentifier: 'fixture-1' }];
      },
    }),
  ]);
  const saved = [];
  const result = await runPricingRefreshJob({
    job: {
      id: 'job-1',
      type: 'PRICING_REFRESH',
      providerId: 'fixture-provider',
      sellerId: 'seller-1',
      productId: 'product-1',
      inventoryItemId: 'inventory-1',
      conditionId: 'condition-1',
    },
    providerRegistry,
    pricingService: {
      async addObservation(input) { saved.push(input); return input; },
      async calculate() { return { valuation: { valueMinor: 2500 } }; },
    },
  });

  assert.equal(result.status, 'COMPLETED');
  assert.equal(result.valuation.valuation.valueMinor, 2500);
  assert.equal(saved[0].providerId, 'fixture-provider');
});

test('fails a refresh clearly when a provider is unavailable', async () => {
  const result = await runPricingRefreshJob({
    job: { id: 'job-2', type: 'PRICING_REFRESH', providerId: 'missing' },
    providerRegistry: createPricingProviderRegistry(),
    pricingService: {},
  });

  assert.equal(result.status, 'FAILED');
  assert.match(result.error, /not configured/);
});

test('persists completed and failed outcomes through the job repository', async () => {
  const calls = [];
  const jobRepository = {
    async claimNext() { return { id: 'job-3', type: 'PRICING_REFRESH', providerId: 'fixture' }; },
    async complete(id, observations, valuation) { calls.push(['complete', id, observations, valuation]); },
    async fail(id, error) { calls.push(['fail', id, error]); },
  };

  await processNextPersistentPricingRefreshJob({
    jobRepository,
    async pricingRefreshJob() { return { status: 'COMPLETED', observations: [{ id: 'observation-1' }], valuation: { valueMinor: 2500 } }; },
  });

  assert.deepEqual(calls, [['complete', 'job-3', [{ id: 'observation-1' }], { valueMinor: 2500 }]]);
});

test('persists failed pricing refresh outcomes through the repository', async () => {
  const calls = [];
  await processNextPersistentPricingRefreshJob({
    jobRepository: {
      async claimNext() { return { id: 'job-4' }; },
      async complete() { throw new Error('not expected'); },
      async fail(id, error) { calls.push([id, error]); },
    },
    async pricingRefreshJob() { return { status: 'FAILED', error: 'Provider unavailable.' }; },
  });

  assert.deepEqual(calls, [['job-4', 'Provider unavailable.']]);
});