import { GUARDS_METADATA } from '@nestjs/common/constants';
import { readFileSync } from 'fs';
import { join } from 'path';
import { REQUIRE_PERMISSION_KEY } from 'src/auth/decorators/require-permission.decorator';
import { REQUIRE_ALGUN_PRIVILEGIO_KEY } from 'src/auth/guards/algun-privilegio.guard';
import { submoduloHabilitado } from 'src/auth/guards/submodulo.guard';
import { GastosController } from 'src/gastos/gastos.controller';
import { GastosService } from 'src/gastos/gastos.service';
import { alcanceSucursalUsuario } from 'src/utils/alcance-sucursal';
import { aplicarEjecucionRequisicion, revaluarEjecucionRequisicion, revertirEjecucionRequisicion } from './ejecucion-requisicion';
import { armar as armarEjecucion, params as paramsEjecucion } from './ejecucion-requisicion.fixture';
import { nivelesParaMonto } from './reglas-requisicion';
import * as G from './requisiciones-generar-oc.fixture';
import { armar as armarLecturas } from './requisiciones-lecturas.fixture';
import * as W from './requisiciones-workflow.fixture';
import { UpsertRequisicionAprobacionConfigDto } from './dto/requisicion-config.dto';
import { RequisicionesController } from './requisiciones.controller';
import { RequisicionesService } from './requisiciones.service';
import { validarDto } from 'src/common/utils/validar-dto.testutil';

// Por default todo contratado; el caso «COMPRAS no contratado» lo cambia en su test.
jest.mock('src/seguridad/privilegios-contratados', () => ({
  privilegiosContratados: jest.fn(async () => ({ has: () => true })),
}));

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 });
});

/**
 * Matriz «Probar según configuración» del spec de Requisiciones (filas 1 a 18), perfiles y ciclos, contra los servicios
 * reales con la base falsa de cada spec del módulo (fixtures `*.fixture.ts`). Los permisos por handler viven en los
 * decoradores del controller (lo que evalúa `PermissionGuard`), así que se prueban leyendo esa metadata, no en el
 * servicio. Lo que vive en Facturas y Gastos (bloqueo de lo directo, contado y crédito) lo cubren sus specs
 * (`compras.service.spec.ts`, `gastos*.spec.ts`).
 */

/** Las configuraciones reales y las de prueba que la matriz nombra. */
const CONFIGS = {
  apagada: { habilitar_requisicion_compra: false, modo_flujo_compra: 'directo', habilitar_orden_compra: true },
  agogo: { habilitar_requisicion_compra: true, modo_flujo_compra: 'directo', habilitar_orden_compra: true },
  opcional: { habilitar_requisicion_compra: true, modo_flujo_compra: 'requisicion_opcional', habilitar_orden_compra: true },
  obligatoria: { habilitar_requisicion_compra: true, modo_flujo_compra: 'requisicion_obligatoria', habilitar_orden_compra: true },
} as const;

const REQ_ID = 'req-1';
const EMP = 'emp-1';
const USR = 'usr-1';
const FECHA = '2026-10-05T12:00:00.000Z';

const altaCompra = (items: any[] = [{ descripcion: 'Resma', cantidad_solicitada: 1, precio_unitario: 1000 }], cab: Record<string, unknown> = {}): any => ({
  cabecera: { origen_tipo: 'compra', sucursal_id: W.SUC, ...cab },
  items,
});

const producto = (over: Record<string, unknown> = {}) => ({ id: 'prod-1', precio_costo: 0, precio: 0, porcentaje_iva: 10, ...over });

/** Detalle mínimo como lo devuelve Prisma (el completo y sus documentos los cubre `requisiciones-lecturas.spec.ts`). */
const detalleDb = (over: Record<string, unknown> = {}): any => ({
  id: 'r-0001',
  empresa_id: EMP,
  sucursal_id: W.SUC,
  numero_requisicion: 'REQ-2026-0001',
  origen_tipo: 'compra',
  estado: 'pendiente_aprobacion',
  fecha_requisicion: new Date('2026-10-05T00:00:00.000Z'),
  descripcion: 'Insumos',
  total_estimado: 1_000_000,
  total_para_aprobacion: 1_000_000,
  total_ejecutado: 0,
  motivo_rechazo: null,
  motivo_cancelacion: null,
  fecha_aprobacion_final: null,
  updated_at: new Date('2026-10-05T12:00:00.000Z'),
  created_at: new Date('2026-10-05T10:00:00.000Z'),
  empresas_sucursales: { id: W.SUC, descripcion: 'Casa Central', punto_establecimiento: '001' },
  solicitante: { id: USR, username: 'ana', nombres: 'Ana', apellidos: 'Gómez' },
  aprobador_final: null,
  requisicion_det: [],
  requisicion_aprobacion: [
    { id: 'ap-1', nivel: 1, estado: 'pendiente', perfil_id: W.PERFIL_1, fecha_resuelta: null, comentario: null, perfiles: { id: W.PERFIL_1, perfil: 'JEFE', desc_perfil: 'Jefe' }, usuario: null },
  ],
  requisicion_historial: [],
  ...over,
});

/* ───────────── Fila 1 y 12: requisiciones apagadas ───────────── */

