import { ValidationPipe } from '@nestjs/common';
import { submoduloHabilitado } from 'src/auth/guards/submodulo.guard';
import { OrdenesCompraService } from 'src/ordenes-compra/ordenes-compra.service';
import { alcanceSucursalUsuario } from 'src/utils/alcance-sucursal';
import { GenerarOrdenesCompraDistribuidasDto } from './dto/requisicion-config.dto';
import { RequisicionesService } from './requisiciones.service';
import {
  asig,
  armar,
  cuerpo,
  DET_AJENA,
  DET1,
  DET2,
  DET3,
  dtoBase,
  error,
  MON_PYG,
  MON_USD,
  OTRA_SUC,
  PROD1,
  PROV_A,
  PROV_B,
  SUC,
  tick,
} from './requisiciones-generar-oc.fixture';

jest.mock('src/utils/alcance-sucursal', () => ({
  ...jest.requireActual('src/utils/alcance-sucursal'),
  alcanceSucursalUsuario: jest.fn(),
}));
jest.mock('src/auth/guards/submodulo.guard', () => ({
  ...jest.requireActual('src/auth/guards/submodulo.guard'),
  submoduloHabilitado: jest.fn(),
}));

const alcanceMock = alcanceSucursalUsuario as jest.Mock;
const submoduloMock = submoduloHabilitado as jest.Mock;



beforeEach(() => {
  alcanceMock.mockReset();
  alcanceMock.mockResolvedValue(null);
  submoduloMock.mockReset();
  submoduloMock.mockResolvedValue({ habilitado: true, fechaFinPrueba: null });
});

