import { Test, TestingModule } from '@nestjs/testing';
import { AuditEventsController } from './audit-events.controller';
import { AuditEventsService } from './audit-events.service';
import { AuditEventsFeatureGuard } from './guards/audit-events-feature.guard';
import { AuditEventsRateLimitGuard } from './guards/audit-events-rate-limit.guard';
import { ServiceCredentialGuard } from '../common/guards/service-credential/service-credential.guard';

describe('AuditEventsController', () => {
  let controller: AuditEventsController;

  const mockService = {
    createBatch: jest.fn(),
    findAll: jest.fn(),
    findRollups: jest.fn(),
    getAhaMetrics: jest.fn(),
    getActiveAhaRule: jest.fn(),
    listAhaRuleVersions: jest.fn(),
    createAhaRuleVersion: jest.fn(),
    listAhaProgress: jest.fn(),
    getAhaRuleSnippet: jest.fn(),
    previewRollups: jest.fn(),
    runRollups: jest.fn(),
    pruneRolledUpEvents: jest.fn(),
    deleteRollups: jest.fn(),
    deleteSelectedRollups: jest.fn(),
    deleteSelectedAuditEvents: jest.fn(),
    deleteAuditEvents: jest.fn(),
  };

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      controllers: [AuditEventsController],
      providers: [{ provide: AuditEventsService, useValue: mockService }],
    })
      .overrideGuard(AuditEventsFeatureGuard)
      .useValue({ canActivate: () => true })
      .overrideGuard(AuditEventsRateLimitGuard)
      .useValue({ canActivate: () => true })
      .overrideGuard(ServiceCredentialGuard)
      .useValue({ canActivate: () => true })
      .compile();

    controller = module.get<AuditEventsController>(AuditEventsController);
  });

  afterEach(() => jest.clearAllMocks());

  it('should be defined', () => {
    expect(controller).toBeDefined();
  });

  it('delegates createBatch to the service', async () => {
    mockService.createBatch.mockResolvedValue({ accepted: 1 });
    const result = await controller.create({ events: [] }, undefined);
    expect(mockService.createBatch).toHaveBeenCalledWith([], undefined);
    expect(result).toEqual({ accepted: 1 });
  });

  it('delegates findAll to the service', async () => {
    mockService.findAll.mockResolvedValue([]);
    const result = await controller.findAll({});
    expect(mockService.findAll).toHaveBeenCalled();
    expect(result).toEqual([]);
  });
});