describe('fila 1 y 12 - requisiciones apagadas (config real de las 8 empresas locales)', () => {
  const escrituras: Array<[string, (s: any) => Promise<unknown>]> = [
    ['alta', (s) => s.create(altaCompra(), EMP, USR)],
    ['editar', (s) => s.update(REQ_ID, { updated_at: FECHA } as any, EMP, USR)],
    ['enviar', (s) => s.enviarAprobacion(REQ_ID, EMP, USR)],
    ['aprobar', (s) => s.aprobar(REQ_ID, EMP, USR, { nivel: 1 })],
    ['rechazar', (s) => s.rechazar(REQ_ID, EMP, USR, { nivel: 1, motivo: 'x' })],
    ['cancelar', (s) => s.cancelar(REQ_ID, EMP, USR, { motivo: 'x' })],
  ];

  it.each(escrituras)('%s → 400 REQUISICIONES_DESHABILITADAS y no escribe nada', async (_n, accion) => {
    const { service, tx } = W.armar({ habilitada: false, estado: 'pendiente_aprobacion', aprobaciones: [W.ap(1)], perfilesUsuario: [W.PERFIL_1] });
    const e = await W.error(accion(service));
    expect(e.getStatus()).toBe(400);
    expect(W.cuerpo(e)).toMatchObject({ codigo: 'REQUISICIONES_DESHABILITADAS' });
    expect(tx.requisicion_cab.create).not.toHaveBeenCalled();
    expect(tx.requisicion_cab.update).not.toHaveBeenCalled();
    expect(tx.requisicion_aprobacion.createMany).not.toHaveBeenCalled();
    expect(tx.requisicion_historial.create).not.toHaveBeenCalled();
  });

  const conOc: Array<[string, (s: any) => Promise<unknown>]> = [
    ['lineas-para-oc', (s) => s.lineasParaOc(REQ_ID, EMP, USR)],
    ['generar órdenes', (s) => s.generarOrdenesCompraDistribuidas(REQ_ID, EMP, G.dtoBase([G.asig(G.DET1, G.PROV_A, 1)]), USR)],
    ['crear-orden-compra', (s) => s.crearOrdenCompraDesdeRequisicion(REQ_ID, EMP, { proveedor_id: G.PROV_A, sucursal_id: G.SUC } as any, USR)],
    ['referencia-producto', (s) => s.referenciaProducto(EMP, 'prod-1')],
  ];

  it.each(conOc)('%s → 400 REQUISICIONES_DESHABILITADAS y no crea ninguna OC', async (_n, accion) => {
    const { service, base, crearEnTx } = G.armar({ config: CONFIGS.apagada });
    const e = await G.error(accion(service));
    expect(e.getStatus()).toBe(400);
    expect(G.cuerpo(e)).toMatchObject({ codigo: 'REQUISICIONES_DESHABILITADAS' });
    expect(crearEnTx).not.toHaveBeenCalled();
    expect(base.ocs).toEqual([]);
  });

  it('gastos/requisiciones-origen → 400 REQUISICIONES_DESHABILITADAS (también sin fila de config)', async () => {
    for (const fila of [{ habilitar_requisicion_compra: false }, null]) {
      const prisma: any = { config_compras: { findUnique: jest.fn().mockResolvedValue(fila) }, requisicion_cab: { findFirst: jest.fn() } };
      const gastos = new GastosService(prisma, {} as any, {} as any, {} as any, {} as any);
      const e = await G.error(gastos.requisicionOrigen(EMP, USR, REQ_ID));
      expect(e.getStatus()).toBe(400);
      expect(G.cuerpo(e)).toMatchObject({ codigo: 'REQUISICIONES_DESHABILITADAS' });
      expect(prisma.requisicion_cab.findFirst).not.toHaveBeenCalled();
    }
  });

  it('las lecturas no responden 400: el listado, el contexto y los niveles siguen (la pestaña lee habilitada: false)', async () => {
    const { service } = armarLecturas({ config: CONFIGS.apagada, filas: [], detalle: detalleDb() });
    await expect(service.findAll(EMP, USR, {})).resolves.toMatchObject({ data: [] });
    await expect(service.contexto(EMP, USR)).resolves.toMatchObject({ habilitada: false });
    await expect(service.nivelesAplicables(EMP, 'compra', 10)).resolves.toEqual([]);
    // Una requisición real: con la bandera apagada el detalle resuelve con sus datos (no 400 ni 404).
    await expect(service.findOne('r-0001', EMP, USR)).resolves.toMatchObject({
      id: 'r-0001',
      numero_requisicion: 'REQ-2026-0001',
      estado: 'pendiente_aprobacion',
    });
  });

  it('con requisiciones vivas, la ejecución desde Facturas y Gastos no mira la bandera (fila 12): aplicar, revertir y revaluar', async () => {
    // El `tx` falso no tiene `config_compras`: si la ejecución la leyera, fallaría con TypeError.
    const { tx, det, cab } = armarEjecucion();
    expect(tx.config_compras).toBeUndefined();
    await aplicarEjecucionRequisicion(tx, paramsEjecucion());
    expect(det[0]).toMatchObject({ cantidad_ejecutada: 4, monto_ejecutado: 400000, estado: 'ejecutada_parcial' });
    await revaluarEjecucionRequisicion(tx, {
      empresaId: 'emp',
      requisicionId: REQ_ID,
      items: [{ requisicion_det_id: 'rd-1', cantidad: 4, subtotal: 100 }],
      antes: { monedaCodigo: 'USD', cotizacion: 7000 },
      despues: { monedaCodigo: 'USD', cotizacion: 7300 },
      fechaOperacion: new Date('2026-10-05T00:00:00.000Z'),
    });
    expect(det[0].monto_ejecutado).toBe(430000);
    await revertirEjecucionRequisicion(tx, paramsEjecucion({ monedaCodigo: 'USD', cotizacion: 7300, items: [{ requisicion_det_id: 'rd-1', cantidad: 4, subtotal: 100 }] }));
    expect(det[0]).toMatchObject({ cantidad_ejecutada: 0, estado: 'pendiente' });
    expect(cab.estado).toBe('aprobada');
  });
});

/* ───────────── Fila 2: Agogó, directo y sin niveles ───────────── */

describe('fila 2 - Agogó: encendida, modo directo, sin niveles', () => {
  it.each([
    ['con ADM_CCFG_CONFIG_VER', ['ADM_CCFG_CONFIG_VER'], true],
    ['sin ADM_CCFG_CONFIG_VER', [], false],
  ])('el contexto avisa de los niveles faltantes %s', async (_n, privilegios, puedeVer) => {
    const { service } = armarLecturas({ config: CONFIGS.agogo, configsNiveles: [], privilegios });
    await expect(service.contexto(EMP, USR)).resolves.toMatchObject({
      habilitada: true,
      modo_flujo: 'directo',
      niveles: { compra: false, gasto: false },
      puede_ver_config: puedeVer,
    });
  });

  it('un borrador se guarda sin mirar los niveles', async () => {
    const { service, tx } = W.armar({ configs: [] });
    await service.create(altaCompra(), EMP, USR);
    expect(tx.requisicion_cab.create.mock.calls[0][0].data.estado).toBe('borrador');
    expect(tx.requisicion_aprobacion_config.findMany).not.toHaveBeenCalled();
  });

  it.each(['compra', 'gasto'])('enviar una requisición de %s → 400 SIN_NIVELES_APROBACION con el origen', async (origen) => {
    const { service, tx } = W.armar({ configs: [], origen });
    const e = await W.error(service.enviarAprobacion(REQ_ID, EMP, USR));
    expect(e.getStatus()).toBe(400);
    expect(W.cuerpo(e)).toMatchObject({ codigo: 'SIN_NIVELES_APROBACION', origen });
    expect(tx.requisicion_aprobacion.createMany).not.toHaveBeenCalled();
    expect(tx.requisicion_cab.update).not.toHaveBeenCalled();
  });

  it('guardar y enviar → el mismo 400 y no queda nada fuera de la transacción', async () => {
    const { service, prisma, tx } = W.armar({ configs: [] });
    const e = await W.error(service.create({ ...altaCompra(), enviar_a_aprobacion: true }, EMP, USR));
    expect(W.cuerpo(e)).toMatchObject({ codigo: 'SIN_NIVELES_APROBACION' });
    expect(prisma.$transaction).toHaveBeenCalledTimes(1);
    expect(tx.requisicion_aprobacion.createMany).not.toHaveBeenCalled();
  });
});

/* ───────────── Filas 3, 4 y 5: niveles ───────────── */

