import 'reflect-metadata';
import { validate } from 'class-validator';
import { plainToInstance } from 'class-transformer';
import { CreateAtributoValorDto } from './dto/create-atributo-valor.dto';
import { ProductoAtributosService } from './producto-atributos.service';

const UUID = '3f1c5a2e-9a3b-4b0e-8d57-6a1f0c2b7e11';
const E1 = 'E1';

function crear() {
  const prisma: any = {
    producto_atributos: {
      findFirst: jest.fn(),
      findMany: jest.fn().mockResolvedValue([]),
      create: jest.fn(),
      update: jest.fn(),
      delete: jest.fn(),
    },
    producto_atributo_valores: {
      findFirst: jest.fn(),
      findMany: jest.fn().mockResolvedValue([]),
      create: jest.fn(),
      update: jest.fn(),
      delete: jest.fn(),
    },
    producto_variante_valores: { count: jest.fn().mockResolvedValue(0) },
  };
  const audit = { log: jest.fn().mockResolvedValue(undefined) };
  return { service: new ProductoAtributosService(prisma, audit as any), prisma, audit };
}

const atributo = { id: UUID, empresa_id: E1, nombre: 'Color', descripcion: null, active: true };
const valor = { id: UUID, valor: 'Rojo', codigo: null, active: true, atributo };