describe('Requisiciones - generar órdenes de compra (todo o nada)', () => {
  it('dos proveedores: dos crearEnTx en la misma $transaction, después de req:', async () => {
    const { service, crearEnTx, orden, base } = armar();
    const r = await service.generarOrdenesCompraDistribuidas(
      'req-1',
      'emp-1',
      dtoBase([asig(DET1, PROV_A, 4), asig(DET2, PROV_B, 2, 48000), asig(DET1, PROV_A, 2)]),
      'usr-1',
    );

    expect(crearEnTx).toHaveBeenCalledTimes(2);
    expect(crearEnTx.mock.calls[0][0]).toBe(crearEnTx.mock.calls[1][0]);
    // Una sola tx de 60 s; req: antes de la relectura y de cualquier alta.
    expect(orden.filter((x) => x.startsWith('tx:'))).toEqual(['tx:60000']);
    const iLock = orden.indexOf('lock:req:req-1');
    expect(iLock).toBeGreaterThan(orden.indexOf('tx:60000'));
    expect(iLock).toBeLessThan(orden.indexOf('lectura:req'));
    expect(iLock).toBeLessThan(orden.indexOf(`oc:${PROV_A}`));
    // El historial va en la misma tx, después de las altas; la auditoría de OC después del commit.
    expect(orden.indexOf('historial:oc_creada')).toBeGreaterThan(orden.indexOf(`oc:${PROV_B}`));
    expect(orden.indexOf('audit')).toBeGreaterThan(orden.indexOf('historial:oc_creada'));

    // La OC de A junta sus dos asignaciones en el orden enviado.
    const dtoA = crearEnTx.mock.calls[0][1];
    expect(dtoA.cabecera).toMatchObject({ proveedor_id: PROV_A, requisicion_id: 'req-1', sucursal_id: SUC, moneda_id: MON_PYG });
    expect(dtoA.items.map((i: any) => [i.requisicion_det_id, i.cantidad, i.precio_unitario])).toEqual([
      [DET1, 4, 1500],
      [DET1, 2, 1500],
    ]);
    // Línea de producto sin descripción: la OC usa la del producto (ruling F5), nunca un literal.
    expect(dtoA.items[0].descripcion).toBe('Resma A4');
    expect(crearEnTx.mock.calls[1][1].items[0]).toMatchObject({ descripcion: 'Servicio de flete', porcentaje_iva: 5, precio_unitario: 48000 });

    expect(r).toEqual({
      ordenes: [
        { id: 'oc-nueva-1', numero_orden: 'OC-00000001', proveedor_id: PROV_A, estado: 'pendiente' },
        { id: 'oc-nueva-2', numero_orden: 'OC-00000002', proveedor_id: PROV_B, estado: 'pendiente' },
      ],
    });
    expect(base.ocs).toHaveLength(2);
  });

  it('historial oc_creada: comentario null y los números de las OC en datos (ruling F5)', async () => {
    const { service, base } = armar();
    await service.generarOrdenesCompraDistribuidas('req-1', 'emp-1', dtoBase([asig(DET1, PROV_A, 1), asig(DET2, PROV_B, 1)]), 'usr-1');
    expect(base.historial).toHaveLength(1);
    expect(base.historial[0]).toEqual({
      requisicion_id: 'req-1',
      accion: 'oc_creada',
      estado_anterior: 'aprobada',
      estado_nuevo: 'aprobada',
      comentario: null,
      usuario_id: 'usr-1',
      datos: {
        ordenes: [
          { orden_compra_id: 'oc-nueva-1', numero_orden: 'OC-00000001', proveedor_id: PROV_A },
          { orden_compra_id: 'oc-nueva-2', numero_orden: 'OC-00000002', proveedor_id: PROV_B },
        ],
      },
    });
  });

  it('si la segunda falla, la tx lanza y no queda ninguna OC ni historial (R6)', async () => {
    const { service, base, crearEnTx, auditService } = armar({ proveedorInexistente: PROV_B });
    const e = await error(
      service.generarOrdenesCompraDistribuidas('req-1', 'emp-1', dtoBase([asig(DET1, PROV_A, 1), asig(DET2, PROV_B, 1)]), 'usr-1'),
    );
    expect(e.getStatus()).toBe(404);
    expect(crearEnTx).toHaveBeenCalledTimes(2);
    expect(base.ocs).toEqual([]);
    expect(base.historial).toEqual([]);
    expect(auditService.log).not.toHaveBeenCalled();
  });

  it('una asignación por encima del disponible (6) → CANTIDAD_SUPERA_REQUISICION con linea (R7)', async () => {
    // Solicitada 10, 3 pedidas en una OC abierta y 1 facturada sin OC: disponible 6.
    const { service, crearEnTx, base } = armar({
      pedidas: [{ requisicion_det_id: DET1, cantidad: 3 }],
      facturadas: [{ requisicion_det_id: DET1, cantidad: 1 }],
    });
    const e = await error(
      service.generarOrdenesCompraDistribuidas(
        'req-1',
        'emp-1',
        dtoBase([asig(DET2, PROV_B, 1), asig(DET1, PROV_A, 4), asig(DET1, PROV_B, 3)]),
        'usr-1',
      ),
    );
    expect(e.getStatus()).toBe(400);
    // La tercera asignación (base 1) excede lo que queda después de la segunda: 6 - 4 = 2.
    expect(cuerpo(e)).toMatchObject({ codigo: 'CANTIDAD_SUPERA_REQUISICION', linea: 3, disponible: 2, requisicion_det_id: DET1 });
    expect(crearEnTx).not.toHaveBeenCalled();
    expect(base.ocs).toEqual([]);

    const { service: s2 } = armar({ pedidas: [{ requisicion_det_id: DET1, cantidad: 3 }], facturadas: [{ requisicion_det_id: DET1, cantidad: 1 }] });
    const e2 = await error(s2.generarOrdenesCompraDistribuidas('req-1', 'emp-1', dtoBase([asig(DET1, PROV_A, 7)]), 'usr-1'));
    expect(cuerpo(e2)).toMatchObject({ codigo: 'CANTIDAD_SUPERA_REQUISICION', linea: 1, disponible: 6, requisicion_det_id: DET1 });
  });

  it('una OC cancelada no cuenta como pedida: el disponible vuelve', async () => {
    const { service, crearEnTx } = armar({ pedidas: [{ requisicion_det_id: DET1, cantidad: 10, estado: 'cancelada' }] });
    await service.generarOrdenesCompraDistribuidas('req-1', 'emp-1', dtoBase([asig(DET1, PROV_A, 10)]), 'usr-1');
    expect(crearEnTx).toHaveBeenCalledTimes(1);
  });

  it('una línea de otra requisición → LINEA_DE_OTRA_REQUISICION con linea base 1 y requisicion_det_id', async () => {
    const { service, crearEnTx } = armar();
    const e = await error(
      service.generarOrdenesCompraDistribuidas('req-1', 'emp-1', dtoBase([asig(DET1, PROV_A, 1), asig(DET_AJENA, PROV_A, 1)]), 'usr-1'),
    );
    expect(e.getStatus()).toBe(400);
    expect(cuerpo(e)).toMatchObject({ codigo: 'LINEA_DE_OTRA_REQUISICION', linea: 2, requisicion_det_id: DET_AJENA });
    expect(crearEnTx).not.toHaveBeenCalled();
  });

  it('sin cantidad, la asignación pide lo disponible de la línea', async () => {
    const { service, crearEnTx } = armar({ pedidas: [{ requisicion_det_id: DET1, cantidad: 4 }] });
    await service.generarOrdenesCompraDistribuidas('req-1', 'emp-1', dtoBase([asig(DET1, PROV_A)]), 'usr-1');
    expect(crearEnTx.mock.calls[0][1].items[0].cantidad).toBe(6);
  });

  it('con habilitar_orden_compra apagada → OC_DESHABILITADA (matriz 8)', async () => {
    const { service, crearEnTx, prisma } = armar({ config: { habilitar_orden_compra: false } });
    const e = await error(service.generarOrdenesCompraDistribuidas('req-1', 'emp-1', dtoBase([asig(DET1, PROV_A, 1)]), 'usr-1'));
    expect(e.getStatus()).toBe(400);
    expect(cuerpo(e)).toEqual({ message: 'Las órdenes de compra están apagadas en Configuración de Compras', codigo: 'OC_DESHABILITADA' });
    expect(crearEnTx).not.toHaveBeenCalled();
    expect(prisma.$transaction).not.toHaveBeenCalled();
  });

  it('sin el submódulo COMP_ORDENES → OC_DESHABILITADA con el mensaje del plan (ruling F4)', async () => {
    submoduloMock.mockResolvedValue({ habilitado: false, causa: 'modulo_no_disponible', mensaje: 'x' });
    const { service, crearEnTx } = armar();
    const e = await error(service.generarOrdenesCompraDistribuidas('req-1', 'emp-1', dtoBase([asig(DET1, PROV_A, 1)]), 'usr-1'));
    expect(e.getStatus()).toBe(400);
    expect(cuerpo(e)).toEqual({ message: 'Las órdenes de compra no están habilitadas en el plan de la empresa', codigo: 'OC_DESHABILITADA' });
    expect(submoduloMock).toHaveBeenCalledWith(expect.anything(), 'emp-1', 'COMP_ORDENES');
    expect(crearEnTx).not.toHaveBeenCalled();
  });

  it('con el período de prueba de COMP_ORDENES vencido → OC_DESHABILITADA', async () => {
    submoduloMock.mockResolvedValue({ habilitado: true, fechaFinPrueba: new Date(Date.now() - 5 * 86_400_000) });
    const { service } = armar();
    const e = await error(service.generarOrdenesCompraDistribuidas('req-1', 'emp-1', dtoBase([asig(DET1, PROV_A, 1)]), 'usr-1'));
    expect(cuerpo(e).codigo).toBe('OC_DESHABILITADA');
  });

  it('con requisiciones apagadas → REQUISICIONES_DESHABILITADAS', async () => {
    const { service, crearEnTx } = armar({ config: { habilitar_requisicion_compra: false } });
    const e = await error(service.generarOrdenesCompraDistribuidas('req-1', 'emp-1', dtoBase([asig(DET1, PROV_A, 1)]), 'usr-1'));
    expect(cuerpo(e).codigo).toBe('REQUISICIONES_DESHABILITADAS');
    expect(crearEnTx).not.toHaveBeenCalled();
  });

  it('en USD con cotización 1 → COTIZACION_INVALIDA (Monedas)', async () => {
    const { service, base } = armar();
    const e = await error(
      service.generarOrdenesCompraDistribuidas('req-1', 'emp-1', dtoBase([asig(DET1, PROV_A, 1, 2)], { moneda_id: MON_USD, cotizacion: 1 }), 'usr-1'),
    );
    expect(e.getStatus()).toBe(400);
    expect(cuerpo(e)).toMatchObject({ codigo: 'COTIZACION_INVALIDA', campo: 'cotizacion' });
    expect(base.ocs).toEqual([]);
  });

  it('en USD sin cotización → COTIZACION_REQUERIDA: no se toma la vigente sola', async () => {
    const { service } = armar();
    const e = await error(
      service.generarOrdenesCompraDistribuidas('req-1', 'emp-1', dtoBase([asig(DET1, PROV_A, 1, 2)], { moneda_id: MON_USD }), 'usr-1'),
    );
    expect(cuerpo(e)).toMatchObject({ codigo: 'COTIZACION_REQUERIDA' });
  });

  it('en USD con cotización válida graba la cotización en cada OC', async () => {
    const { service, base } = armar();
    await service.generarOrdenesCompraDistribuidas(
      'req-1',
      'emp-1',
      dtoBase([asig(DET1, PROV_A, 1, 2), asig(DET2, PROV_B, 1, 7)], { moneda_id: MON_USD, cotizacion: 7350 }),
      'usr-1',
    );
    expect(base.ocs.map((x) => [x.moneda_id, x.cotizacion])).toEqual([
      [MON_USD, 7350],
      [MON_USD, 7350],
    ]);
  });

  it.each([
    [{ requiere_aprobacion: true }],
    [{ usar_workflow: true }],
    [{ workflow_obligatorio: true }],
  ])('con OC con aprobación (%o), las OC quedan pendiente_aprobacion (matriz 9)', async (config) => {
    const { service } = armar({ config });
    const r = await service.generarOrdenesCompraDistribuidas('req-1', 'emp-1', dtoBase([asig(DET1, PROV_A, 1), asig(DET2, PROV_B, 1)]), 'usr-1');
    expect(r.ordenes.map((x) => x.estado)).toEqual(['pendiente_aprobacion', 'pendiente_aprobacion']);
  });

  it.each([
    ['de gasto', { origen: 'gasto' }, 'aprobada'],
    ['en borrador', { estado: 'borrador' }, 'borrador'],
    ['cancelada', { estado: 'cancelada' }, 'cancelada'],
    ['ejecutada total', { estado: 'ejecutada_total' }, 'ejecutada_total'],
  ])('una requisición %s → REQUISICION_NO_DISPONIBLE con estado_actual', async (_n, o, estado) => {
    const { service, crearEnTx } = armar(o);
    const e = await error(service.generarOrdenesCompraDistribuidas('req-1', 'emp-1', dtoBase([asig(DET1, PROV_A, 1)]), 'usr-1'));
    expect(e.getStatus()).toBe(400);
    expect(cuerpo(e)).toMatchObject({ codigo: 'REQUISICION_NO_DISPONIBLE', estado_actual: estado });
    expect(crearEnTx).not.toHaveBeenCalled();
  });

  it('fuera del alcance por sucursal → 404, sin altas (ruling F6)', async () => {
    alcanceMock.mockResolvedValue({ sucursalIds: [OTRA_SUC], puntosEstablecimiento: [], depositoIds: [] });
    const { service, crearEnTx, orden } = armar();
    const e = await error(service.generarOrdenesCompraDistribuidas('req-1', 'emp-1', dtoBase([asig(DET1, PROV_A, 1)]), 'usr-1'));
    expect(e.getStatus()).toBe(404);
    expect(alcanceMock).toHaveBeenCalledWith(expect.anything(), 'usr-1', 'emp-1');
    expect(orden).toContain('lock:req:req-1');
    expect(crearEnTx).not.toHaveBeenCalled();
  });

  it('la sucursal de las OC fuera del alcance → 403 SUCURSAL_FUERA_DE_ALCANCE, sin altas', async () => {
    // El usuario ve la requisición (su sucursal) pero pide las OC en otra sucursal.
    alcanceMock.mockResolvedValue({ sucursalIds: [SUC], puntosEstablecimiento: [], depositoIds: [] });
    const { service, crearEnTx, base } = armar();
    const e = await error(
      service.generarOrdenesCompraDistribuidas('req-1', 'emp-1', dtoBase([asig(DET1, PROV_A, 1)], { sucursal_id: OTRA_SUC }), 'usr-1'),
    );
    expect(e.getStatus()).toBe(403);
    expect(cuerpo(e)).toMatchObject({ codigo: 'SUCURSAL_FUERA_DE_ALCANCE', campo: 'sucursal_id' });
    expect(crearEnTx).not.toHaveBeenCalled();
    expect(base.ocs).toEqual([]);
  });

  it('cancelar que espera el req: de un generar relee y responde REQUISICION_CON_OC_ABIERTA con las OC nuevas (Concurrencia)', async () => {
    const { service, oc, orden } = armar();
    const real = OrdenesCompraService.prototype.crearEnTx.bind(oc);
    let seguir!: () => void;
    const pausa = new Promise<void>((r) => (seguir = r));
    let primera = true;
    (oc.crearEnTx as jest.Mock).mockImplementation(async (...args: any[]) => {
      if (primera) {
        primera = false;
        await pausa;
      }
      return (real as any)(...args);
    });

    const generar = service.generarOrdenesCompraDistribuidas('req-1', 'emp-1', dtoBase([asig(DET1, PROV_A, 1), asig(DET2, PROV_B, 1)]), 'usr-1');
    while (!orden.includes('lock:req:req-1')) await tick();
    const cancelar = error(service.cancelar('req-1', 'emp-1', 'usr-2', { motivo: 'Ya no hace falta' } as any));
    for (let i = 0; i < 5; i++) await tick();
    // Cancelar pidió el lock y espera: todavía no releyó la requisición.
    expect(orden.filter((x) => x === 'lock:req:req-1')).toHaveLength(2);
    expect(orden.filter((x) => x === 'lectura:req')).toHaveLength(1);

    seguir();
    const r = await generar;
    const e = await cancelar;
    expect(e.getStatus()).toBe(409);
    expect(cuerpo(e)).toMatchObject({
      codigo: 'REQUISICION_CON_OC_ABIERTA',
      ordenes: r.ordenes.map(({ id, numero_orden }) => ({ id, numero_orden })),
    });
    expect(cuerpo(e).ordenes).toHaveLength(2);
  });
});