describe('fila 3 - requisicion_opcional con la config recomendada (rangos exclusivos, con ,01)', () => {
  const D = (v: number) => v as any;
  const recomendada = [
    { nivel: 1, perfil_id: W.PERFIL_1, monto_desde: D(0), monto_hasta: D(1_000_000), activo: true, perfiles: { id: W.PERFIL_1, perfil: 'Compras Jr', desc_perfil: 'Compras Junior' } },
    { nivel: 2, perfil_id: W.PERFIL_2, monto_desde: D(1_000_000.01), monto_hasta: D(5_000_000), activo: true, perfiles: { id: W.PERFIL_2, perfil: 'Compras Sr', desc_perfil: 'Compras Senior' } },
    { nivel: 3, perfil_id: 'p3', monto_desde: D(5_000_000.01), monto_hasta: D(50_000_000), activo: true, perfiles: { id: 'p3', perfil: 'Gte Compras', desc_perfil: 'Gerente de Compras' } },
    { nivel: 4, perfil_id: 'p4', monto_desde: D(50_000_000.01), monto_hasta: null, activo: true, perfiles: { id: 'p4', perfil: 'Dir Financiero', desc_perfil: 'Director Financiero' } },
  ];

  it.each([
    [0, 1],
    [1_000_000, 1],
    [1_000_000.5, 2],
    [1_000_000.01, 2],
    [5_000_000, 2],
    [5_000_000.01, 3],
    [50_000_000.01, 4],
    [60_000_000, 4],
  ])('un total de %d cae en un solo nivel: el %d', async (monto, nivel) => {
    const { service } = armarLecturas({ config: CONFIGS.opcional, configsNiveles: recomendada });
    const r = await service.nivelesAplicables(EMP, 'compra', monto);
    expect(r.map((n) => n.nivel)).toEqual([nivel]);
  });

  it('un ítem libre va por monto como los demás: 3.000.000 → nivel 2 al enviar', async () => {
    const { service, tx } = W.armar({
      total: 3_000_000,
      det: [{ id: 'd1', producto_id: null }],
      configs: [W.cfg(1, 0, 1_000_000), W.cfg(2, 1_000_000.01, 5_000_000)],
    });
    await service.enviarAprobacion(REQ_ID, EMP, USR);
    expect(tx.requisicion_aprobacion.createMany.mock.calls[0][0].data.map((f: any) => f.nivel)).toEqual([2]);
  });

  it('aprobar con el perfil del nivel y _APROBAR del controller → aprueba', async () => {
    const { service, tx } = W.armar({ estado: 'pendiente_aprobacion', aprobaciones: [W.ap(1)], perfilesUsuario: [W.PERFIL_1] });
    await service.aprobar(REQ_ID, EMP, USR, { nivel: 1 });
    expect(W.hist(tx).map((h: any) => h.accion)).toEqual(['aprobada']);
  });

  it('aprobar sin el perfil del nivel → 403 SIN_PERFIL_DEL_NIVEL y el detalle no ofrece Aprobar (puedo_aprobar false)', async () => {
    const lectura = armarLecturas({ detalle: detalleDb(), perfilesUsuario: [W.PERFIL_2], privilegios: ['CMP_REQ_REQUISICION_APROBAR'] });
    await expect(lectura.service.findOne('r-0001', EMP, USR)).resolves.toMatchObject({ puedo_aprobar: false });
    const { service, tx } = W.armar({ estado: 'pendiente_aprobacion', aprobaciones: [W.ap(1)], perfilesUsuario: [W.PERFIL_2] });
    const e = await W.error(service.aprobar(REQ_ID, EMP, USR, { nivel: 1 }));
    expect(e.getStatus()).toBe(403);
    expect(W.cuerpo(e)).toMatchObject({ codigo: 'SIN_PERFIL_DEL_NIVEL', nivel: 1 });
    expect(tx.requisicion_aprobacion.update).not.toHaveBeenCalled();
  });
});

describe('fila 4 - niveles superpuestos (nivel 1 de 0 sin tope, nivel 2 desde 5.000.000)', () => {
  const configs = [W.cfg(1, 0, null), W.cfg(2, 5_000_000, null)];
  const niveles = (tx: any) => tx.requisicion_aprobacion.createMany.mock.calls[0][0].data.map((f: any) => f.nivel);

  it('6.000.000 pide dos niveles; 1.000.000 pide solo el 1', async () => {
    const alto = W.armar({ total: 6_000_000, configs });
    await alto.service.enviarAprobacion(REQ_ID, EMP, USR);
    expect(niveles(alto.tx)).toEqual([1, 2]);
    const bajo = W.armar({ total: 1_000_000, configs });
    await bajo.service.enviarAprobacion(REQ_ID, EMP, USR);
    expect(niveles(bajo.tx)).toEqual([1]);
  });

  it('aprobar el 1 la deja pendiente («Nivel 2»); aprobar el 2 la aprueba con aprobador final', async () => {
    const uno = W.armar({ estado: 'pendiente_aprobacion', aprobaciones: [W.ap(1), W.ap(2)], perfilesUsuario: [W.PERFIL_1] });
    await uno.service.aprobar(REQ_ID, EMP, USR, { nivel: 1 });
    expect(uno.tx.requisicion_cab.update).not.toHaveBeenCalled();
    expect(W.hist(uno.tx).map((h: any) => h.accion)).toEqual(['aprobada_nivel']);
    const dos = W.armar({ estado: 'pendiente_aprobacion', aprobaciones: [W.ap(1, 'aprobada'), W.ap(2)], perfilesUsuario: [W.PERFIL_2] });
    await dos.service.aprobar(REQ_ID, EMP, 'usr-2', { nivel: 2 });
    expect(dos.tx.requisicion_cab.update.mock.calls[0][0].data).toMatchObject({ estado: 'aprobada', aprobador_final_id: 'usr-2' });
  });

  it('rechazar en el 2 cierra todo', async () => {
    const { service, tx } = W.armar({ estado: 'pendiente_aprobacion', aprobaciones: [W.ap(1, 'aprobada'), W.ap(2)], perfilesUsuario: [W.PERFIL_2] });
    await service.rechazar(REQ_ID, EMP, 'usr-2', { nivel: 2, motivo: 'Sin presupuesto' });
    expect(tx.requisicion_aprobacion.updateMany.mock.calls[0][0]).toMatchObject({ where: { requisicion_id: REQ_ID, estado: 'pendiente' }, data: { estado: 'rechazada' } });
    expect(tx.requisicion_cab.update.mock.calls[0][0].data).toMatchObject({ estado: 'rechazada', motivo_rechazo: 'Sin presupuesto' });
  });
});

describe('fila 5 - un nivel inactivo', () => {
  it('no se copia al enviar', async () => {
    const { service, tx } = W.armar({ total: 6_000_000, configs: [W.cfg(1, 0, null), { ...W.cfg(2, 5_000_000, null), activo: false }] });
    await service.enviarAprobacion(REQ_ID, EMP, USR);
    expect(tx.requisicion_aprobacion.createMany.mock.calls[0][0].data.map((f: any) => f.nivel)).toEqual([1]);
  });
});

/* ───────────── Fila 6: origen gasto ───────────── */

describe('fila 6 - origen gasto', () => {
  it('enviar pide los niveles del origen gasto', async () => {
    const { service, tx } = W.armar({ origen: 'gasto', configs: [W.cfg(1, 0, null)] });
    await service.enviarAprobacion(REQ_ID, EMP, USR);
    expect(tx.requisicion_aprobacion_config.findMany.mock.calls[0][0].where).toMatchObject({ origen_tipo: 'gasto' });
  });

  it('una requisición de gasto no genera órdenes de compra: REQUISICION_NO_DISPONIBLE', async () => {
    const { service, crearEnTx } = G.armar({ origen: 'gasto' });
    const e = await G.error(service.generarOrdenesCompraDistribuidas(REQ_ID, EMP, G.dtoBase([G.asig(G.DET1, G.PROV_A, 1)]), USR));
    expect(G.cuerpo(e)).toMatchObject({ codigo: 'REQUISICION_NO_DISPONIBLE' });
    expect(crearEnTx).not.toHaveBeenCalled();
  });

  it('un gasto en USD ejecuta en guaraníes y anularlo devuelve lo pendiente', async () => {
    const { tx, det, cab } = armarEjecucion();
    const gasto = paramsEjecucion({ monedaCodigo: 'USD', cotizacion: 7300, items: [{ requisicion_det_id: 'rd-1', cantidad: 4, subtotal: 100 }] });
    await aplicarEjecucionRequisicion(tx, gasto);
    expect(det[0]).toMatchObject({ cantidad_ejecutada: 4, monto_ejecutado: 730000, estado: 'ejecutada_parcial' });
    expect(cab.estado).toBe('ejecutada_parcial');
    await revertirEjecucionRequisicion(tx, gasto);
    expect(det[0]).toMatchObject({ cantidad_ejecutada: 0, monto_ejecutado: 0, estado: 'pendiente' });
    expect(cab).toMatchObject({ estado: 'aprobada', total_ejecutado: 0 });
  });
});

