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

const claudeBinaryResolverClearCacheMock = vi.hoisted(() => vi.fn());
const codexBinaryResolverClearCacheMock = vi.hoisted(() => vi.fn());

vi.mock('@shared/utils/logger', () => ({
  createLogger: () => ({
    info: vi.fn(),
    warn: vi.fn(),
    error: vi.fn(),
    debug: vi.fn(),
  }),
}));

vi.mock('@main/services/team/ClaudeBinaryResolver', () => ({
  ClaudeBinaryResolver: {
    clearCache: claudeBinaryResolverClearCacheMock,
  },
}));

vi.mock('@main/services/infrastructure/codexAppServer', () => ({
  CodexBinaryResolver: {
    clearCache: codexBinaryResolverClearCacheMock,
  },
}));

import {
  initializeCliInstallerHandlers,
  registerCliInstallerHandlers,
} from '@main/ipc/cliInstaller';
import {
  CLI_INSTALLER_GET_PROVIDER_STATUS,
  CLI_INSTALLER_GET_STATUS,
  CLI_INSTALLER_INVALIDATE_STATUS,
  CLI_INSTALLER_VERIFY_PROVIDER_MODELS,
} from '@preload/constants/ipcChannels';
import { createDefaultCliExtensionCapabilities } from '@shared/utils/providerExtensionCapabilities';

import type { CliInstallerService } from '@main/services';
import type {
  CliInstallationStatus,
  CliProviderId,
  CliProviderStatus,
  IpcResult,
} from '@shared/types';
import type { IpcMain, IpcMainInvokeEvent } from 'electron';

type IpcHandler = (event: IpcMainInvokeEvent, ...args: unknown[]) => unknown;

function deferred<T>(): {
  promise: Promise<T>;
  resolve: (value: T) => void;
  reject: (reason?: unknown) => void;
} {
  let resolve!: (value: T) => void;
  let reject!: (reason?: unknown) => void;
  const promise = new Promise<T>((innerResolve, innerReject) => {
    resolve = innerResolve;
    reject = innerReject;
  });
  return { promise, resolve, reject };
}

function createMockIpcMain(): IpcMain & {
  invoke: (channel: string, ...args: unknown[]) => Promise<unknown>;
} {
  const handlers = new Map<string, IpcHandler>();
  const ipcMain = {
    handle: vi.fn((channel: string, handler: IpcHandler) => {
      handlers.set(channel, handler);
    }),
    removeHandler: vi.fn((channel: string) => {
      handlers.delete(channel);
    }),
    invoke: async (channel: string, ...args: unknown[]) => {
      const handler = handlers.get(channel);
      if (!handler) {
        throw new Error(`No handler for ${channel}`);
      }
      return await Promise.resolve(handler({} as IpcMainInvokeEvent, ...args));
    },
  };
  return ipcMain as unknown as IpcMain & {
    invoke: (channel: string, ...args: unknown[]) => Promise<unknown>;
  };
}

function provider(overrides: Partial<CliProviderStatus> & { providerId: CliProviderId }): CliProviderStatus {
  const { providerId, ...rest } = overrides;
  return {
    providerId,
    displayName: providerId,
    supported: true,
    authenticated: false,
    authMethod: null,
    verificationState: 'unknown',
    modelVerificationState: 'idle',
    modelCatalogRefreshState: 'idle',
    statusMessage: null,
    detailMessage: null,
    models: [],
    modelAvailability: [],
    canLoginFromUi: providerId !== 'opencode',
    capabilities: {
      teamLaunch: true,
      oneShot: true,
      extensions: createDefaultCliExtensionCapabilities(),
    },
    selectedBackendId: null,
    resolvedBackendId: null,
    availableBackends: [],
    externalRuntimeDiagnostics: [],
    backend: null,
    connection: null,
    modelCatalog: null,
    runtimeCapabilities: null,
    subscriptionRateLimits: null,
    ...rest,
  };
}

function status(providers: CliProviderStatus[]): CliInstallationStatus {
  const authenticatedProvider = providers.find((entry) => entry.authenticated) ?? null;
  return {
    flavor: 'agent_teams_orchestrator',
    displayName: 'Multimodel runtime',
    supportsSelfUpdate: false,
    showVersionDetails: false,
    showBinaryPath: false,
    installed: true,
    installedVersion: '0.0.3',
    binaryPath: '/mock/agent_teams_orchestrator',
    launchError: null,
    latestVersion: null,
    updateAvailable: false,
    authLoggedIn: authenticatedProvider !== null,
    authStatusChecking: false,
    authMethod: authenticatedProvider?.authMethod ?? null,
    providers,
  };
}

