import { describe, it, expect, vi } from 'vitest';
import { warmSecretCache } from '../src/bootstrap/warm-secret-cache.js';
import type { PrismaClient } from '@prisma/client';
import type { SecretService } from '../src/services/secret.service.js';

function prismaWith(servers: Array<{ name: string; env: unknown }>): PrismaClient {
  return { mcpServer: { findMany: vi.fn(async () => servers) } } as unknown as PrismaClient;
}
const noLog = { info: (): void => undefined, warn: (): void => undefined };

const envRef = (name: string, secret: string, key: string): unknown =>
  ({ name, valueFrom: { secretRef: { name: secret, key } } });

describe('warmSecretCache', () => {
  it('resolves every distinct secret ref exactly once', async () => {
    const prisma = prismaWith([
      { name: 'gitea', env: [envRef('GITEA_ACCESS_TOKEN', 'gitea-creds', 'GITEA_ACCESS_TOKEN')] },
      // Two servers sharing one secret must not cost two reads.
      { name: 'a', env: [envRef('T', 'shared', 'TOKEN')] },
      { name: 'b', env: [envRef('T', 'shared', 'TOKEN')] },
    ]);
    const resolve = vi.fn(async () => 'value');
    const result = await warmSecretCache(prisma, { resolve } as unknown as SecretService, noLog);

    expect(resolve).toHaveBeenCalledTimes(2);
    expect(result).toEqual({ warmed: 2, failed: 0 });
  });

  it('ignores inline env values', async () => {
    const prisma = prismaWith([{ name: 's', env: [{ name: 'PLAIN', value: 'x' }] }]);
    const resolve = vi.fn(async () => 'v');
    expect(await warmSecretCache(prisma, { resolve } as unknown as SecretService, noLog))
      .toEqual({ warmed: 0, failed: 0 });
    expect(resolve).not.toHaveBeenCalled();
  });

  it('never throws when the backend is down — startup must not block', async () => {
    const prisma = prismaWith([
      { name: 'a', env: [envRef('T', 's1', 'K')] },
      { name: 'b', env: [envRef('T', 's2', 'K')] },
    ]);
    const resolve = vi.fn(async () => { throw new Error('bao unreachable'); });
    await expect(warmSecretCache(prisma, { resolve } as unknown as SecretService, noLog))
      .resolves.toEqual({ warmed: 0, failed: 2 });
  });

  it('keeps going after one bad reference', async () => {
    const prisma = prismaWith([
      { name: 'a', env: [envRef('T', 'missing', 'K')] },
      { name: 'b', env: [envRef('T', 'present', 'K')] },
    ]);
    const resolve = vi.fn(async (n: string) => {
      if (n === 'missing') throw new Error('no such secret');
      return 'v';
    });
    expect(await warmSecretCache(prisma, { resolve } as unknown as SecretService, noLog))
      .toEqual({ warmed: 1, failed: 1 });
  });

  it('only considers servers with replicas > 0', async () => {
    const prisma = prismaWith([]);
    await warmSecretCache(prisma, { resolve: vi.fn() } as unknown as SecretService, noLog);
    const findMany = (prisma.mcpServer.findMany as unknown as ReturnType<typeof vi.fn>);
    expect(findMany.mock.calls[0]?.[0]).toMatchObject({ where: { replicas: { gt: 0 } } });
  });
});