/* ───────────── Fila 7: requisicion_obligatoria ───────────── */

describe('fila 7 - requisicion_obligatoria', () => {
  const dtoOc = (extra: Record<string, unknown> = {}): any => ({
    cabecera: { sucursal_id: G.SUC, proveedor_id: G.PROV_A, moneda_id: G.MON_PYG, fecha_emision: '2026-10-29', ...extra },
    items: [{ descripcion: 'Resma', cantidad: 1, precio_unitario: 1500, porcentaje_iva: 10 }],
  });

  it('una OC directa (sin requisición) se rechaza; generada desde la requisición pasa', async () => {
    const { prisma, oc, service, base } = G.armar({ config: CONFIGS.obligatoria });
    const e = await G.error(prisma.$transaction((tx: any) => oc.crearEnTx(tx, dtoOc(), EMP, USR, { origen: 'pantalla' })));
    expect(e.getStatus()).toBe(400);
    expect(e.message).toMatch(/requisición obligatoria/i);
    expect(base.ocs).toEqual([]);
    await service.generarOrdenesCompraDistribuidas(REQ_ID, EMP, G.dtoBase([G.asig(G.DET1, G.PROV_A, 1)]), USR);
    expect(base.ocs).toHaveLength(1);
    expect(base.ocs[0].requisicion_id).toBe(REQ_ID);
  });

  it('la ejecución que aplica la factura de la OC lleva la requisición a ejecutada parcial y después total (el vínculo OC → factura lo cubre compras.service.spec)', async () => {
    const { tx, det, cab } = armarEjecucion();
    await aplicarEjecucionRequisicion(tx, paramsEjecucion({ items: [{ requisicion_det_id: 'rd-1', cantidad: 4, subtotal: 400000 }] }));
    expect([det[0].estado, cab.estado]).toEqual(['ejecutada_parcial', 'ejecutada_parcial']);
    await aplicarEjecucionRequisicion(tx, paramsEjecucion({ items: [{ requisicion_det_id: 'rd-1', cantidad: 6, subtotal: 600000 }] }));
    expect([det[0].estado, cab.estado]).toEqual(['ejecutada_total', 'ejecutada_total']);
  });
});

/* ───────────── Filas 8 a 11: Compras (OC, aprobación, recepciones, contabilidad) ───────────── */

describe('fila 8 - requisiciones encendidas y habilitar_orden_compra apagada', () => {
  const config = { ...CONFIGS.opcional, habilitar_orden_compra: false };
  const generar = (s: any) => s.generarOrdenesCompraDistribuidas(REQ_ID, EMP, G.dtoBase([G.asig(G.DET1, G.PROV_A, 1)]), USR);

  it.each([
    ['generar órdenes', generar],
    ['lineas-para-oc', (s: any) => s.lineasParaOc(REQ_ID, EMP, USR)],
  ])('%s → 400 OC_DESHABILITADA y no crea nada', async (_n, accion) => {
    const { service, base } = G.armar({ config });
    const e = await G.error(accion(service));
    expect(e.getStatus()).toBe(400);
    expect(G.cuerpo(e)).toMatchObject({ codigo: 'OC_DESHABILITADA' });
    expect(base.ocs).toEqual([]);
  });

  it('el contexto lo dice (oc_habilitada: false) para deshabilitar el botón con el motivo', async () => {
    const { service } = armarLecturas({ config });
    await expect(service.contexto(EMP, USR)).resolves.toMatchObject({ habilitada: true, oc_habilitada: false });
  });
});

describe('fila 9 - OC con aprobación', () => {
  it.each([
    [{ requiere_aprobacion: true }, 'pendiente_aprobacion'],
    [{ usar_workflow: true }, 'pendiente_aprobacion'],
    [{ workflow_obligatorio: true }, 'pendiente_aprobacion'],
    [{}, 'pendiente'],
  ])('con %o las OC generadas quedan %s y la respuesta lo trae para el resumen', async (config, estado) => {
    const { service } = G.armar({ config });
    const r = await service.generarOrdenesCompraDistribuidas(REQ_ID, EMP, G.dtoBase([G.asig(G.DET1, G.PROV_A, 1), G.asig(G.DET2, G.PROV_B, 1)]), USR);
    expect(r.ordenes.map((o) => o.estado)).toEqual([estado, estado]);
  });
});

describe('fila 10 - Recepciones y matching 3 vías encendidos o apagados', () => {
  it.each([
    [true, true],
    [true, false],
    [false, true],
    [false, false],
  ])('recepción %s y matching %s: generar no depende de esos flags (OC pendiente, sin tocar la cabecera de la requisición)', async (recepcion, matching) => {
    const { service, base, prisma } = G.armar({ config: { habilitar_recepcion_compra: recepcion, habilitar_matching_3_vias: matching } });
    const r = await service.generarOrdenesCompraDistribuidas(REQ_ID, EMP, G.dtoBase([G.asig(G.DET1, G.PROV_A, 1)]), USR);
    expect(r.ordenes.map((o) => o.estado)).toEqual(['pendiente']);
    expect(base.ocs).toHaveLength(1);
    // La ejecución llega al facturar (compras/gastos), no al generar la OC.
    expect(prisma.requisicion_cab.update).not.toHaveBeenCalled();
  });
});

describe('fila 11 - módulo Contabilidad encendido o apagado', () => {
  it.each([true, false])('el contexto trae contabilidad: %s', async (contabilidad) => {
    const { service } = armarLecturas({ config: CONFIGS.opcional, contabilidad });
    await expect(service.contexto(EMP, USR)).resolves.toMatchObject({ contabilidad });
  });

  it('encendido: el centro de costo es obligatorio en las OC; con él pasa', async () => {
    const sin = G.armar({ contabilidad: true });
    const e = await G.error(sin.service.generarOrdenesCompraDistribuidas(REQ_ID, EMP, G.dtoBase([G.asig(G.DET1, G.PROV_A, 1)]), USR));
    expect(e.getStatus()).toBe(400);
    expect(e.message).toMatch(/centro de costo es obligatorio/i);
    expect(sin.base.ocs).toEqual([]);
    const con = G.armar({ contabilidad: true });
    const r = await con.service.generarOrdenesCompraDistribuidas(REQ_ID, EMP, G.dtoBase([{ ...G.asig(G.DET1, G.PROV_A, 1), centro_costo_id: 'cc-1' }]), USR);
    expect(r.ordenes).toHaveLength(1);
  });

  it('apagado: sin centro de costo pasa', async () => {
    const { service } = G.armar({ contabilidad: false });
    const r = await service.generarOrdenesCompraDistribuidas(REQ_ID, EMP, G.dtoBase([G.asig(G.DET1, G.PROV_A, 1)]), USR);
    expect(r.ordenes).toHaveLength(1);
  });
});

/* ───────────── Filas 13 a 16: precio estimado ───────────── */