describe('ProductoAtributosService (K1)', () => {
  describe('IDOR de atributos', () => {
    const metodos: Array<[string, (s: ProductoAtributosService, id: string) => Promise<unknown>]> = [
      ['findOneAtributo', (s, id) => s.findOneAtributo(id, E1)],
      ['updateAtributo', (s, id) => s.updateAtributo(id, { nombre: 'X' }, E1)],
      ['toggleAtributo', (s, id) => s.toggleAtributo(id, E1)],
      ['removeAtributo', (s, id) => s.removeAtributo(id, E1)],
      ['findValoresByAtributo', (s, id) => s.findValoresByAtributo(id, E1)],
      ['createValor', (s, id) => s.createValor({ atributo_id: id, valor: 'Rojo' }, E1)],
    ];

    it.each(metodos)('%s con el id de otra empresa da 404 ATRIBUTO_NO_ENCONTRADO y no escribe', async (_n, llamar) => {
      const { service, prisma } = crear();
      prisma.producto_atributos.findFirst.mockResolvedValue(null);
      await expect(llamar(service, UUID)).rejects.toMatchObject({
        status: 404,
        response: { codigo: 'ATRIBUTO_NO_ENCONTRADO', message: 'Atributo no encontrado' },
      });
      expect(prisma.producto_atributos.findFirst).toHaveBeenCalledWith(
        expect.objectContaining({ where: { id: UUID, empresa_id: E1 } }),
      );
      expect(prisma.producto_atributos.update).not.toHaveBeenCalled();
      expect(prisma.producto_atributos.delete).not.toHaveBeenCalled();
      expect(prisma.producto_atributo_valores.create).not.toHaveBeenCalled();
    });

    it.each(metodos)('%s con un id que no es uuid da 404 sin consultar', async (_n, llamar) => {
      const { service, prisma } = crear();
      await expect(llamar(service, 'no-es-uuid')).rejects.toMatchObject({ status: 404 });
      expect(prisma.producto_atributos.findFirst).not.toHaveBeenCalled();
    });
  });

  describe('IDOR de valores', () => {
    const metodos: Array<[string, (s: ProductoAtributosService, id: string) => Promise<unknown>]> = [
      ['updateValor', (s, id) => s.updateValor(id, { valor: 'X' }, E1)],
      ['toggleValor', (s, id) => s.toggleValor(id, E1)],
      ['removeValor', (s, id) => s.removeValor(id, E1)],
    ];

    it.each(metodos)('%s con el valor de otra empresa da 404 VALOR_NO_ENCONTRADO y no escribe', async (_n, llamar) => {
      const { service, prisma } = crear();
      prisma.producto_atributo_valores.findFirst.mockResolvedValue(null);
      await expect(llamar(service, UUID)).rejects.toMatchObject({
        status: 404,
        response: { codigo: 'VALOR_NO_ENCONTRADO', message: 'Valor de atributo no encontrado' },
      });
      expect(prisma.producto_atributo_valores.findFirst).toHaveBeenCalledWith(
        expect.objectContaining({ where: { id: UUID, atributo: { empresa_id: E1 } } }),
      );
      expect(prisma.producto_atributo_valores.update).not.toHaveBeenCalled();
      expect(prisma.producto_atributo_valores.delete).not.toHaveBeenCalled();
    });

    it.each(metodos)('%s con un id que no es uuid da 404 sin consultar', async (_n, llamar) => {
      const { service, prisma } = crear();
      await expect(llamar(service, 'no-es-uuid')).rejects.toMatchObject({ status: 404 });
      expect(prisma.producto_atributo_valores.findFirst).not.toHaveBeenCalled();
    });
  });

  describe('inactivos', () => {
    it('findAllAtributos("E1") filtra active: true en atributo y valores', async () => {
      const { service, prisma } = crear();
      await service.findAllAtributos(E1);
      expect(prisma.producto_atributos.findMany).toHaveBeenCalledWith({
        where: { empresa_id: E1, active: true },
        include: { producto_atributo_valores: { where: { active: true }, orderBy: { orden: 'asc' } } },
        orderBy: { orden: 'asc' },
      });
    });

    it('findAllAtributos("E1", true) no filtra ninguno de los dos', async () => {
      const { service, prisma } = crear();
      await service.findAllAtributos(E1, true);
      expect(prisma.producto_atributos.findMany).toHaveBeenCalledWith({
        where: { empresa_id: E1 },
        include: { producto_atributo_valores: { where: undefined, orderBy: { orden: 'asc' } } },
        orderBy: { orden: 'asc' },
      });
    });

    it('findValoresByAtributo filtra activos salvo con incluirInactivos', async () => {
      const { service, prisma } = crear();
      prisma.producto_atributos.findFirst.mockResolvedValue(atributo);
      await service.findValoresByAtributo(UUID, E1);
      expect(prisma.producto_atributo_valores.findMany).toHaveBeenLastCalledWith({
        where: { atributo_id: UUID, active: true },
        orderBy: { orden: 'asc' },
      });
      await service.findValoresByAtributo(UUID, E1, true);
      expect(prisma.producto_atributo_valores.findMany).toHaveBeenLastCalledWith({
        where: { atributo_id: UUID },
        orderBy: { orden: 'asc' },
      });
    });
  });

  describe('duplicados y obligatoriedad', () => {
    const p2002 = { code: 'P2002' };

    it('createAtributo con P2002 da 409 ATRIBUTO_DUPLICADO, campo nombre', async () => {
      const { service, prisma } = crear();
      prisma.producto_atributos.create.mockRejectedValue(p2002);
      await expect(service.createAtributo({ nombre: 'Color' }, E1)).rejects.toMatchObject({
        status: 409,
        response: { codigo: 'ATRIBUTO_DUPLICADO', campo: 'nombre' },
      });
    });

    it('updateAtributo con P2002 da 409 ATRIBUTO_DUPLICADO', async () => {
      const { service, prisma } = crear();
      prisma.producto_atributos.findFirst.mockResolvedValue(atributo);
      prisma.producto_atributos.update.mockRejectedValue(p2002);
      await expect(service.updateAtributo(UUID, { nombre: 'Talle' }, E1)).rejects.toMatchObject({
        status: 409,
        response: { codigo: 'ATRIBUTO_DUPLICADO', campo: 'nombre' },
      });
    });

    it('createValor con P2002 da 409 VALOR_DUPLICADO, campo valor', async () => {
      const { service, prisma } = crear();
      prisma.producto_atributos.findFirst.mockResolvedValue(atributo);
      prisma.producto_atributo_valores.create.mockRejectedValue(p2002);
      await expect(service.createValor({ atributo_id: UUID, valor: 'Rojo' }, E1)).rejects.toMatchObject({
        status: 409,
        response: { codigo: 'VALOR_DUPLICADO', campo: 'valor' },
      });
    });

    it('updateValor con P2002 da 409 VALOR_DUPLICADO', async () => {
      const { service, prisma } = crear();
      prisma.producto_atributo_valores.findFirst.mockResolvedValue(valor);
      prisma.producto_atributo_valores.update.mockRejectedValue(p2002);
      await expect(service.updateValor(UUID, { valor: 'Azul' }, E1)).rejects.toMatchObject({
        status: 409,
        response: { codigo: 'VALOR_DUPLICADO', campo: 'valor' },
      });
    });

    it('un error que no es P2002 se propaga tal cual', async () => {
      const { service, prisma } = crear();
      const falla = new Error('conexión');
      prisma.producto_atributos.create.mockRejectedValue(falla);
      await expect(service.createAtributo({ nombre: 'Color' }, E1)).rejects.toBe(falla);
    });

    it('nombre y valor con solo espacios dan 400 CAMPO_REQUERIDO', async () => {
      const { service, prisma } = crear();
      prisma.producto_atributos.findFirst.mockResolvedValue(atributo);
      await expect(service.createAtributo({ nombre: '  ' }, E1)).rejects.toMatchObject({
        status: 400,
        response: { codigo: 'CAMPO_REQUERIDO', campo: 'nombre' },
      });
      await expect(service.createValor({ atributo_id: UUID, valor: ' ' }, E1)).rejects.toMatchObject({
        status: 400,
        response: { codigo: 'CAMPO_REQUERIDO', campo: 'valor' },
      });
    });
  });

  describe('borrados con variantes', () => {
    it('removeValor con 3 variantes da 400 VALOR_CON_VARIANTES con el mensaje de hoy', async () => {
      const { service, prisma } = crear();
      prisma.producto_atributo_valores.findFirst.mockResolvedValue(valor);
      prisma.producto_variante_valores.count.mockResolvedValue(3);
      await expect(service.removeValor(UUID, E1)).rejects.toMatchObject({
        status: 400,
        response: {
          codigo: 'VALOR_CON_VARIANTES',
          message: 'No se puede eliminar el valor porque tiene 3 variante(s) asociada(s)',
        },
      });
      expect(prisma.producto_atributo_valores.delete).not.toHaveBeenCalled();
    });

    it('removeAtributo con variantes da 400 ATRIBUTO_CON_VARIANTES', async () => {
      const { service, prisma } = crear();
      prisma.producto_atributos.findFirst.mockResolvedValue(atributo);
      prisma.producto_variante_valores.count.mockResolvedValue(2);
      await expect(service.removeAtributo(UUID, E1)).rejects.toMatchObject({
        status: 400,
        response: {
          codigo: 'ATRIBUTO_CON_VARIANTES',
          message: 'No se puede eliminar el atributo porque tiene 2 variante(s) asociada(s)',
        },
      });
    });
  });

  describe('updateValor: null limpia, undefined no toca', () => {
    it('con color_hex y codigo null manda null; sin ellos, undefined', async () => {
      const { service, prisma } = crear();
      prisma.producto_atributo_valores.findFirst.mockResolvedValue(valor);
      prisma.producto_atributo_valores.update.mockResolvedValue(valor);
      await service.updateValor(UUID, { color_hex: null, codigo: null }, E1);
      expect(prisma.producto_atributo_valores.update.mock.calls[0][0].data).toMatchObject({ color_hex: null, codigo: null });
      await service.updateValor(UUID, { valor: 'Rojo' }, E1);
      const data = prisma.producto_atributo_valores.update.mock.calls[1][0].data;
      expect(data.color_hex).toBeUndefined();
      expect(data.codigo).toBeUndefined();
    });
  });

  describe('CreateAtributoValorDto.color_hex', () => {
    const errores = async (color_hex: unknown) =>
      (await validate(plainToInstance(CreateAtributoValorDto, { atributo_id: UUID, valor: 'Rojo', color_hex }))).map(
        (e) => e.property,
      );

    it('#FF0000 es válido', async () => expect(await errores('#FF0000')).toEqual([]));
    it('FF0000 falla', async () => expect(await errores('FF0000')).toContain('color_hex'));
    it('#GG0000 falla', async () => expect(await errores('#GG0000')).toContain('color_hex'));
    it('null es válido (borra el color)', async () => expect(await errores(null)).toEqual([]));
  });
});
