import { ConflictException, NotFoundException } from '@nestjs/common';
import { codigoDeError } from 'src/common/utils/error-estructurado';
import { ProductosService } from './productos.service';

const crear = (opciones: { producto?: any; conStock?: number } = {}) => {
  const prisma: any = {
    productos: {
      findUnique: jest.fn().mockResolvedValue('producto' in opciones ? opciones.producto : { id: 'p1', descripcion: 'Heladera', cod_producto: 'H1', precio: 10, active: true, deleted: false }),
      update: jest.fn(async ({ data }: any) => ({ id: 'p1', ...data })),
    },
    stock_deposito: { count: jest.fn().mockResolvedValue(opciones.conStock ?? 0) },
    $queryRaw: jest.fn().mockResolvedValue([{ id: 'p1' }]),
  };
  prisma.$transaction = jest.fn(async (fn: any) => fn(prisma));
  const audit = { log: jest.fn().mockResolvedValue(undefined) };
  const service = new ProductosService(prisma, { get: () => undefined } as any, audit as any, {} as any, {} as any, {} as any);
  return { service, prisma, audit };
};

describe('ProductosService.remove: bloqueo por stock', () => {
  it('con stock en algún depósito da 409 PRODUCTO_CON_STOCK y no hace update', async () => {
    const { service, prisma, audit } = crear({ conStock: 1 });
    const err = await service.remove('p1', 'e1', 'u1').catch((e) => e);
    expect(err).toBeInstanceOf(ConflictException);
    expect(codigoDeError(err)).toBe('PRODUCTO_CON_STOCK');
    expect(err.getResponse().message).toBe('Tiene stock en algún depósito. Ajustalo a cero antes de eliminarlo; o desactivalo.');
    expect(prisma.productos.update).not.toHaveBeenCalled();
    expect(audit.log).not.toHaveBeenCalled();
  });

  it('busca cualquier cantidad distinta de 0, disponible o reservada (también negativa; +5 y -5 en dos depósitos bloquea)', async () => {
    const { service, prisma } = crear({ conStock: 2 });
    await service.remove('p1', 'e1', 'u1').catch(() => undefined);
    expect(prisma.stock_deposito.count).toHaveBeenCalledWith({
      where: { producto_id: 'p1', OR: [{ cantidad_disponible: { not: 0 } }, { cantidad_reservada: { not: 0 } }] },
    });
  });

  it('sin filas de stock, o solo con stock 0, elimina y audita DELETE', async () => {
    const { service, prisma, audit } = crear({ conStock: 0 });
    const r = await service.remove('p1', 'e1', 'u1');
    expect(prisma.productos.update).toHaveBeenCalledWith({ where: { id: 'p1' }, data: expect.objectContaining({ deleted: true }) });
    expect(audit.log).toHaveBeenCalledWith(expect.objectContaining({ action: 'DELETE', entity_id: 'p1', empresa_id: 'e1' }));
    expect(r.message).toBe('Producto eliminado exitosamente');
  });

  it('cuenta el stock y da de baja dentro de una transacción con el producto bloqueado', async () => {
    const { service, prisma } = crear({ conStock: 0 });
    await service.remove('p1', 'e1', 'u1');
    expect(prisma.$transaction).toHaveBeenCalledTimes(1);
    expect(prisma.$queryRaw.mock.calls[0][0].join('')).toMatch(/FOR UPDATE/);
  });

  it('inexistente, o de otra empresa, da 404 PRODUCTO_NO_ENCONTRADO', async () => {
    const { service, prisma } = crear({ producto: null });
    const err = await service.remove('p1', 'otra', 'u1').catch((e) => e);
    expect(err).toBeInstanceOf(NotFoundException);
    expect(codigoDeError(err)).toBe('PRODUCTO_NO_ENCONTRADO');
    expect(prisma.productos.findUnique).toHaveBeenCalledWith({ where: { id: 'p1', empresa_id: 'otra' } });
  });

  it('ya eliminado da 409 PRODUCTO_YA_ELIMINADO antes de mirar el stock', async () => {
    const { service, prisma } = crear({ producto: { id: 'p1', deleted: true } });
    const err = await service.remove('p1', 'e1', 'u1').catch((e) => e);
    expect(codigoDeError(err)).toBe('PRODUCTO_YA_ELIMINADO');
    expect(prisma.stock_deposito.count).not.toHaveBeenCalled();
  });
});