describe('filas 13 a 16 - precio estimado contra el costo del producto', () => {
  const NIVELES = [
    { nivel: 1, monto_desde: 0, monto_hasta: 1_000_000, activo: true },
    { nivel: 2, monto_desde: 1_000_000.01, monto_hasta: null, activo: true },
  ];
  const alta = async (productoRow: any, linea: Record<string, unknown>) => {
    const { service, tx } = W.armar();
    tx.productos.findFirst.mockResolvedValue(productoRow);
    await service.create(altaCompra([{ producto_id: 'prod-1', cantidad_solicitada: 600, ...linea }]), EMP, USR);
    const cab = tx.requisicion_cab.create.mock.calls[0][0].data;
    const fila = tx.requisicion_det.createMany.mock.calls[0][0].data[0];
    return { total_estimado: Number(cab.total_estimado), total_para_aprobacion: Number(cab.total_para_aprobacion), fila };
  };
  const nivelDe = (total: number) => nivelesParaMonto(NIVELES, total).map((n) => n.nivel);

  it('13: precio precargado con el costo y editado hacia arriba → los dos totales suben y pasa al nivel 2', async () => {
    const alCosto = await alta(producto({ precio_costo: 1500 }), { precio_unitario: 1500 });
    expect([alCosto.total_estimado, alCosto.total_para_aprobacion, nivelDe(alCosto.total_para_aprobacion)]).toEqual([900_000, 900_000, [1]]);
    const arriba = await alta(producto({ precio_costo: 1500 }), { precio_unitario: 2000 });
    expect([arriba.total_estimado, arriba.total_para_aprobacion, nivelDe(arriba.total_para_aprobacion)]).toEqual([1_200_000, 1_200_000, [2]]);
  });

  it('14: precio por debajo del costo → total_para_aprobacion usa el costo (mismo nivel); total_estimado baja', async () => {
    const abajo = await alta(producto({ precio_costo: 1500 }), { precio_unitario: 1000 });
    expect(abajo.total_estimado).toBe(600_000);
    expect(abajo.total_para_aprobacion).toBe(900_000);
    expect(abajo.fila.costo_referencia).toBe(1500);
    expect(nivelDe(abajo.total_para_aprobacion)).toEqual([1]);
  });

  it('16: producto sin costo ni lista → costo_referencia 0 y el nivel usa lo cargado; el GET de referencia da null', async () => {
    const r = await alta(producto(), { precio_unitario: 2000 });
    expect(r.fila.costo_referencia).toBe(0);
    expect(r.total_para_aprobacion).toBe(1_200_000);
    expect(nivelDe(r.total_para_aprobacion)).toEqual([2]);
    const { service, prisma } = G.armar({ config: CONFIGS.opcional });
    prisma.productos.findFirst = jest.fn().mockResolvedValue(producto());
    await expect(service.referenciaProducto(EMP, 'prod-1')).resolves.toEqual({ producto_id: 'prod-1', costo_referencia: null });
  });

  it('con costo, el GET de referencia lo devuelve para precargar el precio', async () => {
    const { service, prisma } = G.armar({ config: CONFIGS.opcional });
    prisma.productos.findFirst = jest.fn().mockResolvedValue(producto({ precio_costo: 1500 }));
    await expect(service.referenciaProducto(EMP, 'prod-1')).resolves.toEqual({ producto_id: 'prod-1', costo_referencia: '1500.0000' });
  });

  it.each([
    ['sin precio', undefined],
    ['con precio 0', 0],
  ])('15: un ítem libre %s → 400 PRECIO_ESTIMADO_REQUERIDO con la línea', async (_n, precio) => {
    const { service, tx } = W.armar();
    const items = [
      { descripcion: 'Resma', cantidad_solicitada: 1, precio_unitario: 1000 },
      { descripcion: 'Flete', cantidad_solicitada: 1, ...(precio === undefined ? {} : { precio_unitario: precio }) },
    ];
    const e = await W.error(service.create(altaCompra(items as any[]), EMP, USR));
    expect(e.getStatus()).toBe(400);
    expect(W.cuerpo(e)).toMatchObject({ codigo: 'PRECIO_ESTIMADO_REQUERIDO', campo: 'precio_unitario', linea: 2 });
    expect(tx.requisicion_det.createMany).not.toHaveBeenCalled();
  });

  it.each([
    ['sin precio', undefined],
    ['con precio 0', 0],
  ])('15: un ítem de gasto %s → 400 PRECIO_ESTIMADO_REQUERIDO con la línea', async (_n, precio) => {
    const { service, tx } = W.armar();
    tx.tipo_gasto = { findFirst: jest.fn().mockResolvedValue({ id: 'tg-1' }) };
    const items = [
      { tipo_gasto_id: 'tg-1', descripcion: 'Combustible', cantidad_solicitada: 1, precio_unitario: 100_000 },
      { tipo_gasto_id: 'tg-1', descripcion: 'Peaje', cantidad_solicitada: 1, ...(precio === undefined ? {} : { precio_unitario: precio }) },
    ];
    const e = await W.error(service.create(altaCompra(items as any[], { origen_tipo: 'gasto' }), EMP, USR));
    expect(e.getStatus()).toBe(400);
    expect(W.cuerpo(e)).toMatchObject({ codigo: 'PRECIO_ESTIMADO_REQUERIDO', campo: 'precio_unitario', linea: 2 });
    expect(tx.requisicion_det.createMany).not.toHaveBeenCalled();
  });
});

/* ───────────── Fila 17: ejecutado por encima de lo aprobado ───────────── */

describe('fila 17 - ejecutado por encima de lo aprobado', () => {
  it('una ejecución más cara que lo aprobado se aplica igual y el total ejecutado lo supera', async () => {
    const { tx, det, cab } = armarEjecucion();
    // Línea de 10 unidades; lo aprobado era 10 × 100.000 = 1.000.000, se ejecuta a 150.000 la unidad.
    await aplicarEjecucionRequisicion(tx, paramsEjecucion({ items: [{ requisicion_det_id: 'rd-1', cantidad: 10, subtotal: 1_500_000 }] }));
    expect(det[0]).toMatchObject({ cantidad_ejecutada: 10, monto_ejecutado: 1_500_000, estado: 'ejecutada_total' });
    expect(cab).toMatchObject({ estado: 'ejecutada_total', total_ejecutado: 1_500_000 });
  });
  // La marca `ejecutado_sobre_aprobado` del listado y el aprobado contra ejecutado por moneda (USD) los cubre
  // `requisiciones-lecturas.spec.ts` (fila de listado y detalle); acá solo la parte de ejecución.
});

/* ───────────── Fila 18: pendientes antes de la migración ───────────── */

