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

jest.setTimeout(30000);

describe('ParametroController.create', () => {
  let app: INestApplication;
  let mongoServer;
  let parametroModel = mongoose.model('parametro', ParametroSchema);

  const seederParametroSimple = {
    codigo: 'codigo test',
    nombre: 'Este es un nombre parametro de test simple',
    idTipoParametro: new mongoose.Types.ObjectId().toHexString(),
  };

  const seederParametroConPadre = {
    codigo: 'codigo test padre',
    nombre: 'Este es un nombre parametro de test padre',
    padre: {
      _id: new mongoose.Types.ObjectId().toHexString(),
      nombre: 'nombre test padre',
    },
    idTipoParametro: new mongoose.Types.ObjectId().toHexString(),
  };

  const seederParametroMenuSimple = {
    codigo: 'codigo test menu simple',
    nombre: 'Este es un nombre parametro de test menu simple',
    padre: null,
    icon: {
      _id: new mongoose.Types.ObjectId().toHexString(),
      nombre: 'nombre Icono test menu simple',
      codigo: 'codigo Icono test menu simple',
    },
    posicion: 1,
    idTipoParametro: new mongoose.Types.ObjectId().toHexString(),
  };

  beforeAll(async () => {
    mongoServer = await MongoMemoryServer.create();
    const uri = mongoServer.getUri();
    await mongoose.connect(uri);
    parametroModel = mongoose.model('Parametro', ParametroSchema);
  });

  const seederParametroMenuConPadre = {
    codigo: 'codigo test menu con padre',
    nombre: 'nombre Icono test menu con padre',
    padre: {
      _id: new mongoose.Types.ObjectId().toHexString(),
      nombre: 'nombre test menu con padre',
    },
    idTipoParametro: new mongoose.Types.ObjectId().toHexString(),
    icon: {
      _id: new mongoose.Types.ObjectId().toHexString(),
      nombre: 'nombre Icono test menu con padre',
      codigo: 'codigo Icono test menu con padre',
    },
    posicion: 1,
    // Campos adicionales que podrían ser necesarios
    deletedAt: null,
    createdAt: new Date().toISOString(),
    updatedAt: new Date().toISOString(),
    __v: 0,
  };

  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,
          }),
        }),
        ParametroModule,
      ],
    }).compile();

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

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

  describe('POST parametro', () => {
    it('debe retornar un error 400 si no se envían datos', async () => {
      const expectResponse = {
        message: [
          'codigo no debe exceder los 60 caracteres.',
          'codigo no debe estar vacío.',
          'codigo debe ser una cadena de texto.',
          'nombre no debe exceder los 50 caracteres.',
          'nombre no debe estar vacío.',
          'nombre debe ser una cadena de texto.',
          'idTipoParametro no debe estar vacío.',
          'idTipoParametro debe ser un ID de MongoDB valido.',
        ],
        error: 'Bad Request',
        statusCode: 400,
      };

      const response = await request(app.getHttpServer())
        .post('/parametros')
        .set({
          'Content-Type': 'application/json',
          Accept: 'application/json',
        })
        .send({})
        .expect(400);

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

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

      const response = await request(app.getHttpServer())
        .post('/parametros')
        .set({
          'Content-Type': 'application/json',
          Accept: 'application/json',
        })
        .send(payload)
        .expect(201);

      const data = response.body.data;

      expect(data.codigo).toEqual(payload.codigo);
      expect(data.nombre).toEqual(payload.nombre);
      expect(data.padre).toBeNull();
      expect(data.idTipoParametro).toEqual(payload.idTipoParametro);
      expect(response.body.message).toEqual('Registro exitoso');
      expect(response.body.summary).toEqual('El elemento fue creado');
    });

    it('debe crear un parametro con padre correctamente', async () => {
      const payload = seederParametroConPadre;

      const response = await request(app.getHttpServer())
        .post('/parametros')
        .set({
          'Content-Type': 'application/json',
          Accept: 'application/json',
        })
        .send(payload)
        .expect(201);

      const data = response.body.data;

      expect(data.codigo).toEqual(payload.codigo);
      expect(data.nombre).toEqual(payload.nombre);
      expect(data.padre).toBeDefined();
      expect(data.padre.nombre).toEqual(payload.padre.nombre);
      expect(data.idTipoParametro).toEqual(payload.idTipoParametro);
      // Validar que no existan campos no esperados
      expect(data.icon).toBeUndefined();
      expect(data.posicion).toBeUndefined();
      expect(response.body.message).toEqual('Registro exitoso');
      expect(response.body.summary).toEqual('El elemento fue creado');
    });

    it('debe crear un menú simple correctamente', async () => {
      const payload = seederParametroMenuSimple;

      const response = await request(app.getHttpServer())
        .post('/parametros')
        .set({
          'Content-Type': 'application/json',
          Accept: 'application/json',
        })
        .send(payload)
        .expect(201);

      const data = response.body.data;

      expect(data.codigo).toEqual(payload.codigo);
      expect(data.nombre).toEqual(payload.nombre);
      expect(data.padre).toBeNull();
      expect(data.icon).toBeDefined();
      expect(data.icon.nombre).toEqual(payload.icon.nombre);
      expect(data.posicion).toEqual(payload.posicion);
      expect(data.idTipoParametro).toEqual(payload.idTipoParametro);
      expect(response.body.message).toEqual('Registro exitoso');
      expect(response.body.summary).toEqual('El elemento fue creado');
    });

    it('debe crear un menú con padre e ícono correctamente', async () => {
      const payload = seederParametroMenuConPadre;

      const response = await request(app.getHttpServer())
        .post('/parametros')
        .set({
          'Content-Type': 'application/json',
          Accept: 'application/json',
        })
        .send(payload)
        .expect(201);

      const data = response.body.data;

      expect(data.codigo).toEqual(payload.codigo);
      expect(data.nombre).toEqual(payload.nombre);
      expect(data.padre).toBeDefined();
      expect(data.padre.nombre).toEqual(payload.padre.nombre);
      expect(data.icon).toBeDefined();
      expect(data.icon.nombre).toEqual(payload.icon.nombre);
      expect(data.posicion).toEqual(payload.posicion);
      expect(data.idTipoParametro).toEqual(payload.idTipoParametro);
      expect(response.body.message).toEqual('Registro exitoso');
      expect(response.body.summary).toEqual('El elemento fue creado');
    });
  });
});