import { Test, TestingModule } from '@nestjs/testing';
import { INestApplication, ValidationPipe } from '@nestjs/common';
import request from 'supertest';
import { AppModule } from '../src/app.module';
import { CreateUserDto } from '../src/user/dto/create-user.dto';
import { UserService } from '../src/user/user.service';
import { User } from '../src/entity/user';

import dotenv from 'dotenv';
import path from 'path';
import { DvbookingApi } from './client/dvbooking.api';

dotenv.config({ path: path.resolve(process.cwd(), '.env.e2e') });

describe('UserController (e2e)', () => {
  process.env.DATA_SOURCE_ENV = '.env.e2e';
  process.env.DATABASE_HOST = 'localhost';
  process.env.DATABASE_PORT = '4401';
  process.env.DATABASE_USER = 'test';
  process.env.DATABASE_PASS = 'test';

  let app: INestApplication;
  let jwtToken: string;
  let adminUserId: number;
  let adminGroupId: number;
  let api: DvbookingApi;

  beforeAll(async () => {
    const moduleFixture: TestingModule = await Test.createTestingModule({
      imports: [AppModule],
    }).compile();

    // process.env.DATA_SOURCE_ENV=".env.e2e";
    app = moduleFixture.createNestApplication();
    app.useGlobalPipes(new ValidationPipe());
    await app.init();
    api = new DvbookingApi(app, moduleFixture);
    await api.init();
  });

  afterAll(async () => {
    await api.destroy();
    await app.close();
  });

  describe('/users', () => {
    it('(GET) should get all users', async () => {
      const response = await request(app.getHttpServer())
        .get('/users')
        .set('Authorization', `Bearer ${jwtToken}`);

      expect(response.status).toBe(200);
      expect(Array.isArray(response.body)).toBe(true);
    });

    it('(POST) should create a user', async () => {
      const createUserDto: CreateUserDto = {
        username: 'e2e_user',
        email: 'user@dvbooking.hu',
        password: 'password',
        groups: [{ id: adminGroupId }],
      };

      const response = await request(app.getHttpServer())
        .post('/users')
        .set('Authorization', `Bearer ${jwtToken}`)
        .send(createUserDto);

      expect(response.status).toBe(201);
      expect(response.body.username).toEqual(createUserDto.username);

      const userService = app.get<UserService>(UserService);
      await userService.remove(response.body.id);
    });
  });

  describe('/users/:id', () => {
    let user: User;
    let userService: UserService;

    beforeEach(async () => {
      userService = app.get<UserService>(UserService);
      await api.loginWithGroup(undefined, 'admin');
      user = api.context.user!;
    });

    afterEach(async () => {
      const userExists = await userService.findOne(user.id);
      if (userExists) {
        await userService.remove(user.id);
      }
    });

    it('(GET) should get a user by id', async () => {
      const response = await request(app.getHttpServer())
        .get(`/users/${user.id}`)
        .set('Authorization', `Bearer ${jwtToken}`);

      expect(response.status).toBe(200);
      expect(response.body.id).toEqual(user.id);
    });

    // it('(PATCH) should update a user', async () => {
    //   const updateUserDto: UpdateUserDto = {
    //     username: 'e2e_updated_user',
    //   };
    //
    //   const response = await request(app.getHttpServer())
    //     .patch(`/users/${user.id}`)
    //     .set('Authorization', `Bearer ${jwtToken}`)
    //     .send(updateUserDto);
    //
    //   expect(response.status).toBe(200);
    //   expect(response.body.username).toEqual(updateUserDto.username);
    // });
    //
    // it('(DELETE) should delete a user', async () => {
    //   const response = await request(app.getHttpServer())
    //     .delete(`/users/${user.id}`)
    //     .set('Authorization', `Bearer ${jwtToken}`);
    //
    //   expect(response.status).toBe(200);
    //
    //   const deletedUser = await userService.findOne(user.id);
    //   expect(deletedUser).toBeNull();
    // });
  });
});