describe('fila 18 - requisición en pendiente_aprobacion antes de la migración', () => {
  // La ejecución real de la migración se verificó con BEGIN/ROLLBACK en la Task 6; acá se anclan sus tres sentencias.
  it('el SQL de la migración 100200 inserta el evento, borra las aprobaciones y pasa a borrador (ejecución real: BEGIN/ROLLBACK de la Task 6)', () => {
    const sql = readFileSync(join(process.cwd(), 'prisma/migrations/20261029100200_requisiciones_pendientes_a_borrador/migration.sql'), 'utf8');
    expect(sql).toMatch(
      /INSERT INTO requisicion_historial \([^)]*accion[^)]*\)\s+SELECT c\.id,\s+'vuelta_a_borrador_precio_estimado',\s+'pendiente_aprobacion',\s+'borrador'[\s\S]*?FROM requisicion_cab c\s+WHERE c\.estado = 'pendiente_aprobacion';/,
    );
    expect(sql).toMatch(
      /DELETE FROM requisicion_aprobacion a\s+USING requisicion_cab c\s+WHERE a\.requisicion_id = c\.id AND c\.estado = 'pendiente_aprobacion';/,
    );
    expect(sql).toMatch(/UPDATE requisicion_cab\s+SET estado = 'borrador'[^;]*WHERE estado = 'pendiente_aprobacion';/);
    // El historial va antes que el borrado: los niveles aprobados quedan en `datos`.
    expect(sql.indexOf('INSERT INTO requisicion_historial')).toBeLessThan(sql.indexOf('DELETE FROM requisicion_aprobacion'));
  });

  it('una vez en borrador (sin aprobaciones), se cargan los precios y se reenvía: actualizada y enviada, con niveles nuevos', async () => {
    const { service, tx } = W.armar({ estado: 'borrador', configs: [W.cfg(1, 0, null)] });
    await service.update(REQ_ID, { updated_at: FECHA, enviar_a_aprobacion: true } as any, EMP, USR);
    expect(W.hist(tx).map((h: any) => h.accion)).toEqual(['actualizada', 'enviada_aprobacion']);
    expect(tx.requisicion_aprobacion.createMany).toHaveBeenCalled();
  });
});

/* ───────────── Perfiles ───────────── */

describe('perfiles - lo que cada uno puede hacer (metadata del controller y los guards)', () => {
  const proto = RequisicionesController.prototype as any;
  const handlers = Object.getOwnPropertyNames(proto).filter((m) => m !== 'constructor' && typeof proto[m] === 'function');

  /** Lo mismo que evalúan `PermissionGuard` y `AlgunPrivilegioGuard` con los privilegios del perfil. */
  const permitidos = (privilegios: string[], p: any = proto, lista: string[] = handlers) =>
    lista.filter((h) => {
      const exacto = Reflect.getMetadata(REQUIRE_PERMISSION_KEY, p[h]);
      const alguno = Reflect.getMetadata(REQUIRE_ALGUN_PRIVILEGIO_KEY, p[h]) as string[] | undefined;
      if (exacto) return privilegios.includes(exacto.privilegio);
      if (alguno) return alguno.some((x) => privilegios.includes(x));
      return false;
    });
  const R = (a: string) => `CMP_REQ_REQUISICION_${a}`;

  it('solo VER: lista, detalle, contexto y niveles; nada que escriba', () => {
    expect(permitidos([R('VER')])).toEqual(['findAll', 'contexto', 'nivelesAplicables', 'findOne']);
  });

  it('CREAR sin EDITAR: crea, envía y consulta la referencia; no edita', () => {
    const p = permitidos([R('VER'), R('CREAR')]);
    expect(p).toEqual(expect.arrayContaining(['create', 'enviarAprobacion', 'referenciaProducto']));
    expect(p).not.toContain('update');
  });

  it('EDITAR sin CREAR: edita pero no crea ni envía (Guardar y enviar pide además CREAR en el servicio)', () => {
    const p = permitidos([R('VER'), R('EDITAR')]);
    expect(p).toContain('update');
    expect(p).not.toContain('create');
    expect(p).not.toContain('enviarAprobacion');
  });

  it('perfil del nivel sin _APROBAR: no llega a aprobar ni a rechazar, y el contexto no le ofrece aprobar', async () => {
    const p = permitidos([R('VER'), R('CREAR'), R('EDITAR')]);
    expect(p).not.toContain('aprobar');
    expect(p).not.toContain('rechazar');
    const { service } = armarLecturas({
      config: CONFIGS.opcional,
      configsNiveles: [{ nivel: 1, perfil_id: W.PERFIL_1, monto_desde: 0 as any, monto_hasta: null, activo: true, perfiles: { id: W.PERFIL_1, perfil: 'J', desc_perfil: null } }],
      perfilesUsuario: [W.PERFIL_1],
      privilegios: [],
    });
    await expect(service.contexto(EMP, USR)).resolves.toMatchObject({ aprueba_algun_nivel: false });
  });

  it('_APROBAR sin el perfil del nivel: pasa el guard y el servicio responde 403 SIN_PERFIL_DEL_NIVEL', async () => {
    expect(permitidos([R('VER'), R('APROBAR')])).toEqual(expect.arrayContaining(['aprobar', 'rechazar']));
    for (const accion of [
      (s: any) => s.aprobar(REQ_ID, EMP, USR, { nivel: 1 }),
      (s: any) => s.rechazar(REQ_ID, EMP, USR, { nivel: 1, motivo: 'x' }),
    ]) {
      const { service, tx } = W.armar({ estado: 'pendiente_aprobacion', aprobaciones: [W.ap(1)], perfilesUsuario: [] });
      const e = await W.error(accion(service));
      expect(e.getStatus()).toBe(403);
      expect(W.cuerpo(e)).toMatchObject({ codigo: 'SIN_PERFIL_DEL_NIVEL' });
      expect(tx.requisicion_cab.update).not.toHaveBeenCalled();
    }
  });

  it('superadmin sin el perfil del nivel: tampoco aprueba (sin excepción)', async () => {
    const { service, tx } = W.armar({ estado: 'pendiente_aprobacion', aprobaciones: [W.ap(1)], perfilesUsuario: [] });
    tx.usuario.findUnique.mockResolvedValue({ is_superadmin: true });
    const e = await W.error(service.aprobar(REQ_ID, EMP, 'usr-super', { nivel: 1 }));
    expect(e.getStatus()).toBe(403);
    expect(tx.requisicion_aprobacion.update).not.toHaveBeenCalled();
    const lecturas = armarLecturas({ config: CONFIGS.opcional, superadmin: true, privilegios: [], perfilesUsuario: [] });
    await expect(lecturas.service.contexto(EMP, 'usr-super')).resolves.toMatchObject({ aprueba_algun_nivel: false });
  });

  it('sin CMP_OC_ORDEN_COMPRA_CREAR: no genera órdenes ni ve las líneas; el resto de la pantalla sigue', () => {
    const todos = [R('VER'), R('CREAR'), R('EDITAR'), R('ELIMINAR'), R('APROBAR')];
    const p = permitidos(todos);
    for (const h of ['lineasParaOc', 'crearOrdenCompra', 'generarOrdenesCompraDistribuidas']) expect(p).not.toContain(h);
    expect(p).toEqual(expect.arrayContaining(['create', 'update', 'aprobar', 'cancelar']));
    const con = permitidos([...todos, 'CMP_OC_ORDEN_COMPRA_CREAR']);
    for (const h of ['lineasParaOc', 'crearOrdenCompra', 'generarOrdenesCompraDistribuidas']) expect(con).toContain(h);
  });

  it('sin Gastos: «Registrar gasto» no precarga (requisiciones-origen pide TES_GAS_GASTO_VER o _CREAR)', () => {
    const gp = GastosController.prototype as any;
    expect(Reflect.getMetadata(REQUIRE_ALGUN_PRIVILEGIO_KEY, gp.requisicionOrigen)).toEqual(['TES_GAS_GASTO_VER', 'TES_GAS_GASTO_CREAR']);
    expect(Reflect.getMetadata(GUARDS_METADATA, gp.requisicionOrigen)).toBeDefined();
    expect(permitidos([R('VER'), R('CREAR')], gp, ['requisicionOrigen'])).toEqual([]);
    expect(permitidos(['TES_GAS_GASTO_VER'], gp, ['requisicionOrigen'])).toEqual(['requisicionOrigen']);
    expect(permitidos(['TES_GAS_GASTO_CREAR'], gp, ['requisicionOrigen'])).toEqual(['requisicionOrigen']);
  });
});