describe('Requisiciones - crear-orden-compra (envoltorio)', () => {
  it('crear-orden-compra con todas las líneas disponibles a un proveedor usa la misma lógica', async () => {
    const { service, crearEnTx, orden, base } = armar({ pedidas: [{ requisicion_det_id: DET1, cantidad: 4 }, { requisicion_det_id: DET3, cantidad: 1 }] });
    const generar = jest.spyOn(service, 'generarOrdenesCompraDistribuidas');
    const r = await service.crearOrdenCompraDesdeRequisicion(
      'req-1',
      'emp-1',
      { proveedor_id: PROV_A, sucursal_id: SUC, fecha_emision: '2026-10-29' } as any,
      'usr-1',
    );
    expect(generar).not.toHaveBeenCalled();
    expect(orden.filter((x) => x.startsWith('tx:'))).toEqual(['tx:60000']);
    expect(crearEnTx).toHaveBeenCalledTimes(1);
    const dto = crearEnTx.mock.calls[0][1];
    expect(dto.cabecera).toMatchObject({ proveedor_id: PROV_A, moneda_id: MON_PYG, requisicion_id: 'req-1' });
    // DET3 ya está toda pedida: no va. DET1 va por su disponible (10 - 4), con el precio estimado.
    expect(dto.items.map((i: any) => [i.requisicion_det_id, i.cantidad, i.precio_unitario])).toEqual([
      [DET1, 6, 1500],
      [DET2, 2, 50000],
    ]);
    expect(base.historial.map((h) => [h.accion, h.comentario])).toEqual([['oc_creada', null]]);
    expect(r).toEqual({ ordenes: [{ id: 'oc-nueva-1', numero_orden: 'OC-00000001', proveedor_id: PROV_A, estado: 'pendiente' }] });
  });

  it('crear-orden-compra en otra moneda → MONEDA_REQUISICION (ruling F3)', async () => {
    const { service, crearEnTx } = armar();
    const e = await error(
      service.crearOrdenCompraDesdeRequisicion('req-1', 'emp-1', { proveedor_id: PROV_A, sucursal_id: SUC, moneda_id: MON_USD } as any, 'usr-1'),
    );
    expect(e.getStatus()).toBe(400);
    expect(cuerpo(e)).toMatchObject({ codigo: 'MONEDA_REQUISICION', campo: 'moneda_id' });
    expect(crearEnTx).not.toHaveBeenCalled();
  });

  it('crear-orden-compra sin nada disponible → CANTIDAD_SUPERA_REQUISICION sin crear nada', async () => {
    const { service, crearEnTx } = armar({
      pedidas: [
        { requisicion_det_id: DET1, cantidad: 10 },
        { requisicion_det_id: DET2, cantidad: 2 },
        { requisicion_det_id: DET3, cantidad: 1 },
      ],
    });
    const e = await error(service.crearOrdenCompraDesdeRequisicion('req-1', 'emp-1', { proveedor_id: PROV_A, sucursal_id: SUC } as any, 'usr-1'));
    expect(e.getStatus()).toBe(400);
    expect(cuerpo(e).codigo).toBe('CANTIDAD_SUPERA_REQUISICION');
    expect(crearEnTx).not.toHaveBeenCalled();
  });

  it('crear-orden-compra con OC apagada → OC_DESHABILITADA', async () => {
    const { service } = armar({ config: { habilitar_orden_compra: false } });
    const e = await error(service.crearOrdenCompraDesdeRequisicion('req-1', 'emp-1', { proveedor_id: PROV_A, sucursal_id: SUC } as any, 'usr-1'));
    expect(cuerpo(e).codigo).toBe('OC_DESHABILITADA');
  });
});

