import { MarcasService } from './marcas.service';

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

function crear() {
  const prisma: any = {
    marcas: {
      findFirst: jest.fn(),
      findMany: jest.fn().mockResolvedValue([]),
      create: jest.fn(),
      update: jest.fn(),
      delete: jest.fn(),
    },
    productos: { count: jest.fn().mockResolvedValue(0) },
    proveedor_marca: { count: jest.fn().mockResolvedValue(0) },
    reglas_precio: { count: jest.fn().mockResolvedValue(0) },
    oferta_aplicacion: { count: jest.fn().mockResolvedValue(0) },
    $queryRaw: jest.fn().mockResolvedValue([]),
    $transaction: jest.fn(),
  };
  prisma.$transaction.mockImplementation((cb: any) => cb(prisma));
  const audit = { log: jest.fn().mockResolvedValue(undefined) };
  const cache = { set: jest.fn().mockResolvedValue(undefined) };
  const service = new MarcasService(prisma, audit as any, cache as any);
  return { service, prisma, audit, cache };
}

const marca = { id: UUID, empresa_id: E1, descripcion: 'Nuar', codigo: null, active: true };

describe('MarcasService (K1)', () => {
  describe('IDOR', () => {
    const metodos: Array<[string, (s: MarcasService, id: string) => Promise<unknown>]> = [
      ['findOne', (s, id) => s.findOne(id, E1)],
      ['update', (s, id) => s.update(id, { descripcion: 'X' }, E1)],
      ['toggleActive', (s, id) => s.toggleActive(id, E1)],
      ['remove', (s, id) => s.remove(id, E1)],
    ];

    it.each(metodos)('%s con el id de otra empresa da 404 MARCA_NO_ENCONTRADA y no escribe', async (_n, llamar) => {
      const { service, prisma } = crear();
      prisma.marcas.findFirst.mockResolvedValue(null);
      await expect(llamar(service, UUID)).rejects.toMatchObject({
        response: { codigo: 'MARCA_NO_ENCONTRADA', message: 'Marca no encontrada' },
        status: 404,
      });
      expect(prisma.marcas.findFirst).toHaveBeenCalledWith({ where: { id: UUID, empresa_id: E1 } });
      expect(prisma.marcas.update).not.toHaveBeenCalled();
      expect(prisma.marcas.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.marcas.findFirst).not.toHaveBeenCalled();
    });
  });

  describe('duplicados y obligatoriedad', () => {
    it('create con "  Nuar " si existe "NUAR" da 409 MARCA_DUPLICADA con campo descripcion', async () => {
      const { service, prisma } = crear();
      prisma.marcas.findMany.mockResolvedValue([{ id: 'otra', descripcion: 'NUAR' }]);
      await expect(service.create({ descripcion: '  Nuar ' }, E1)).rejects.toMatchObject({
        status: 409,
        response: { codigo: 'MARCA_DUPLICADA', campo: 'descripcion' },
      });
      expect(prisma.marcas.create).not.toHaveBeenCalled();
    });

    it('create con "SAMSUNG " ya guardada con espacios también choca', async () => {
      const { service, prisma } = crear();
      prisma.marcas.findMany.mockResolvedValue([{ id: 'otra', descripcion: 'SAMSUNG ' }]);
      await expect(service.create({ descripcion: 'samsung' }, E1)).rejects.toMatchObject({ status: 409 });
    });

    it('create guarda la descripción con trim', async () => {
      const { service, prisma } = crear();
      prisma.marcas.create.mockResolvedValue({ ...marca, descripcion: 'Nuar' });
      await service.create({ descripcion: '  Nuar ' }, E1);
      expect(prisma.marcas.create).toHaveBeenCalledWith({
        data: { empresa_id: E1, codigo: undefined, descripcion: 'Nuar' },
      });
    });

    it('descripción con solo espacios da 400 CAMPO_REQUERIDO', async () => {
      const { service } = crear();
      await expect(service.create({ descripcion: '   ' }, E1)).rejects.toMatchObject({
        status: 400,
        response: { codigo: 'CAMPO_REQUERIDO', campo: 'descripcion' },
      });
    });

    it('update que no cambia la descripción no busca duplicados', async () => {
      const { service, prisma } = crear();
      prisma.marcas.findFirst.mockResolvedValue(marca);
      prisma.marcas.update.mockResolvedValue(marca);
      await service.update(UUID, { descripcion: 'Nuar', codigo: 'NU' }, E1);
      expect(prisma.marcas.findMany).not.toHaveBeenCalled();
    });

    it('update que cambia la descripción busca duplicados excluyendo la propia fila', async () => {
      const { service, prisma } = crear();
      prisma.marcas.findFirst.mockResolvedValue(marca);
      prisma.marcas.update.mockResolvedValue(marca);
      await service.update(UUID, { descripcion: 'Otra' }, E1);
      expect(prisma.marcas.findMany).toHaveBeenCalledWith({
        where: { empresa_id: E1, id: { not: UUID } },
        select: { id: true, descripcion: true },
      });
    });

    it('update con codigo null manda null y sin codigo manda undefined', async () => {
      const { service, prisma } = crear();
      prisma.marcas.findFirst.mockResolvedValue(marca);
      prisma.marcas.update.mockResolvedValue(marca);
      await service.update(UUID, { codigo: null }, E1);
      expect(prisma.marcas.update.mock.calls[0][0].data.codigo).toBeNull();
      await service.update(UUID, { descripcion: 'Nuar' }, E1);
      expect(prisma.marcas.update.mock.calls[1][0].data.codigo).toBeUndefined();
    });
  });

  describe('lectura', () => {
    it('findAll devuelve el array pelado', async () => {
      const { service, prisma } = crear();
      prisma.marcas.findMany.mockResolvedValue([marca]);
      await expect(service.findAll(E1)).resolves.toEqual([marca]);
    });
  });

  describe('remove', () => {
    beforeEach(() => undefined);

    it('con 2 productos da 400 MARCA_CON_PRODUCTOS con el mensaje de hoy', async () => {
      const { service, prisma } = crear();
      prisma.marcas.findFirst.mockResolvedValue(marca);
      prisma.productos.count.mockResolvedValue(2);
      await expect(service.remove(UUID, E1)).rejects.toMatchObject({
        status: 400,
        response: {
          codigo: 'MARCA_CON_PRODUCTOS',
          message: 'No se puede eliminar la marca porque tiene 2 producto(s) asociado(s)',
        },
      });
      expect(prisma.productos.count).toHaveBeenCalledWith({ where: { marca_id: UUID } });
      expect(prisma.marcas.delete).not.toHaveBeenCalled();
    });

    it('bloquea la fila con FOR UPDATE antes de contar', async () => {
      const { service, prisma } = crear();
      prisma.marcas.findFirst.mockResolvedValue(marca);
      await service.remove(UUID, E1);
      expect(prisma.$queryRaw.mock.invocationCallOrder[0]).toBeLessThan(prisma.productos.count.mock.invocationCallOrder[0]);
    });

    it('con 1 proveedor y 1 regla activa da 409 MARCA_EN_USO con los conteos y no borra', async () => {
      const { service, prisma } = crear();
      prisma.marcas.findFirst.mockResolvedValue(marca);
      prisma.proveedor_marca.count.mockResolvedValue(1);
      prisma.reglas_precio.count.mockResolvedValue(1);
      await expect(service.remove(UUID, E1)).rejects.toMatchObject({
        status: 409,
        response: { codigo: 'MARCA_EN_USO', proveedores: 1, reglas: 1, ofertas: 0 },
      });
      expect(prisma.marcas.delete).not.toHaveBeenCalled();
    });

    it('cuenta todos los vínculos con proveedores, sin filtrar por vigencia', async () => {
      const { service, prisma } = crear();
      prisma.marcas.findFirst.mockResolvedValue(marca);
      await service.remove(UUID, E1);
      expect(prisma.proveedor_marca.count).toHaveBeenCalledWith({ where: { marca_id: UUID, empresa_id: E1 } });
    });

    it('con P2003 al borrar da MARCA_CON_PRODUCTOS', async () => {
      const { service, prisma } = crear();
      prisma.marcas.findFirst.mockResolvedValue(marca);
      prisma.marcas.delete.mockRejectedValue({ code: 'P2003' });
      await expect(service.remove(UUID, E1)).rejects.toMatchObject({
        status: 400,
        response: { codigo: 'MARCA_CON_PRODUCTOS' },
      });
    });

    it('sin nada que la use, la borra, audita e invalida la tienda', async () => {
      const { service, prisma, audit, cache } = crear();
      prisma.marcas.findFirst.mockResolvedValue(marca);
      await expect(service.remove(UUID, E1, 'U1')).resolves.toEqual({ message: 'Marca eliminada exitosamente' });
      expect(prisma.marcas.delete).toHaveBeenCalledWith({ where: { id: UUID } });
      expect(audit.log).toHaveBeenCalledWith(expect.objectContaining({ action: 'DELETE', entity_id: UUID }));
      expect(cache.set).toHaveBeenCalledWith('store:catalogo:gen:E1', expect.any(Number), expect.any(Number));
    });
  });

  describe('caché de la tienda', () => {
    const escrituras: Array<[string, (s: MarcasService, p: any) => Promise<unknown>]> = [
      [
        'create',
        (s, p) => {
          p.marcas.create.mockResolvedValue(marca);
          return s.create({ descripcion: 'Nuar' }, E1);
        },
      ],
      ['update', (s, p) => (p.marcas.update.mockResolvedValue(marca), s.update(UUID, { codigo: 'N' }, E1))],
      ['toggleActive', (s, p) => (p.marcas.update.mockResolvedValue(marca), s.toggleActive(UUID, E1))],
      ['remove', (s) => s.remove(UUID, E1)],
    ];

    it.each(escrituras)('%s invalida la generación con store:catalogo:gen:E1 después de escribir', async (_n, escribir) => {
      const { service, prisma, cache } = crear();
      prisma.marcas.findFirst.mockResolvedValue(marca);
      await escribir(service, prisma);
      expect(cache.set).toHaveBeenCalledWith('store:catalogo:gen:E1', expect.any(Number), expect.any(Number));
    });

    it.each(escrituras)('%s responde bien aunque cache.set rechace', async (_n, escribir) => {
      const { service, prisma, cache } = crear();
      prisma.marcas.findFirst.mockResolvedValue(marca);
      cache.set.mockRejectedValue(new Error('redis caído'));
      await expect(escribir(service, prisma)).resolves.toBeDefined();
    });
  });
});
