// ...other imports
import { TestBedClient } from '@nestjs-microservices-testbed/core';
import waitForExpect from 'wait-for-expect';

class ExclamationInterceptor implements NestInterceptor {
    intercept(context: ExecutionContext, next: CallHandler<any> ): Observable<any> {
        return next.handle()
            .pipe(map((result) => result + '!'));
    }
}

@Controller()
class TestAppConsumer {

    constructor(
        @Inject('TEST_CLIENT')
        private readonly client: ClientProxy,
    ) {}

    @MessagePattern('say-hello')
    @UseInterceptors(ExclamationInterceptor)
    async helloWorld(@Payload() data: string) {
        return `Hello ${data}`;
    }

    returnResponse() {
        return firstValueFrom(this.client.send('handle-response', ''));
    }

    @MessagePattern('handle-response')
    handleResponse() {
        return 'Response!';
    }

    @EventPattern('events')
    handleEvent(@Payload() data: string) {
        this.client.emit('emitted-events', data).subscribe();
    }
}


describe('Microservices Testbed', () => {

    // create instance of the test bed
    const testBed = new MicroservicesTestBed();
    let app: INestMicroservice;

    beforeAll(async () => {
        const module = await Test.createTestingModule({
            imports: [
                ClientsModule.register([{
                    name: 'TEST_SERVICE',
                    // register a custom class to be used as the client
                    customClass: testBed.getClientClass(),
                }]);
            ]
            controllers: [TestAppConsumer],
        })
        app = module.createNestMicroservice<MicroserviceOptions>({
            // retrieve the test bed server instance
            strategy: testBed.getServerInstance(),
        });
        await app.init();
    });

    afterAll(() => app.close());

    it('should handle message pattern', async () => {
        // send a message using the test bed
        const result = await testBed.handleMessage({
            pattern: 'hello-world',
            data: 'World',
        });
        // observe that your application handled the message
        // and the interceptor was triggered
        expect(result).toBe('Hello World!');
    });

    it('should handle client response', async () => {
        // invoke a method that sends a message using the client
        const result = await app.get(TestAppConsumer).returnResponse();
        // observe that a response was received through the client
        expect(result).toBe('Response!');
    });

    it('should handle event pattern', async () => {
        // emit an event using the test bed
        testBed.handleEvent({
            pattern: 'events',
            data: 'event-payload',
        });
        await waitForExpect(() => {
            // verify that your application handled the event
            // by checking that it emitted another event
            expect(
                testBed.getLastMessageForPattern('emitted-events').data
            ).toEqual(['event-payload']);
        });
    });
});