describe('Requisiciones - lineasParaOc', () => {
  it('lineasParaOc devuelve disponible = solicitada − pedida en OC abiertas − ejecutado fuera de OC', async () => {
    const { service } = armar({
      pedidas: [
        { requisicion_det_id: DET1, cantidad: 3 },
        { requisicion_det_id: DET1, cantidad: 5, estado: 'cancelada' },
        { requisicion_det_id: DET3, cantidad: 1 },
      ],
      facturadas: [{ requisicion_det_id: DET1, cantidad: 1 }],
      gastadas: [{ requisicion_det_id: DET2, cantidad: 0.5 }],
    });
    const r = await service.lineasParaOc('req-1', 'emp-1', 'usr-1');
    expect(r).toEqual({
      requisicion: { id: 'req-1', numero_requisicion: 'REQ-2026-000001', estado: 'aprobada', sucursal_id: SUC, descripcion: 'Insumos de oficina' },
      moneda: { codigo: 'PYG' },
      lineas: [
        {
          id: DET1,
          producto: { id: PROD1, codigo: 'P-1', descripcion: 'Resma A4' },
          descripcion: null,
          centro_costo_id: null,
          cantidad_solicitada: '10.0000',
          disponible: '6.0000',
          precio_unitario: '1500.0000',
          porcentaje_iva: '10.00',
        },
        {
          id: DET2,
          producto: null,
          descripcion: 'Servicio de flete',
          centro_costo_id: null,
          cantidad_solicitada: '2.0000',
          disponible: '1.5000',
          precio_unitario: '50000.0000',
          porcentaje_iva: '5.00',
        },
      ],
    });
  });

  it('una requisición de gasto → REQUISICION_NO_DISPONIBLE', async () => {
    const { service } = armar({ origen: 'gasto' });
    const e = await error(service.lineasParaOc('req-1', 'emp-1', 'usr-1'));
    expect(e.getStatus()).toBe(400);
    expect(cuerpo(e)).toMatchObject({ codigo: 'REQUISICION_NO_DISPONIBLE', estado_actual: 'aprobada' });
  });

  it('pendiente de aprobación → REQUISICION_NO_DISPONIBLE', async () => {
    const { service } = armar({ estado: 'pendiente_aprobacion' });
    const e = await error(service.lineasParaOc('req-1', 'emp-1', 'usr-1'));
    expect(cuerpo(e)).toMatchObject({ codigo: 'REQUISICION_NO_DISPONIBLE', estado_actual: 'pendiente_aprobacion' });
  });

  it('fuera del alcance por sucursal → 404 (ruling F6)', async () => {
    alcanceMock.mockResolvedValue({ sucursalIds: [OTRA_SUC], puntosEstablecimiento: [], depositoIds: [] });
    const { service } = armar();
    const e = await error(service.lineasParaOc('req-1', 'emp-1', 'usr-1'));
    expect(e.getStatus()).toBe(404);
  });

  it('con la OC apagada (bandera o submódulo) → OC_DESHABILITADA', async () => {
    const { service } = armar({ config: { habilitar_orden_compra: false } });
    expect(cuerpo(await error(service.lineasParaOc('req-1', 'emp-1', 'usr-1'))).codigo).toBe('OC_DESHABILITADA');
    submoduloMock.mockResolvedValue({ habilitado: false, causa: 'excluido', mensaje: 'x' });
    const { service: s2 } = armar();
    expect(cuerpo(await error(s2.lineasParaOc('req-1', 'emp-1', 'usr-1'))).codigo).toBe('OC_DESHABILITADA');
  });
});