/* ───────────── Ciclos ───────────── */

describe('ciclos', () => {
  it('rechazar → editar → reenviar: cada paso parte del estado que dejó el anterior', async () => {
    const rechazo = W.armar({ estado: 'pendiente_aprobacion', aprobaciones: [W.ap(1)], perfilesUsuario: [W.PERFIL_1] });
    await rechazo.service.rechazar(REQ_ID, EMP, USR, { nivel: 1, motivo: 'Falta el precio' });
    const tras = rechazo.tx.requisicion_cab.update.mock.calls[0][0].data.estado;
    expect(tras).toBe('rechazada');

    const edicion = W.armar({ estado: tras });
    await edicion.service.update(REQ_ID, { updated_at: FECHA } as any, EMP, USR);
    const editada = edicion.tx.requisicion_cab.update.mock.calls[0][0].data;
    expect(editada.estado).toBe('borrador');
    expect(W.hist(edicion.tx).map((h: any) => h.accion)).toEqual(['actualizada']);

    const reenvio = W.armar({ estado: editada.estado, configs: [W.cfg(1, 0, null)] });
    await reenvio.service.enviarAprobacion(REQ_ID, EMP, USR);
    expect(reenvio.tx.requisicion_cab.update.mock.calls[0][0].data).toMatchObject({ estado: 'pendiente_aprobacion', motivo_rechazo: null });
    expect(W.hist(reenvio.tx).map((h: any) => h.accion)).toEqual(['enviada_aprobacion']);
  });

  it('una rechazada se reenvía directo, sin pasar por la edición', async () => {
    const { service, tx } = W.armar({ estado: 'rechazada', configs: [W.cfg(1, 0, null)] });
    await service.enviarAprobacion(REQ_ID, EMP, USR);
    expect(tx.requisicion_cab.update.mock.calls[0][0].data.estado).toBe('pendiente_aprobacion');
  });

  it('cancelar con las OC abiertas → 409 con los números; con las OC canceladas pasa y las líneas vuelven a ofrecerse', async () => {
    const { service, base } = G.armar({ pedidas: [] });
    await service.generarOrdenesCompraDistribuidas(REQ_ID, EMP, G.dtoBase([G.asig(G.DET1, G.PROV_A), G.asig(G.DET2, G.PROV_B)]), USR);
    expect(base.ocs).toHaveLength(2);
    expect((await service.lineasParaOc(REQ_ID, EMP, USR)).lineas.map((l) => l.id)).toEqual([G.DET3]);

    const e = await G.error(service.cancelar(REQ_ID, EMP, USR, { motivo: 'Ya no se necesita' }));
    expect(e.getStatus()).toBe(409);
    expect(G.cuerpo(e)).toMatchObject({ codigo: 'REQUISICION_CON_OC_ABIERTA' });
    expect(G.cuerpo(e).ordenes.map((o: any) => o.numero_orden)).toHaveLength(2);

    // Se cancelan las dos OC (la requisición sigue aprobada: solo escribe `oc_cancelada`, ver el spec de OC).
    for (const oc of base.ocs) oc.estado = 'cancelada';
    expect((await service.lineasParaOc(REQ_ID, EMP, USR)).lineas.map((l) => l.id)).toEqual([G.DET1, G.DET2, G.DET3]);
    await expect(service.cancelar(REQ_ID, EMP, USR, { motivo: 'Ya no se necesita' })).resolves.toBeDefined();
  });
});

/* ───────────── Filas 12 a 14: niveles de aprobación (pantalla de Configuración de Compras) ───────────── */

