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(30000);

describe('UserController (e2e) - GET /users/:id', () => {
  let app: INestApplication;
  let mongoServer;
  let userModel = mongoose.model('User', UserSchema);
  let user;

  // Seeder para el usuario de prueba
  const seederUser = {
    tipoIdentificacion: [
      {
        _id: new mongoose.Types.ObjectId(),
        nombre: 'Cédula de ciudadanía',
      },
    ],
    identificacion: '123456789',
    nombres: 'Juan',
    apellidos: 'Pérez',
    email: 'juan.perez@example.com',
    password: 'securepassword123',
    roles: [
      {
        _id: new mongoose.Types.ObjectId(),
        nombre: 'Administrador',
      },
    ],
  };

  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();

    // Crear usuario de prueba en la base de datos
    user = await userModel.create(seederUser);
    app = moduleRef.createNestApplication();
    await app.init();
  });

  afterEach(async () => {
    // Limpiar la base de datos después de cada prueba
    await userModel.deleteMany({});
    if (app) await app.close();
  });

  describe('GET /users/:id', () => {
    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')
        .set({
          'Content-Type': 'application/json',
          Accept: 'application/json',
        })
        .send({})
        .expect(400);

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

    it('debe retornar un usuario por su ID', async () => {
      const expectResponsee = {
        data: {
          _id: user._id.toString(),
          tipoIdentificacion: [
            {
              _id: user.tipoIdentificacion[0]._id.toString(),
              nombre: user.tipoIdentificacion[0].nombre,
            },
          ],
          identificacion: user.identificacion,
          nombres: user.nombres,
          apellidos: user.apellidos,
          email: user.email,
          roles: [
            {
              _id: user.roles[0]._id.toString(),
              nombre: user.roles[0].nombre,
            },
          ],
        },
        message: 'Consulta exitosa',
        summary: 'El elemento fue encontrado',
      };

      const response = await request(app.getHttpServer())
        .get(`/users/${user._id}`)
        .set({
          'Content-Type': 'application/json',
          Accept: 'application/json',
        })
        .expect(200);

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