import * as request from 'supertest';
import { Test } from '@nestjs/testing';
import { INestApplication } from '@nestjs/common';
import { UserModule } from '../../src/app/user/user.module';
import { UserSchema } from '../../src/app/user/schemas/user.schema';
import mongoose from 'mongoose';
import { MongoMemoryServer } from 'mongodb-memory-server';
import { MongooseModule } from '@nestjs/mongoose';

jest.setTimeout(40000);

describe('UserController.create', () => {
  let app: INestApplication;
  let mongoServer;
  let userModel = mongoose.model('User', UserSchema);
  const seederUser = {
    tipoIdentificacion: {
      _id: new mongoose.Types.ObjectId(),
      nombre: 'Cédula',
    },
    identificacion: '123456789',
    nombres: 'Juan',
    apellidos: 'Pérez',
    email: 'juan.perez@example.com',
    password: 'Password123',
    roles: [
      {
        _id: new mongoose.Types.ObjectId(),
        nombre: 'admin',
      },
    ],
  };

  beforeAll(async () => {
    mongoServer = await MongoMemoryServer.create();
    const uri = mongoServer.getUri();
    await mongoose.connect(uri);
    userModel = mongoose.model('User', UserSchema);
  });

  afterAll(async () => {
    await mongoose.disconnect();
    await mongoServer.stop();
  });

  beforeEach(async () => {
    const moduleRef = await Test.createTestingModule({
      imports: [
        MongooseModule.forRootAsync({
          useFactory: () => ({
            uri: mongoServer.getUri(),
            useNewUrlParser: true,
            useUnifiedTopology: true,
          }),
        }),
        UserModule,
      ],
    }).compile();

    app = moduleRef.createNestApplication();
    await app.init();
  });

  afterEach(async () => {
    await userModel.deleteMany({});
    if (app) await app.close();
  });

  describe('POST users', () => {
    it('debe retornar un error 400 si no se envían datos', async () => {
      const expectResponse = {
        message: [
          'tipoIdentificacion no debe estar vacío.',
          'identificacion no debe exceder los 15 caracteres.',
          'identificacion no debe estar vacío.',
          'identificacion debe ser una cadena de texto.',
          'nombres no debe exceder los 50 caracteres.',
          'nombres no debe estar vacío.',
          'nombres debe ser una cadena de texto.',
          'apellidos no debe exceder los 50 caracteres.',
          'apellidos no debe estar vacío.',
          'apellidos debe ser una cadena de texto.',
          'email no debe exceder los 45 caracteres.',
          'email no debe estar vacío.',
          'email debe tener un formato de correo electrónico válido.',
          'La lista de roles no debe estar vacía.',
          'roles debe ser un array.',
        ],
        error: 'Bad Request',
        statusCode: 400,
      };

      const response = await request(app.getHttpServer())
        .post('/users') // Asegúrate de que la ruta sea correcta
        .set({
          'Content-Type': 'application/json',
          Accept: 'application/json',
        })
        .send({})
        .expect(400);

      expect(response.body).toEqual(expectResponse);
    });

    it('debe crear un usuario correctamente', async () => {
      const payload = seederUser;

      const response = await request(app.getHttpServer())
        .post('/users') // Asegúrate de que la ruta sea correcta
        .set({
          'Content-Type': 'application/json',
          Accept: 'application/json',
        })
        .send(payload)
        .expect(201);

      const data = response.body.data;

      expect(data.identificacion).toEqual(payload.identificacion);
      expect(data.nombres).toEqual(payload.nombres);
      expect(data.apellidos).toEqual(payload.apellidos);
      expect(data.email).toEqual(payload.email);
      expect(response.body.message).toEqual('Registro exitoso');
      expect(response.body.summary).toEqual('El elemento fue creado');
    });
  });
});