describe('filas 12 a 14 - niveles: lectura, guardado validado y configuración recomendada', () => {
  const P_OK = '11111111-1111-4111-8111-111111111111';
  const P_SIN = '22222222-2222-4222-8222-222222222222';
  const nivelGuardado = { id: 'n1', origen_tipo: 'compra', nivel: 1, perfil_id: P_OK, monto_desde: '0', monto_hasta: '1000000', activo: true, perfiles: { id: P_OK, perfil: 'JEFE', desc_perfil: 'Jefe' } };

  function montar(opts: { niveles?: any[] } = {}) {
    const niveles = opts.niveles ?? [nivelGuardado];
    const tx: any = {
      requisicion_aprobacion_config: {
        findMany: jest.fn().mockResolvedValue(niveles),
        deleteMany: jest.fn().mockResolvedValue(undefined),
        createMany: jest.fn().mockResolvedValue(undefined),
      },
      perfiles: {
        findMany: jest.fn().mockResolvedValue([
          { id: P_OK, perfil: 'JEFE', desc_perfil: 'Jefe' },
          { id: P_SIN, perfil: 'AUX', desc_perfil: null },
        ]),
        findFirst: jest.fn().mockImplementation(async ({ where }: any) => ({ id: `perfil-${where.desc_perfil ?? where.perfil}` })),
        create: jest.fn(),
      },
      perfiles_privilegios: {
        findMany: jest.fn().mockResolvedValue([
          { perfil_id: P_OK, privilegios: { codigo: 'CMP_REQ_REQUISICION_VER' } },
          { perfil_id: P_OK, privilegios: { codigo: 'CMP_REQ_REQUISICION_APROBAR' } },
          { perfil_id: P_SIN, privilegios: { codigo: 'CMP_REQ_REQUISICION_VER' } },
        ]),
        findFirst: jest.fn().mockResolvedValue(null),
        create: jest.fn().mockResolvedValue(undefined),
      },
      usuario_perfiles: { groupBy: jest.fn().mockResolvedValue([{ perfil_id: P_OK, _count: { _all: 3 } }]) },
      privilegios: {
        findMany: jest.fn().mockResolvedValue([
          { id: 'pr-ver', codigo: 'CMP_REQ_REQUISICION_VER' },
          { id: 'pr-aprobar', codigo: 'CMP_REQ_REQUISICION_APROBAR' },
        ]),
      },
      modulos: { findFirst: jest.fn().mockResolvedValue({ id: 'mod-compras' }) },
    };
    const prisma: any = { $transaction: jest.fn(async (cb: any) => cb(tx)), ...tx };
    const audit = { logEnTransaccion: jest.fn() };
    return { service: new RequisicionesService(prisma, {} as any, audit as any), tx, audit };
  }
  const itemOk = (o: Record<string, unknown> = {}) => ({ origen_tipo: 'compra' as const, nivel: 1, perfil_id: P_OK, monto_desde: 0, monto_hasta: 1_000_000, activo: true, ...o });

  it('fila 12: el GET devuelve niveles, perfiles con puede_aprobar y usuarios, la moneda y la recomendada con ,01', async () => {
    const { service, tx } = montar();
    const r = await service.getAprobacionesConfig('emp-1');
    expect(r.niveles).toHaveLength(1);
    expect(r.perfiles).toEqual([
      { id: P_OK, perfil: 'JEFE', desc_perfil: 'Jefe', puede_aprobar: true, usuarios: 3 },
      { id: P_SIN, perfil: 'AUX', desc_perfil: null, puede_aprobar: false, usuarios: 0 },
    ]);
    expect(r.moneda).toEqual({ codigo: 'PYG' });
    expect(r.recomendada.perfiles.map((p) => p.desc_perfil)).toEqual(['Compras Junior', 'Compras Senior', 'Gerente de Compras', 'Director Financiero']);
    expect(r.recomendada.tramos.map((t) => t.monto_desde)).toEqual([0, 1_000_000.01, 5_000_000.01, 50_000_000.01]);
    expect(r.recomendada.tramos.map((t) => t.monto_hasta)).toEqual([1_000_000, 5_000_000, 50_000_000, null]);
    // Todos los perfiles de la empresa (sin filtrar is_sistema) y los privilegios activos grabados en COMPRAS.
    expect(tx.perfiles.findMany.mock.calls[0][0].where).toEqual({ empresa_id: 'emp-1' });
    expect(tx.perfiles_privilegios.findMany.mock.calls[0][0].where).toMatchObject({
      active: true,
      modulos: { codigo: 'COMPRAS' },
      privilegios: { codigo: { in: ['CMP_REQ_REQUISICION_VER', 'CMP_REQ_REQUISICION_APROBAR'] }, active: true },
    });
  });

  it('fila 13: un PUT inválido no borra los niveles guardados (falla antes del deleteMany) y no audita', async () => {
    const { service, tx, audit } = montar();
    const e: any = await service
      .upsertAprobacionesConfig('emp-1', { items: [itemOk({ monto_desde: 500, monto_hasta: 100 })] }, 'usr-1')
      .catch((x) => x);
    expect(e.getResponse()).toMatchObject({ codigo: 'NIVEL_RANGO_INVALIDO', linea: 1, origen: 'compra' });
    expect(tx.requisicion_aprobacion_config.deleteMany).not.toHaveBeenCalled();
    expect(audit.logEnTransaccion).not.toHaveBeenCalled();
  });

  it('un perfil sin _APROBAR se rechaza con PERFIL_SIN_PERMISO_APROBAR y no se le da permiso', async () => {
    const { service, tx } = montar();
    const e: any = await service.upsertAprobacionesConfig('emp-1', { items: [itemOk({ perfil_id: P_SIN })] }, 'usr-1').catch((x) => x);
    expect(e.getResponse()).toMatchObject({ codigo: 'PERFIL_SIN_PERMISO_APROBAR' });
    expect(tx.perfiles_privilegios.create).not.toHaveBeenCalled();
    expect(tx.requisicion_aprobacion_config.deleteMany).not.toHaveBeenCalled();
  });

  it('un PUT válido no da privilegios a ningún perfil', async () => {
    const { service, tx } = montar();
    await service.upsertAprobacionesConfig('emp-1', { items: [itemOk(), itemOk({ nivel: 2, monto_desde: 1_000_000.01, monto_hasta: null })] }, 'usr-1');
    expect(tx.perfiles_privilegios.create).not.toHaveBeenCalled();
    expect(tx.requisicion_aprobacion_config.deleteMany).toHaveBeenCalledWith({ where: { empresa_id: 'emp-1' } });
    expect(tx.requisicion_aprobacion_config.createMany.mock.calls[0][0].data).toHaveLength(2);
  });

  it("activo: 'si' → 400 por @IsBoolean (ValidationPipe real)", async () => {
    await expect(validarDto(UpsertRequisicionAprobacionConfigDto, { items: [{ origen_tipo: 'compra', nivel: 1, perfil_id: P_OK, activo: 'si' }] })).rejects.toMatchObject({ status: 400 });
    await expect(validarDto(UpsertRequisicionAprobacionConfigDto, { items: [{ origen_tipo: 'compra', nivel: 1, perfil_id: P_OK, activo: false }] })).resolves.toBeDefined();
  });

  it('vaciar sin confirmar_vaciar: NIVELES_VACIOS (como hoy), sin borrar', async () => {
    const { service, tx } = montar();
    const e: any = await service.upsertAprobacionesConfig('emp-1', { items: [] }, 'usr-1').catch((x) => x);
    expect(e.getResponse()).toMatchObject({ codigo: 'NIVELES_VACIOS' });
    expect(tx.requisicion_aprobacion_config.deleteMany).not.toHaveBeenCalled();
  });

  it('fila 14: guardar audita NIVELES_APROBACION_GUARDADOS con los niveles antes y después', async () => {
    const { service, tx, audit } = montar();
    tx.requisicion_aprobacion_config.findMany
      .mockResolvedValueOnce([nivelGuardado]) // antes
      .mockResolvedValueOnce([{ ...nivelGuardado, monto_hasta: '2000000' }]) // después
      .mockResolvedValue([{ ...nivelGuardado, monto_hasta: '2000000' }]);
    await service.upsertAprobacionesConfig('emp-1', { items: [itemOk({ monto_hasta: 2_000_000 })] }, 'usr-1');
    expect(audit.logEnTransaccion).toHaveBeenCalledTimes(1);
    expect(audit.logEnTransaccion.mock.calls[0][1]).toMatchObject({
      empresa_id: 'emp-1',
      user_id: 'usr-1',
      action: 'NIVELES_APROBACION_GUARDADOS',
      entity_type: 'requisicion_aprobacion_config',
      old_value: { niveles: [{ origen_tipo: 'compra', nivel: 1, perfil_id: P_OK, monto_desde: 0, monto_hasta: 1_000_000, activo: true }] },
      new_value: { niveles: [{ origen_tipo: 'compra', nivel: 1, perfil_id: P_OK, monto_desde: 0, monto_hasta: 2_000_000, activo: true }] },
    });
  });

  it('un guardado sin cambios en los niveles no escribe en la auditoría', async () => {
    const { service, audit } = montar();
    await service.upsertAprobacionesConfig('emp-1', { items: [itemOk()] }, 'usr-1');
    expect(audit.logEnTransaccion).not.toHaveBeenCalled();
  });

  it('aplicar la recomendada: tramos con ,01, asegura _VER/_APROBAR, audita CONFIG_RECOMENDADA_APLICADA y devuelve perfiles_aplicados {id, desc_perfil}', async () => {
    const { service, tx, audit } = montar();
    const r = await service.aplicarConfiguracionRecomendada('emp-1', 'usr-1');
    const data = tx.requisicion_aprobacion_config.createMany.mock.calls[0][0].data;
    expect(data).toHaveLength(8);
    const compra = data.filter((d: any) => d.origen_tipo === 'compra');
    expect(compra.map((d: any) => [d.nivel, Number(d.monto_desde), d.monto_hasta == null ? null : Number(d.monto_hasta)])).toEqual([
      [1, 0, 1_000_000],
      [2, 1_000_000.01, 5_000_000],
      [3, 5_000_000.01, 50_000_000],
      [4, 50_000_000.01, null],
    ]);
    expect(tx.perfiles_privilegios.create).toHaveBeenCalledTimes(8);
    expect(r.perfiles_aplicados).toEqual([
      { id: 'perfil-Compras Junior', desc_perfil: 'Compras Junior' },
      { id: 'perfil-Compras Senior', desc_perfil: 'Compras Senior' },
      { id: 'perfil-Gerente de Compras', desc_perfil: 'Gerente de Compras' },
      { id: 'perfil-Director Financiero', desc_perfil: 'Director Financiero' },
    ]);
    expect(audit.logEnTransaccion).toHaveBeenCalledTimes(1);
    expect(audit.logEnTransaccion.mock.calls[0][1]).toMatchObject({ action: 'CONFIG_RECOMENDADA_APLICADA', entity_type: 'requisicion_aprobacion_config', user_id: 'usr-1' });
  });
});
