import { describe, expect, it } from 'vitest';

import { createAdapter } from './src/adapters.js';
import { parseHarnessOptions } from './src/options.js';
import { BlockedOnInfraError } from './src/outcomes.js';
import { LegacyFixtureSeeder } from './src/legacy-fixtures.js';
import { enableNetworkFamilyAutoselection, loadCapabilityEnv } from './src/env.mjs';

describe('capability harness configuration', () => {
  it('selects legacy dialect from the required CLI flag', () => {
    expect(parseHarnessOptions(['--adapter=legacy'], {})).toEqual({
      adapter: 'legacy',
      baseUrl: 'https://api.press.zone',
    });
  });

  it('requires BASE_URL for platform runs', () => {
    expect(() => parseHarnessOptions(['--adapter=platform'], {})).toThrow('BASE_URL');
  });

  it('uses platform URL preserved by the npm runner', () => {
    expect(parseHarnessOptions([], {
      CAPABILITY_ADAPTER: 'platform',
      CAPABILITY_BASE_URL: 'https://worker.invalid',
      BASE_URL: '/',
    }).baseUrl).toBe('https://worker.invalid');
  });

  it('accepts adapter forwarded by the npm runner', () => {
    expect(parseHarnessOptions([], { CAPABILITY_ADAPTER: 'legacy' })).toEqual({
      adapter: 'legacy',
      baseUrl: 'https://api.press.zone',
    });
  });

  it('does not let Vitest BASE_URL override the fixed legacy oracle', () => {
    expect(parseHarnessOptions([], { CAPABILITY_ADAPTER: 'legacy', BASE_URL: '/' }).baseUrl)
      .toBe('https://api.press.zone');
  });

  it('maps one capability request through each adapter dialect', () => {
    const legacy = createAdapter('legacy', 'https://api.press.zone');
    const platform = createAdapter('platform', 'https://worker.invalid');

    expect(legacy.request('translate', 'secret')).toEqual({
      url: 'https://api.press.zone/v1/translate',
      headers: {
        Authorization: 'Bearer secret',
        'Content-Type': 'application/json',
        'X-Plugin': 'international',
      },
    });
    expect(platform.request('translate', 'prefix.secret')).toMatchObject({
      url: 'https://worker.invalid/api/translate',
      headers: { Authorization: 'Bearer prefix.secret' },
    });
    expect(legacy.request('exceptionsSync').url).toBe('https://api.press.zone/v1/exceptions/sync');
    expect(legacy.request('account', 'secret').url).toBe('https://api.press.zone/v1/account/credits');
  });

  it('represents missing callback reachability as infrastructure blocking', () => {
    const error = new BlockedOnInfraError('collector unavailable');
    expect(error.message).toBe('collector unavailable');
  });

  it('adds the legacy plugin entitlement header', () => {
    expect(createAdapter('legacy', 'https://api.press.zone').request('translate', 'secret').headers)
      .toMatchObject({ 'X-Plugin': 'international' });
  });

  it('seeds and removes legacy fixtures through the oracle database executor', async () => {
    const statements: string[] = [];
    const seeder = new LegacyFixtureSeeder({ LEGACY_ORACLE_DB_HOST: 'oracle.invalid' }, async (sql) => {
      statements.push(sql);
    });
    await seeder.initialize();
    const fixture = await seeder.seedCredential('international', 24, 'low-credit');
    await seeder.revoke(fixture);
    await seeder.cleanup();

    expect(fixture.apiKey).toMatch(/^sk_test_/);
    expect(statements[0]).toContain('INSERT INTO users');
    expect(statements[0]).toContain('INSERT INTO subscriptions');
    expect(statements[0]).toContain('INSERT INTO api_keys');
    expect(statements[0]).toContain('INSERT INTO credit_transactions');
    expect(statements[1]).toContain('UPDATE api_keys SET is_active = false');
    expect(statements[2]).toContain('DELETE FROM users');
    expect(statements.join('\n')).not.toContain(fixture.apiKey);
  });

  it('loads missing capability variables without overriding explicit environment', () => {
    const env = { LEGACY_ADMIN_EMAIL: 'explicit@example.test' };
    loadCapabilityEnv('LEGACY_ADMIN_EMAIL=file@example.test\nLEGACY_ADMIN_PASSWORD="secret value"\n', env);
    expect(env).toEqual({
      LEGACY_ADMIN_EMAIL: 'explicit@example.test',
      LEGACY_ADMIN_PASSWORD: 'secret value',
    });
  });

  it('enables IPv4 fallback without discarding existing Node options', () => {
    expect(enableNetworkFamilyAutoselection('--trace-warnings'))
      .toBe('--trace-warnings --enable-network-family-autoselection');
    expect(enableNetworkFamilyAutoselection('--enable-network-family-autoselection'))
      .toBe('--enable-network-family-autoselection');
  });
});