import { afterEach, describe, expect, it, vi } from 'vitest';
import { net } from 'electron';
import { proxyAwareFetch } from '@electron/utils/proxy-fetch';

const originalElectronVersion = Object.getOwnPropertyDescriptor(process.versions, 'electron');

function setElectronVersion(version: string | undefined): void {
  if (version === undefined) {
    delete (process.versions as NodeJS.ProcessVersions & { electron?: string }).electron;
    return;
  }
  Object.defineProperty(process.versions, 'electron', {
    configurable: true,
    value: version,
  });
}

afterEach(() => {
  vi.unstubAllGlobals();
  vi.mocked(net.fetch).mockReset();
  if (originalElectronVersion) {
    Object.defineProperty(process.versions, 'electron', originalElectronVersion);
  } else {
    setElectronVersion(undefined);
  }
});

describe('proxyAwareFetch', () => {
  it('uses Electron net.fetch without dynamically importing the Electron namespace', async () => {
    setElectronVersion('43.4.0');
    const response = new Response('electron');
    vi.mocked(net.fetch).mockResolvedValue(response);

    await expect(proxyAwareFetch('https://example.test')).resolves.toBe(response);
    expect(net.fetch).toHaveBeenCalledWith('https://example.test', undefined);
  });

  it('does not replay a mutation through global fetch after Electron net.fetch fails', async () => {
    setElectronVersion('43.4.0');
    const transportError = new Error('response transport failed');
    const fetchMock = vi.fn();
    vi.mocked(net.fetch).mockRejectedValue(transportError);
    vi.stubGlobal('fetch', fetchMock);

    await expect(proxyAwareFetch('https://example.test/quote', {
      method: 'PATCH',
      body: JSON.stringify({ aspect_ratio: '16:9' }),
    })).rejects.toBe(transportError);

    expect(net.fetch).toHaveBeenCalledOnce();
    expect(fetchMock).not.toHaveBeenCalled();
  });

  it('retains the global fallback for safe reads after Electron net.fetch fails', async () => {
    setElectronVersion('43.4.0');
    const response = new Response('node fallback');
    const fetchMock = vi.fn().mockResolvedValue(response);
    vi.mocked(net.fetch).mockRejectedValue(new Error('electron transport failed'));
    vi.stubGlobal('fetch', fetchMock);

    await expect(proxyAwareFetch('https://example.test/read', {
      method: 'GET',
    })).resolves.toBe(response);

    expect(fetchMock).toHaveBeenCalledWith('https://example.test/read', { method: 'GET' });
  });

  it('uses the global fetch outside Electron', async () => {
    setElectronVersion(undefined);
    const response = new Response('node');
    const fetchMock = vi.fn().mockResolvedValue(response);
    vi.stubGlobal('fetch', fetchMock);

    await expect(proxyAwareFetch('https://example.test')).resolves.toBe(response);
    expect(fetchMock).toHaveBeenCalledWith('https://example.test', undefined);
    expect(net.fetch).not.toHaveBeenCalled();
  });
});