describe('Requisiciones - REQUISICIONES_DESHABILITADAS (ruling F4b)', () => {
  const apagada = () => armar({ config: { habilitar_requisicion_compra: false } });

  it.each([
    ['lineasParaOc', (s: RequisicionesService) => s.lineasParaOc('req-1', 'emp-1', 'usr-1')],
    ['generar', (s: RequisicionesService) => s.generarOrdenesCompraDistribuidas('req-1', 'emp-1', dtoBase([asig(DET1, PROV_A, 1)]), 'usr-1')],
    ['crear-orden-compra', (s: RequisicionesService) => s.crearOrdenCompraDesdeRequisicion('req-1', 'emp-1', { proveedor_id: PROV_A, sucursal_id: SUC } as any, 'usr-1')],
    ['referencia-producto', (s: RequisicionesService) => s.referenciaProducto('emp-1', PROD1)],
  ])('%s responde 400 REQUISICIONES_DESHABILITADAS', async (_n, llamar) => {
    const { service } = apagada();
    const e = await error(llamar(service));
    expect(e.getStatus()).toBe(400);
    expect(cuerpo(e).codigo).toBe('REQUISICIONES_DESHABILITADAS');
  });

  it('findOne y findAll no miran la bandera: las lecturas siguen', async () => {
    const { service, prisma } = apagada();
    (service.findOne as jest.Mock).mockRestore();
    prisma.requisicion_cab.findFirst.mockResolvedValue(null);
    const e = await error(service.findOne('req-x', 'emp-1', 'usr-1'));
    expect(e.getStatus()).toBe(404);

    prisma.requisicion_cab.findMany = jest.fn().mockResolvedValue([]);
    prisma.requisicion_cab.count = jest.fn().mockResolvedValue(0);
    prisma.requisicion_cab.groupBy = jest.fn().mockResolvedValue([]);
    // El listado pregunta por `_APROBAR` (Esperan mi aprobación); sin él, no hay perfiles que buscar.
    prisma.usuario = { findUnique: jest.fn().mockResolvedValue({ is_superadmin: false }) };
    prisma.perfiles_privilegios = { findFirst: jest.fn().mockResolvedValue(null) };
    prisma.$transaction.mockImplementation(async (arg: any) => (Array.isArray(arg) ? Promise.all(arg) : arg(prisma)));
    await expect(service.findAll('emp-1', 'usr-1', {})).resolves.toMatchObject({ total: 0 });
    expect(prisma.config_compras.findUnique).not.toHaveBeenCalled();
  });
});