describe('cliInstaller IPC handlers', () => {
  let ipcMain: ReturnType<typeof createMockIpcMain>;
  let service: {
    getLatestStatusSnapshot: ReturnType<typeof vi.fn>;
    getStatus: ReturnType<typeof vi.fn>;
    getProviderStatus: ReturnType<typeof vi.fn>;
    verifyProviderModels: ReturnType<typeof vi.fn>;
    install: ReturnType<typeof vi.fn>;
    invalidateStatusCache: ReturnType<typeof vi.fn>;
  };

  beforeEach(async () => {
    vi.clearAllMocks();
    ipcMain = createMockIpcMain();
    service = {
      getLatestStatusSnapshot: vi.fn(() => null),
      getStatus: vi.fn(),
      getProviderStatus: vi.fn(),
      verifyProviderModels: vi.fn(),
      install: vi.fn(),
      invalidateStatusCache: vi.fn(),
    };
    initializeCliInstallerHandlers(service as unknown as CliInstallerService);
    registerCliInstallerHandlers(ipcMain);
    await ipcMain.invoke(CLI_INSTALLER_INVALIDATE_STATUS);
    vi.clearAllMocks();
  });

  it('does not let explicit hidden Gemini refresh poison cached frontend auth status', async () => {
    service.getStatus.mockResolvedValue(
      status([
        provider({ providerId: 'anthropic' }),
        provider({ providerId: 'codex' }),
        provider({ providerId: 'opencode', canLoginFromUi: false }),
      ])
    );
    service.getProviderStatus.mockResolvedValue(
      provider({
        providerId: 'gemini',
        authenticated: true,
        authMethod: 'gemini_api_key',
        models: ['gemini-2.5-pro'],
      })
    );

    const initial = (await ipcMain.invoke(CLI_INSTALLER_GET_STATUS)) as IpcResult<CliInstallationStatus>;
    expect(initial.success).toBe(true);
    expect(initial.data?.providers.map((entry) => entry.providerId)).toEqual([
      'anthropic',
      'codex',
      'opencode',
    ]);

    const gemini = (await ipcMain.invoke(
      CLI_INSTALLER_GET_PROVIDER_STATUS,
      'gemini'
    )) as IpcResult<CliProviderStatus | null>;
    expect(gemini.success).toBe(true);
    expect(gemini.data?.authenticated).toBe(true);

    const cached = (await ipcMain.invoke(CLI_INSTALLER_GET_STATUS)) as IpcResult<CliInstallationStatus>;
    expect(service.getStatus).toHaveBeenCalledTimes(1);
    expect(cached.success).toBe(true);
    expect(cached.data?.providers.map((entry) => entry.providerId)).toEqual([
      'anthropic',
      'codex',
      'opencode',
    ]);
    expect(cached.data?.authLoggedIn).toBe(false);
    expect(cached.data?.authMethod).toBeNull();
  });

  it('clears Claude and Codex binary resolver caches when status is invalidated', async () => {
    const result = (await ipcMain.invoke(CLI_INSTALLER_INVALIDATE_STATUS)) as IpcResult<void>;

    expect(result.success).toBe(true);
    expect(claudeBinaryResolverClearCacheMock).toHaveBeenCalledTimes(1);
    expect(codexBinaryResolverClearCacheMock).toHaveBeenCalledTimes(1);
    expect(service.invalidateStatusCache).toHaveBeenCalledTimes(1);
  });

  it('serializes explicit provider runtime status requests to avoid startup memory spikes', async () => {
    const codexRequest = deferred<CliProviderStatus>();
    const opencodeRequest = deferred<CliProviderStatus>();
    const startedProviders: CliProviderId[] = [];
    service.getProviderStatus.mockImplementation((providerId: CliProviderId) => {
      startedProviders.push(providerId);
      return providerId === 'codex' ? codexRequest.promise : opencodeRequest.promise;
    });

    const codexInvoke = ipcMain.invoke(
      CLI_INSTALLER_GET_PROVIDER_STATUS,
      'codex'
    ) as Promise<IpcResult<CliProviderStatus | null>>;
    await vi.waitFor(() => expect(service.getProviderStatus).toHaveBeenCalledTimes(1));

    const opencodeInvoke = ipcMain.invoke(
      CLI_INSTALLER_GET_PROVIDER_STATUS,
      'opencode'
    ) as Promise<IpcResult<CliProviderStatus | null>>;
    await Promise.resolve();
    await Promise.resolve();

    expect(startedProviders).toEqual(['codex']);
    expect(service.getProviderStatus).toHaveBeenCalledTimes(1);

    codexRequest.resolve(provider({ providerId: 'codex', authenticated: true }));
    await expect(codexInvoke).resolves.toMatchObject({
      success: true,
      data: { providerId: 'codex' },
    });
    await vi.waitFor(() => expect(service.getProviderStatus).toHaveBeenCalledTimes(2));

    expect(startedProviders).toEqual(['codex', 'opencode']);
    opencodeRequest.resolve(provider({ providerId: 'opencode', authenticated: true }));
    await expect(opencodeInvoke).resolves.toMatchObject({
      success: true,
      data: { providerId: 'opencode' },
    });
  });

  it('does not reuse or recache a status request that was in flight before invalidation', async () => {
    const staleStatus = status([
      provider({
        providerId: 'codex',
        verificationState: 'error',
        statusMessage: 'Codex CLI not found',
      }),
    ]);
    const freshStatus = status([
      provider({
        providerId: 'codex',
        authenticated: true,
        authMethod: 'chatgpt',
        verificationState: 'verified',
        statusMessage: 'ChatGPT account ready',
      }),
    ]);
    const staleRequest = deferred<CliInstallationStatus>();
    const freshRequest = deferred<CliInstallationStatus>();
    service.getStatus
      .mockReturnValueOnce(staleRequest.promise)
      .mockReturnValueOnce(freshRequest.promise);

    const firstInvoke = ipcMain.invoke(CLI_INSTALLER_GET_STATUS) as Promise<
      IpcResult<CliInstallationStatus>
    >;
    await vi.waitFor(() => expect(service.getStatus).toHaveBeenCalledTimes(1));

    await ipcMain.invoke(CLI_INSTALLER_INVALIDATE_STATUS);
    const secondInvoke = ipcMain.invoke(CLI_INSTALLER_GET_STATUS) as Promise<
      IpcResult<CliInstallationStatus>
    >;
    await vi.waitFor(() => expect(service.getStatus).toHaveBeenCalledTimes(2));

    staleRequest.resolve(staleStatus);
    freshRequest.resolve(freshStatus);

    await expect(firstInvoke).resolves.toMatchObject({
      success: true,
      data: { authLoggedIn: false },
    });
    await expect(secondInvoke).resolves.toMatchObject({
      success: true,
      data: { authLoggedIn: true, authMethod: 'chatgpt' },
    });

    const cached = (await ipcMain.invoke(CLI_INSTALLER_GET_STATUS)) as IpcResult<CliInstallationStatus>;

    expect(service.getStatus).toHaveBeenCalledTimes(2);
    expect(cached.success).toBe(true);
    expect(cached.data?.authLoggedIn).toBe(true);
    expect(cached.data?.providers[0]?.statusMessage).toBe('ChatGPT account ready');
  });

  it('keeps lightweight startup status cache separate from full provider status cache', async () => {
    const deferredStartupStatus = status([
      provider({
        providerId: 'anthropic',
        supported: false,
        statusMessage: 'Provider status will refresh when needed.',
      }),
      provider({
        providerId: 'codex',
        supported: false,
        statusMessage: 'Provider status will refresh when needed.',
      }),
    ]);
    const fullStatus = status([
      provider({
        providerId: 'anthropic',
        authenticated: true,
        authMethod: 'oauth_token',
        verificationState: 'verified',
        statusMessage: 'Connected',
      }),
      provider({
        providerId: 'codex',
        authenticated: true,
        authMethod: 'chatgpt',
        verificationState: 'verified',
        statusMessage: 'ChatGPT account ready',
      }),
    ]);
    const startupRequest = deferred<CliInstallationStatus>();
    const fullRequest = deferred<CliInstallationStatus>();
    service.getStatus.mockImplementation((options?: { providerStatusMode?: string }) =>
      options?.providerStatusMode === 'defer' ? startupRequest.promise : fullRequest.promise
    );

    const startupInvoke = ipcMain.invoke(CLI_INSTALLER_GET_STATUS, {
      providerStatusMode: 'defer',
    }) as Promise<IpcResult<CliInstallationStatus>>;
    const fullInvoke = ipcMain.invoke(CLI_INSTALLER_GET_STATUS) as Promise<
      IpcResult<CliInstallationStatus>
    >;
    await vi.waitFor(() => expect(service.getStatus).toHaveBeenCalledTimes(2));

    startupRequest.resolve(deferredStartupStatus);
    fullRequest.resolve(fullStatus);

    await expect(startupInvoke).resolves.toMatchObject({
      success: true,
      data: { authLoggedIn: false },
    });
    await expect(fullInvoke).resolves.toMatchObject({
      success: true,
      data: { authLoggedIn: true, authMethod: 'oauth_token' },
    });

    const cachedStartup = (await ipcMain.invoke(CLI_INSTALLER_GET_STATUS, {
      providerStatusMode: 'defer',
    })) as IpcResult<CliInstallationStatus>;
    const cachedFull = (await ipcMain.invoke(
      CLI_INSTALLER_GET_STATUS
    )) as IpcResult<CliInstallationStatus>;

    expect(service.getStatus).toHaveBeenCalledTimes(2);
    expect(cachedStartup.data?.authLoggedIn).toBe(false);
    expect(cachedStartup.data?.providers[0]?.statusMessage).toBe(
      'Provider status will refresh when needed.'
    );
    expect(cachedFull.data?.authLoggedIn).toBe(true);
    expect(cachedFull.data?.providers[1]?.statusMessage).toBe('ChatGPT account ready');
  });

  it('does not replace a cached full provider status with a deferred startup snapshot', async () => {
    const fullStatus = status([
      provider({
        providerId: 'anthropic',
        authenticated: true,
        authMethod: 'oauth_token',
        verificationState: 'verified',
        statusMessage: 'Connected',
      }),
    ]);
    const deferredStartupStatus = status([
      provider({
        providerId: 'anthropic',
        supported: false,
        verificationState: 'unknown',
        statusMessage: 'Provider status will refresh when needed.',
      }),
    ]);
    service.getStatus.mockResolvedValueOnce(fullStatus);

    const first = (await ipcMain.invoke(CLI_INSTALLER_GET_STATUS)) as IpcResult<CliInstallationStatus>;
    expect(first.success).toBe(true);
    expect(first.data?.providers[0]?.statusMessage).toBe('Connected');

    service.getLatestStatusSnapshot.mockReturnValue(deferredStartupStatus);
    const cached = (await ipcMain.invoke(
      CLI_INSTALLER_GET_STATUS
    )) as IpcResult<CliInstallationStatus>;

    expect(service.getStatus).toHaveBeenCalledTimes(1);
    expect(cached.success).toBe(true);
    expect(cached.data?.authLoggedIn).toBe(true);
    expect(cached.data?.providers[0]?.statusMessage).toBe('Connected');
  });

  it('does not cache incomplete full provider status responses', async () => {
    const incompleteFullStatus = status([
      provider({
        providerId: 'anthropic',
        supported: false,
        verificationState: 'unknown',
        statusMessage: 'Provider status will refresh when needed.',
      }),
      provider({
        providerId: 'codex',
        supported: false,
        verificationState: 'unknown',
        statusMessage: 'Checking...',
      }),
    ]);
    const freshFullStatus = status([
      provider({
        providerId: 'anthropic',
        authenticated: true,
        authMethod: 'oauth_token',
        verificationState: 'verified',
        statusMessage: 'Connected',
      }),
      provider({
        providerId: 'codex',
        authenticated: true,
        authMethod: 'chatgpt',
        verificationState: 'verified',
        statusMessage: 'ChatGPT account ready',
      }),
    ]);
    incompleteFullStatus.authStatusChecking = true;
    service.getStatus
      .mockResolvedValueOnce(incompleteFullStatus)
      .mockResolvedValueOnce(freshFullStatus);

    const first = (await ipcMain.invoke(CLI_INSTALLER_GET_STATUS)) as IpcResult<CliInstallationStatus>;
    const second = (await ipcMain.invoke(CLI_INSTALLER_GET_STATUS)) as IpcResult<CliInstallationStatus>;

    expect(service.getStatus).toHaveBeenCalledTimes(2);
    expect(first.success).toBe(true);
    expect(first.data?.providers[0]?.statusMessage).toBe(
      'Provider status will refresh when needed.'
    );
    expect(second.success).toBe(true);
    expect(second.data?.authLoggedIn).toBe(true);
    expect(second.data?.providers[0]?.statusMessage).toBe('Connected');
  });

  it('does not let a stale in-flight provider refresh patch the cache after invalidation', async () => {
    const staleProviderRequest = deferred<CliProviderStatus | null>();
    service.getStatus
      .mockResolvedValueOnce(
        status([
          provider({ providerId: 'anthropic' }),
          provider({ providerId: 'codex', statusMessage: 'Checking...' }),
        ])
      )
      .mockResolvedValueOnce(
        status([
          provider({ providerId: 'anthropic' }),
          provider({
            providerId: 'codex',
            authenticated: true,
            authMethod: 'chatgpt',
            verificationState: 'verified',
            statusMessage: 'ChatGPT account ready',
          }),
        ])
      );
    service.getProviderStatus.mockReturnValueOnce(staleProviderRequest.promise);

    const initial = (await ipcMain.invoke(CLI_INSTALLER_GET_STATUS)) as IpcResult<CliInstallationStatus>;
    expect(initial.success).toBe(true);
    expect(initial.data?.authLoggedIn).toBe(false);

    const staleProviderInvoke = ipcMain.invoke(
      CLI_INSTALLER_GET_PROVIDER_STATUS,
      'codex'
    ) as Promise<IpcResult<CliProviderStatus | null>>;
    await vi.waitFor(() => expect(service.getProviderStatus).toHaveBeenCalledTimes(1));

    await ipcMain.invoke(CLI_INSTALLER_INVALIDATE_STATUS);
    const fresh = (await ipcMain.invoke(CLI_INSTALLER_GET_STATUS)) as IpcResult<CliInstallationStatus>;
    expect(fresh.success).toBe(true);
    expect(fresh.data?.authLoggedIn).toBe(true);

    staleProviderRequest.resolve(
      provider({
        providerId: 'codex',
        verificationState: 'error',
        statusMessage: 'Codex CLI not found',
      })
    );
    await expect(staleProviderInvoke).resolves.toMatchObject({
      success: true,
      data: { statusMessage: 'Codex CLI not found' },
    });

    const cached = (await ipcMain.invoke(CLI_INSTALLER_GET_STATUS)) as IpcResult<CliInstallationStatus>;

    expect(service.getStatus).toHaveBeenCalledTimes(2);
    expect(cached.success).toBe(true);
    expect(cached.data?.authLoggedIn).toBe(true);
    expect(cached.data?.providers.find((entry) => entry.providerId === 'codex')?.statusMessage).toBe(
      'ChatGPT account ready'
    );
  });

  it('does not let a stale model verification patch the cache after invalidation', async () => {
    const staleVerificationRequest = deferred<CliProviderStatus | null>();
    service.getStatus
      .mockResolvedValueOnce(
        status([
          provider({ providerId: 'anthropic' }),
          provider({ providerId: 'codex', statusMessage: 'Checking...' }),
        ])
      )
      .mockResolvedValueOnce(
        status([
          provider({ providerId: 'anthropic' }),
          provider({
            providerId: 'codex',
            authenticated: true,
            authMethod: 'chatgpt',
            verificationState: 'verified',
            statusMessage: 'ChatGPT account ready',
          }),
        ])
      );
    service.verifyProviderModels.mockReturnValueOnce(staleVerificationRequest.promise);

    const initial = (await ipcMain.invoke(
      CLI_INSTALLER_GET_STATUS
    )) as IpcResult<CliInstallationStatus>;
    expect(initial.success).toBe(true);
    expect(initial.data?.authLoggedIn).toBe(false);

    const staleVerificationInvoke = ipcMain.invoke(
      CLI_INSTALLER_VERIFY_PROVIDER_MODELS,
      'codex'
    ) as Promise<IpcResult<CliProviderStatus | null>>;
    await vi.waitFor(() => expect(service.verifyProviderModels).toHaveBeenCalledTimes(1));

    await ipcMain.invoke(CLI_INSTALLER_INVALIDATE_STATUS);
    const fresh = (await ipcMain.invoke(
      CLI_INSTALLER_GET_STATUS
    )) as IpcResult<CliInstallationStatus>;
    expect(fresh.success).toBe(true);
    expect(fresh.data?.authLoggedIn).toBe(true);

    staleVerificationRequest.resolve(
      provider({
        providerId: 'codex',
        verificationState: 'error',
        statusMessage: 'Stale model verification failed',
      })
    );
    await expect(staleVerificationInvoke).resolves.toMatchObject({
      success: true,
      data: { statusMessage: 'Stale model verification failed' },
    });

    const cached = (await ipcMain.invoke(
      CLI_INSTALLER_GET_STATUS
    )) as IpcResult<CliInstallationStatus>;

    expect(service.getStatus).toHaveBeenCalledTimes(2);
    expect(cached.success).toBe(true);
    expect(cached.data?.authLoggedIn).toBe(true);
    expect(cached.data?.providers.find((entry) => entry.providerId === 'codex')?.statusMessage).toBe(
      'ChatGPT account ready'
    );
  });
});