describe('GenerarOrdenesCompraDistribuidasDto', () => {
  const pipe = new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true, transform: true });
  const validar = (body: unknown) => pipe.transform(body, { type: 'body', metatype: GenerarOrdenesCompraDistribuidasDto });
  const ok = { sucursal_id: SUC, moneda_id: MON_USD, cotizacion: 7300, asignaciones: [{ requisicion_det_id: DET1, proveedor_id: PROV_A, precio_unitario: 2.5 }] };

  it('acepta cotizacion y precio_unitario', async () => {
    await expect(validar(ok)).resolves.toMatchObject({ cotizacion: 7300 });
  });

  it('la cotización 1 llega al servicio (que responde COTIZACION_INVALIDA)', async () => {
    await expect(validar({ ...ok, cotizacion: 1 })).resolves.toMatchObject({ cotizacion: 1 });
  });

  it.each([
    ['sin precio', { requisicion_det_id: DET1, proveedor_id: PROV_A }, 'precio_unitario'],
    ['precio 0', { requisicion_det_id: DET1, proveedor_id: PROV_A, precio_unitario: 0 }, 'precio_unitario'],
    ['precio negativo', { requisicion_det_id: DET1, proveedor_id: PROV_A, precio_unitario: -1 }, 'precio_unitario'],
    ['precio con 5 decimales', { requisicion_det_id: DET1, proveedor_id: PROV_A, precio_unitario: 1.00001 }, 'precio_unitario'],
    ['cantidad 0', { requisicion_det_id: DET1, proveedor_id: PROV_A, precio_unitario: 1, cantidad: 0 }, 'cantidad'],
    ['cantidad negativa', { requisicion_det_id: DET1, proveedor_id: PROV_A, precio_unitario: 1, cantidad: -2 }, 'cantidad'],
    ['cantidad con 5 decimales', { requisicion_det_id: DET1, proveedor_id: PROV_A, precio_unitario: 1, cantidad: 1.00001 }, 'cantidad'],
  ])('asignación %s → 400 sobre esa propiedad', async (_n, a, propiedad) => {
    const e = await error(validar({ ...ok, asignaciones: [a] }));
    expect(e.getStatus()).toBe(400);
    const mensajes: string[] = cuerpo(e).message;
    expect(mensajes.length).toBeGreaterThan(0);
    expect(mensajes.every((m) => m.startsWith(`asignaciones.0.${propiedad} `))).toBe(true);
  });
});
