import { ValidationPipe } from '@nestjs/common';
import { alcanceSucursalUsuario } from 'src/utils/alcance-sucursal';
import { AprobarRequisicionDto, CancelarRequisicionDto, RechazarRequisicionDto } from './dto/requisicion-config.dto';
import { CreateRequisicionDto } from './dto/create-requisicion.dto';
import { RequisicionesService } from './requisiciones.service';
import { ap, armar, cfg, cuerpo, error, hist, PERFIL_1, PERFIL_2, SUC } from './requisiciones-workflow.fixture';
import { privilegiosContratados } from 'src/seguridad/privilegios-contratados';

// 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(),
}));

const alcanceMock = alcanceSucursalUsuario as jest.Mock;



beforeEach(() => {
  alcanceMock.mockReset();
  alcanceMock.mockResolvedValue(null);
});

describe('Requisiciones - enviar', () => {
  it('sin niveles → SIN_NIVELES_APROBACION (400) con el origen; no se crea nada (matriz 2)', async () => {
    const { service, tx } = armar({ configs: [] });
    const e = await error(service.enviarAprobacion('req-1', 'emp-1', 'usr-1'));
    expect(e.getStatus()).toBe(400);
    expect(cuerpo(e)).toMatchObject({ codigo: 'SIN_NIVELES_APROBACION', origen: 'compra' });
    expect(tx.requisicion_aprobacion.createMany).not.toHaveBeenCalled();
    expect(tx.requisicion_cab.update).not.toHaveBeenCalled();
  });

  it('un ítem libre de compra va por total_para_aprobacion, no al nivel 1 (R4, matriz 3)', async () => {
    const { service, tx } = armar({
      total: 3_000_000,
      det: [{ id: 'd1', producto_id: null }],
      configs: [cfg(1, 0, 1_000_000), cfg(2, 1_000_000.01, null)],
    });
    await service.enviarAprobacion('req-1', 'emp-1', 'usr-1');
    const filas = tx.requisicion_aprobacion.createMany.mock.calls[0][0].data;
    expect(filas.map((f: any) => f.nivel)).toEqual([2]);
  });

  it('con niveles superpuestos crea dos niveles (matriz 4)', async () => {
    const { service, tx } = armar({ total: 6_000_000, configs: [cfg(1, 0, null), cfg(2, 5_000_000, null)] });
    await service.enviarAprobacion('req-1', 'emp-1', 'usr-1');
    const filas = tx.requisicion_aprobacion.createMany.mock.calls[0][0].data;
    expect(filas.map((f: any) => [f.nivel, f.estado])).toEqual([
      [1, 'pendiente'],
      [2, 'pendiente'],
    ]);
    expect(tx.requisicion_cab.update).toHaveBeenCalledWith(
      expect.objectContaining({ data: expect.objectContaining({ estado: 'pendiente_aprobacion', motivo_rechazo: null }) }),
    );
  });

  it('un estado que no es borrador ni rechazada → 409 REQUISICION_ESTADO_CAMBIADO', async () => {
    const { service } = armar({ estado: 'aprobada', configs: [cfg(1, 0, null)] });
    const e = await error(service.enviarAprobacion('req-1', 'emp-1', 'usr-1'));
    expect(e.getStatus()).toBe(409);
    expect(cuerpo(e)).toMatchObject({ codigo: 'REQUISICION_ESTADO_CAMBIADO', estado_actual: 'aprobada' });
  });
});

describe('Requisiciones - aprobar', () => {
  const pendientes2 = () => [ap(1), ap(2)];

  it('aprobar el 1 deja pendiente el 2 (aprobada_nivel)', async () => {
    const { service, tx } = armar({ estado: 'pendiente_aprobacion', aprobaciones: pendientes2(), perfilesUsuario: [PERFIL_1] });
    await service.aprobar('req-1', 'emp-1', 'usr-1', { nivel: 1 });
    expect(tx.requisicion_aprobacion.update).toHaveBeenCalledWith(
      expect.objectContaining({ where: { id: 'ap-1' }, data: expect.objectContaining({ estado: 'aprobada', aprobado_por: 'usr-1' }) }),
    );
    expect(tx.requisicion_cab.update).not.toHaveBeenCalled();
    expect(hist(tx).map((h: any) => h.accion)).toEqual(['aprobada_nivel']);
  });

  it('aprobar el 2 aprueba la requisición con aprobador_final', async () => {
    const { service, tx } = armar({
      estado: 'pendiente_aprobacion',
      aprobaciones: [ap(1, 'aprobada'), ap(2)],
      perfilesUsuario: [PERFIL_2],
    });
    await service.aprobar('req-1', 'emp-1', 'usr-2', { nivel: 2 });
    expect(tx.requisicion_cab.update).toHaveBeenCalledWith(
      expect.objectContaining({ data: expect.objectContaining({ estado: 'aprobada', aprobador_final_id: 'usr-2' }) }),
    );
    expect(hist(tx).map((h: any) => h.accion)).toEqual(['aprobada']);
  });

  it('sin el perfil del nivel → 403 SIN_PERFIL_DEL_NIVEL con el nivel (matriz 3)', async () => {
    const { service, tx } = armar({ estado: 'pendiente_aprobacion', aprobaciones: pendientes2(), perfilesUsuario: [PERFIL_2] });
    const e = await error(service.aprobar('req-1', 'emp-1', 'usr-1', { nivel: 1 }));
    expect(e.getStatus()).toBe(403);
    expect(cuerpo(e)).toMatchObject({ codigo: 'SIN_PERFIL_DEL_NIVEL', nivel: 1 });
    expect(tx.requisicion_aprobacion.update).not.toHaveBeenCalled();
  });

  it('un superadmin sin el perfil tampoco aprueba: 403', async () => {
    const { service, tx } = armar({ estado: 'pendiente_aprobacion', aprobaciones: pendientes2(), perfilesUsuario: [] });
    tx.usuario.findUnique.mockResolvedValue({ is_superadmin: true });
    tx.usuario.findFirst = jest.fn().mockResolvedValue({ is_superadmin: true });
    const e = await error(service.aprobar('req-1', 'emp-1', 'usr-super', { nivel: 1 }));
    expect(e.getStatus()).toBe(403);
    expect(cuerpo(e)).toMatchObject({ codigo: 'SIN_PERFIL_DEL_NIVEL' });
  });

  it('dos aprobaciones: la segunda relee bajo req: y recibe REQUISICION_ESTADO_CAMBIADO', async () => {
    const { service, tx, orden } = armar({ estado: 'aprobada', aprobaciones: [ap(1, 'aprobada')], perfilesUsuario: [PERFIL_1] });
    const e = await error(service.aprobar('req-1', 'emp-1', 'usr-1', { nivel: 1 }));
    expect(e.getStatus()).toBe(409);
    expect(cuerpo(e)).toMatchObject({ codigo: 'REQUISICION_ESTADO_CAMBIADO', estado_actual: 'aprobada' });
    expect(orden.indexOf('lock:req:req-1')).toBeGreaterThanOrEqual(0);
    expect(orden.indexOf('lock:req:req-1')).toBeLessThan(orden.indexOf('relectura'));
    expect(tx.requisicion_aprobacion.update).not.toHaveBeenCalled();
  });

  it('F7(a): si el nivel pendiente es otro que el que vio el usuario → 409 REQUISICION_ESTADO_CAMBIADO', async () => {
    // Quien tiene los dos perfiles vio el nivel 1, pero otro lo aprobó y ahora el pendiente es el 2.
    const { service, tx } = armar({
      estado: 'pendiente_aprobacion',
      aprobaciones: [ap(1, 'aprobada'), ap(2)],
      perfilesUsuario: [PERFIL_1, PERFIL_2],
    });
    const e = await error(service.aprobar('req-1', 'emp-1', 'usr-1', { nivel: 1 }));
    expect(e.getStatus()).toBe(409);
    expect(cuerpo(e)).toMatchObject({ codigo: 'REQUISICION_ESTADO_CAMBIADO', estado_actual: 'pendiente_aprobacion', nivel_pendiente: 2 });
    expect(tx.requisicion_aprobacion.update).not.toHaveBeenCalled();
  });

  it('F7(a): rechazar con otro nivel pendiente → 409 REQUISICION_ESTADO_CAMBIADO', async () => {
    const { service, tx } = armar({
      estado: 'pendiente_aprobacion',
      aprobaciones: [ap(1, 'aprobada'), ap(2)],
      perfilesUsuario: [PERFIL_1, PERFIL_2],
    });
    const e = await error(service.rechazar('req-1', 'emp-1', 'usr-1', { nivel: 1, motivo: 'caro' }));
    expect(e.getStatus()).toBe(409);
    expect(cuerpo(e)).toMatchObject({ codigo: 'REQUISICION_ESTADO_CAMBIADO', estado_actual: 'pendiente_aprobacion', nivel_pendiente: 2 });
    expect(tx.requisicion_aprobacion.updateMany).not.toHaveBeenCalled();
  });

  it('aprobar sin comentario guarda null (en el nivel y en el historial)', async () => {
    const { service, tx } = armar({ estado: 'pendiente_aprobacion', aprobaciones: [ap(1)], perfilesUsuario: [PERFIL_1] });
    await service.aprobar('req-1', 'emp-1', 'usr-1', { nivel: 1 });
    expect(tx.requisicion_aprobacion.update.mock.calls[0][0].data.comentario).toBeNull();
    expect(hist(tx)[0].comentario).toBeNull();
  });

  it('aprobar con comentario con espacios guarda el texto limpio', async () => {
    const { service, tx } = armar({ estado: 'pendiente_aprobacion', aprobaciones: [ap(1)], perfilesUsuario: [PERFIL_1] });
    await service.aprobar('req-1', 'emp-1', 'usr-1', { nivel: 1, comentario: '  ok  ' });
    expect(tx.requisicion_aprobacion.update.mock.calls[0][0].data.comentario).toBe('ok');
    expect(hist(tx)[0].comentario).toBe('ok');
  });
});

describe('Requisiciones - rechazar y cancelar', () => {
  it('rechazar en el 2 cierra todos los pendientes con el motivo y lo graba en motivo_rechazo', async () => {
    const { service, tx } = armar({
      estado: 'pendiente_aprobacion',
      aprobaciones: [ap(1, 'aprobada'), ap(2)],
      perfilesUsuario: [PERFIL_2],
    });
    await service.rechazar('req-1', 'emp-1', 'usr-2', { nivel: 2, motivo: '  Falta presupuesto ' });
    expect(tx.requisicion_aprobacion.updateMany).toHaveBeenCalledWith(
      expect.objectContaining({
        where: { requisicion_id: 'req-1', estado: 'pendiente' },
        data: expect.objectContaining({ estado: 'rechazada', comentario: 'Falta presupuesto', aprobado_por: 'usr-2' }),
      }),
    );
    expect(tx.requisicion_cab.update).toHaveBeenCalledWith(
      expect.objectContaining({ data: expect.objectContaining({ estado: 'rechazada', motivo_rechazo: 'Falta presupuesto' }) }),
    );
    expect(hist(tx)[0]).toMatchObject({ accion: 'rechazada', comentario: 'Falta presupuesto' });
  });

  it('rechazar sin el perfil del nivel → 403 SIN_PERFIL_DEL_NIVEL', async () => {
    const { service } = armar({ estado: 'pendiente_aprobacion', aprobaciones: [ap(1)], perfilesUsuario: [] });
    const e = await error(service.rechazar('req-1', 'emp-1', 'usr-1', { nivel: 1, motivo: 'no' }));
    expect(e.getStatus()).toBe(403);
    expect(cuerpo(e)).toMatchObject({ codigo: 'SIN_PERFIL_DEL_NIVEL', nivel: 1 });
  });

  it('rechazar sin perfil y sin motivo da 403: el perfil se chequea antes que el motivo', async () => {
    const { service } = armar({ estado: 'pendiente_aprobacion', aprobaciones: [ap(1)], perfilesUsuario: [] });
    const e = await error(service.rechazar('req-1', 'emp-1', 'usr-1', { nivel: 1, motivo: '  ' }));
    expect(e.getStatus()).toBe(403);
    expect(cuerpo(e)).toMatchObject({ codigo: 'SIN_PERFIL_DEL_NIVEL' });
  });

  it.each([
    ['rechazar', undefined],
    ['rechazar', ''],
    ['rechazar', '   '],
    ['cancelar', undefined],
    ['cancelar', ''],
    ['cancelar', ' \t '],
  ])('%s con el motivo %j → MOTIVO_REQUERIDO (R16)', async (accion, motivo) => {
    const { service, tx } = armar({ estado: 'pendiente_aprobacion', aprobaciones: [ap(1)], perfilesUsuario: [PERFIL_1] });
    const p =
      accion === 'rechazar'
        ? service.rechazar('req-1', 'emp-1', 'usr-1', { nivel: 1, motivo })
        : service.cancelar('req-1', 'emp-1', 'usr-1', { motivo });
    const e = await error(p);
    expect(e.getStatus()).toBe(400);
    expect(cuerpo(e)).toMatchObject({ codigo: 'MOTIVO_REQUERIDO', campo: 'motivo' });
    expect(tx.requisicion_cab.update).not.toHaveBeenCalled();
  });

  it('un motivo de más de 500 caracteres → MOTIVO_REQUERIDO tampoco pasa', async () => {
    const { service } = armar({ estado: 'aprobada' });
    const e = await error(service.cancelar('req-1', 'emp-1', 'usr-1', { motivo: 'x'.repeat(501) }));
    expect(e.getStatus()).toBe(400);
    expect(cuerpo(e)).toMatchObject({ codigo: 'MOTIVO_REQUERIDO' });
  });

  it('cancelar cierra los niveles pendientes con el motivo de la cancelación', async () => {
    const { service, tx } = armar({ estado: 'pendiente_aprobacion', aprobaciones: [ap(1), ap(2)] });
    await service.cancelar('req-1', 'emp-1', 'usr-1', { motivo: ' Ya no se necesita ' });
    expect(tx.requisicion_aprobacion.updateMany).toHaveBeenCalledWith(
      expect.objectContaining({
        where: { requisicion_id: 'req-1', estado: 'pendiente' },
        data: expect.objectContaining({ estado: 'rechazada', comentario: 'Ya no se necesita' }),
      }),
    );
    expect(tx.requisicion_cab.update).toHaveBeenCalledWith(
      expect.objectContaining({ data: expect.objectContaining({ estado: 'cancelada', motivo_cancelacion: 'Ya no se necesita' }) }),
    );
    expect(hist(tx)[0]).toMatchObject({ accion: 'cancelada', comentario: 'Ya no se necesita', estado_anterior: 'pendiente_aprobacion' });
  });

  it('cancelar con una OC abierta → 409 REQUISICION_CON_OC_ABIERTA con los números (R12)', async () => {
    const ordenes = [{ id: 'oc-1', numero_orden: 'OC-0007' }];
    const { service, tx } = armar({ estado: 'aprobada', ordenes });
    const e = await error(service.cancelar('req-1', 'emp-1', 'usr-1', { motivo: 'cambio de planes' }));
    expect(e.getStatus()).toBe(409);
    expect(cuerpo(e)).toMatchObject({ codigo: 'REQUISICION_CON_OC_ABIERTA', ordenes });
    expect(tx.requisicion_cab.update).not.toHaveBeenCalled();
  });

  it('cancelar con la OC cancelada (o dada de baja) pasa: solo cuentan las OC activas no canceladas ni completadas', async () => {
    const { service, tx } = armar({ estado: 'aprobada', ordenes: [] });
    await service.cancelar('req-1', 'emp-1', 'usr-1', { motivo: 'cambio de planes' });
    expect(tx.orden_compra_cab.findMany.mock.calls[0][0].where).toEqual({
      requisicion_id: 'req-1',
      empresa_id: 'emp-1',
      activo: { not: false },
      OR: [{ estado: null }, { estado: { notIn: ['cancelada', 'completada'] } }],
    });
    expect(tx.requisicion_cab.update).toHaveBeenCalled();
  });

  it('cancelar con una OC abierta devuelta por la consulta da 409 y no cancela', async () => {
    const { service, tx } = armar({ estado: 'aprobada', ordenes: [{ id: 'oc-9', numero_orden: 'OC-0009' }] });
    const e = await error(service.cancelar('req-1', 'emp-1', 'usr-1', { motivo: 'x' }));
    expect(e.getStatus()).toBe(409);
    expect(cuerpo(e)).toMatchObject({ codigo: 'REQUISICION_CON_OC_ABIERTA', ordenes: [{ id: 'oc-9', numero_orden: 'OC-0009' }] });
    expect(tx.requisicion_cab.update).not.toHaveBeenCalled();
  });

  it.each(['cancelada', 'ejecutada_total'])('cancelar una requisición %s → 409 REQUISICION_ESTADO_CAMBIADO', async (estado) => {
    const { service } = armar({ estado });
    const e = await error(service.cancelar('req-1', 'emp-1', 'usr-1', { motivo: 'x' }));
    expect(e.getStatus()).toBe(409);
    expect(cuerpo(e)).toMatchObject({ codigo: 'REQUISICION_ESTADO_CAMBIADO', estado_actual: estado });
  });
});

describe('Requisiciones - historial sin literales inventados (F5)', () => {
  const correr: Record<string, (s: RequisicionesService) => Promise<unknown>> = {
    enviada_aprobacion: (s) => s.enviarAprobacion('req-1', 'emp-1', 'usr-1'),
    aprobada_nivel: (s) => s.aprobar('req-1', 'emp-1', 'usr-1', { nivel: 1 }),
    aprobada: (s) => s.aprobar('req-1', 'emp-1', 'usr-1', { nivel: 1 }),
  };
  const montar = (accion: string) =>
    accion === 'enviada_aprobacion'
      ? armar({ configs: [cfg(1, 0, null)] })
      : accion === 'aprobada_nivel'
        ? armar({ estado: 'pendiente_aprobacion', aprobaciones: [ap(1), ap(2)], perfilesUsuario: [PERFIL_1] })
        : armar({ estado: 'pendiente_aprobacion', aprobaciones: [ap(1)], perfilesUsuario: [PERFIL_1] });

  it.each(Object.keys(correr))('%s: el comentario es null si el usuario no escribió nada', async (accion) => {
    const { service, tx } = montar(accion);
    await correr[accion](service);
    const h = hist(tx).find((x: any) => x.accion === accion);
    expect(h).toBeDefined();
    expect(h.comentario).toBeNull();
  });

  it('ningún literal «Rechazada» ni «Requisición cancelada» en comentario ni motivo', async () => {
    const r = armar({ estado: 'pendiente_aprobacion', aprobaciones: [ap(1)], perfilesUsuario: [PERFIL_1] });
    await r.service.rechazar('req-1', 'emp-1', 'usr-1', { nivel: 1, motivo: 'Precio alto' });
    const c = armar({ estado: 'aprobada' });
    await c.service.cancelar('req-1', 'emp-1', 'usr-1', { motivo: 'Duplicada' });
    const todo = JSON.stringify([
      r.tx.requisicion_aprobacion.updateMany.mock.calls,
      r.tx.requisicion_cab.update.mock.calls,
      hist(r.tx),
      c.tx.requisicion_aprobacion.updateMany.mock.calls,
      c.tx.requisicion_cab.update.mock.calls,
      hist(c.tx),
    ]);
    expect(todo).not.toMatch(/"Rechazada"|Rechazada en aprobación|Requisición cancelada|"Cancelada"/);
  });
});

describe('Requisiciones - alcance por sucursal en las acciones (F6)', () => {
  const acciones: Array<[string, (s: RequisicionesService) => Promise<unknown>]> = [
    ['enviar', (s) => s.enviarAprobacion('req-1', 'emp-1', 'usr-1')],
    ['aprobar', (s) => s.aprobar('req-1', 'emp-1', 'usr-1', { nivel: 1 })],
    ['rechazar', (s) => s.rechazar('req-1', 'emp-1', 'usr-1', { nivel: 1, motivo: 'x' })],
    ['cancelar', (s) => s.cancelar('req-1', 'emp-1', 'usr-1', { motivo: 'x' })],
  ];

  it.each(acciones)('%s: una requisición de otra sucursal da 404', async (_n, accion) => {
    const { service, tx } = armar({ estado: 'inexistente' });
    alcanceMock.mockResolvedValue({ sucursalIds: ['otra'], puntosEstablecimiento: [], depositoIds: [] });
    const e = await error(accion(service));
    expect(e.getStatus()).toBe(404);
    expect(tx.requisicion_cab.findFirst.mock.calls[0][0].where).toMatchObject({ sucursal_id: expect.anything() });
    expect(tx.requisicion_cab.update).not.toHaveBeenCalled();
  });

  it.each(acciones)('%s: toma req: antes de releer', async (_n, accion) => {
    const { service, orden } = armar({ estado: 'inexistente' });
    await error(accion(service));
    expect(orden[0]).toBe('lock:req:req-1');
    expect(orden[1]).toBe('relectura');
  });
});

describe('Requisiciones - guardar y enviar', () => {
  const dtoCreate = (extra: Record<string, unknown> = {}): any => ({
    cabecera: { origen_tipo: 'compra', sucursal_id: SUC },
    items: [{ descripcion: 'Resma', cantidad_solicitada: 1, precio_unitario: 1000 }],
    ...extra,
  });

  it('en la misma tx: si no hay niveles no queda nada creado (el error sale de la única transacción)', async () => {
    const { service, prisma, tx } = armar({ configs: [] });
    const e = await error(service.create(dtoCreate({ enviar_a_aprobacion: true }), 'emp-1', 'usr-1'));
    expect(cuerpo(e)).toMatchObject({ codigo: 'SIN_NIVELES_APROBACION', origen: 'compra' });
    expect(prisma.$transaction).toHaveBeenCalledTimes(1);
    expect(tx.requisicion_cab.create).toHaveBeenCalled(); // se creó dentro de la tx que se revierte por el error
    expect(tx.requisicion_aprobacion.createMany).not.toHaveBeenCalled();
  });

  it('create con enviar_a_aprobacion y niveles deja pendiente_aprobacion con historial creada y enviada', async () => {
    const { service, tx } = armar({ configs: [cfg(1, 0, null)] });
    await service.create(dtoCreate({ enviar_a_aprobacion: true }), 'emp-1', 'usr-1');
    expect(hist(tx).map((h: any) => h.accion)).toEqual(['creada', 'enviada_aprobacion']);
    expect(tx.requisicion_aprobacion.createMany).toHaveBeenCalled();
  });

  it('create sin la bandera no resuelve niveles', async () => {
    const { service, tx } = armar({ configs: [cfg(1, 0, null)] });
    await service.create(dtoCreate(), 'emp-1', 'usr-1');
    expect(tx.requisicion_aprobacion_config.findMany).not.toHaveBeenCalled();
  });

  it('editar y enviar sin _CREAR → 403 y no se guarda nada', async () => {
    const { service, tx } = armar({ tieneCrear: false, configs: [cfg(1, 0, null)] });
    const e = await error(
      service.update('req-1', { updated_at: '2026-10-05T12:00:00.000Z', enviar_a_aprobacion: true } as any, 'emp-1', 'usr-1'),
    );
    expect(e.getStatus()).toBe(403);
    expect(cuerpo(e)).toMatchObject({ codigo: 'SIN_PERMISO_ENVIAR' });
    expect(tx.requisicion_cab.update).not.toHaveBeenCalled();
    expect(tx.requisicion_aprobacion.createMany).not.toHaveBeenCalled();
  });

  it('editar y enviar sin _CREAR una requisición de otra sucursal da 404, no 403', async () => {
    const { service } = armar({ estado: 'inexistente', tieneCrear: false });
    alcanceMock.mockResolvedValue({ sucursalIds: ['otra'], puntosEstablecimiento: [], depositoIds: [] });
    const e = await error(
      service.update('req-1', { updated_at: '2026-10-05T12:00:00.000Z', enviar_a_aprobacion: true } as any, 'emp-1', 'usr-1'),
    );
    expect(e.getStatus()).toBe(404);
  });

  it('editar y enviar con _CREAR guarda y envía en la misma tx', async () => {
    const { service, tx, prisma } = armar({ configs: [cfg(1, 0, null)] });
    await service.update('req-1', { updated_at: '2026-10-05T12:00:00.000Z', enviar_a_aprobacion: true } as any, 'emp-1', 'usr-1');
    expect(prisma.$transaction).toHaveBeenCalledTimes(1);
    expect(hist(tx).map((h: any) => h.accion)).toEqual(['actualizada', 'enviada_aprobacion']);
  });
});

describe('DTO de acciones con el ValidationPipe real (F1, F7)', () => {
  const pipe = new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true, transform: true });
  const pasar = (body: unknown, metatype: any) => pipe.transform(body, { type: 'body', metatype });

  it.each(['', '   '])('rechazar y cancelar con el motivo %j llegan al servicio, que responde MOTIVO_REQUERIDO', async (motivo) => {
    const r: any = await pasar({ nivel: 1, motivo }, RechazarRequisicionDto);
    const c: any = await pasar({ motivo }, CancelarRequisicionDto);
    const { service } = armar({ estado: 'pendiente_aprobacion', aprobaciones: [ap(1)], perfilesUsuario: [PERFIL_1] });
    expect(cuerpo(await error(service.rechazar('req-1', 'emp-1', 'usr-1', r)))).toMatchObject({ codigo: 'MOTIVO_REQUERIDO' });
    expect(cuerpo(await error(service.cancelar('req-1', 'emp-1', 'usr-1', c)))).toMatchObject({ codigo: 'MOTIVO_REQUERIDO' });
  });

  it('rechazar sin motivo pasa el pipe', async () => {
    await expect(pasar({ nivel: 1 }, RechazarRequisicionDto)).resolves.toBeDefined();
    await expect(pasar({}, CancelarRequisicionDto)).resolves.toBeDefined();
  });

  it('aprobar y rechazar exigen nivel entero; el comentario tiene tope de 500', async () => {
    await expect(pasar({}, AprobarRequisicionDto)).rejects.toThrow();
    await expect(pasar({ nivel: 'uno' }, AprobarRequisicionDto)).rejects.toThrow();
    await expect(pasar({ motivo: 'x' }, RechazarRequisicionDto)).rejects.toThrow();
    await expect(pasar({ nivel: 1, comentario: 'x'.repeat(501) }, AprobarRequisicionDto)).rejects.toThrow();
    await expect(pasar({ nivel: 1, comentario: 'x'.repeat(500) }, AprobarRequisicionDto)).resolves.toBeDefined();
  });

  it('el alta y la edición aceptan enviar_a_aprobacion booleano', async () => {
    const base = { cabecera: { origen_tipo: 'compra', sucursal_id: SUC }, items: [{ descripcion: 'x', cantidad_solicitada: 1, precio_unitario: 1 }] };
    await expect(pasar({ ...base, enviar_a_aprobacion: true }, CreateRequisicionDto)).resolves.toBeDefined();
    await expect(pasar({ ...base, enviar_a_aprobacion: 'si' }, CreateRequisicionDto)).rejects.toThrow();
  });
});

describe('Requisiciones - niveles y perfiles recomendados (T11)', () => {
  function armarConfig(niveles: number) {
    const tx: any = {
      perfiles: {
        findFirst: jest.fn().mockImplementation(async ({ where }: any) => ({ id: `perfil-${where.desc_perfil ?? where.perfil}`, empresa_id: 'emp-1' })),
        create: jest.fn(),
        findMany: jest.fn().mockResolvedValue([]),
      },
      usuario_perfiles: { groupBy: jest.fn().mockResolvedValue([]) },
      requisicion_aprobacion_config: {
        deleteMany: jest.fn().mockResolvedValue(undefined),
        createMany: jest.fn().mockResolvedValue(undefined),
        findMany: jest.fn().mockResolvedValue(
          Array.from({ length: niveles }, (_, i) => ({ origen_tipo: 'compra', nivel: i + 1, perfil_id: 'p', monto_desde: 0, monto_hasta: null, activo: true })),
        ),
      },
      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' }) },
      perfiles_privilegios: {
        findFirst: jest.fn().mockResolvedValue(null),
        findMany: jest.fn().mockResolvedValue([]),
        create: jest.fn().mockResolvedValue(undefined),
      },
    };
    const prisma: any = { $transaction: jest.fn().mockImplementation(async (cb: any) => cb(tx)), ...tx };
    return { service: new RequisicionesService(prisma, {} as any, { logEnTransaccion: jest.fn() } as any), tx };
  }

  it('PUT de niveles vacío con niveles → NIVELES_VACIOS (400) y no borra nada', async () => {
    const { service, tx } = armarConfig(3);
    const e = await error(service.upsertAprobacionesConfig('emp-1', { items: [] }, 'usr-1'));
    expect(e.getStatus()).toBe(400);
    expect(cuerpo(e)).toMatchObject({ codigo: 'NIVELES_VACIOS' });
    expect(tx.requisicion_aprobacion_config.deleteMany).not.toHaveBeenCalled();
  });

  it('con confirmar_vaciar pasa y borra', async () => {
    const { service, tx } = armarConfig(3);
    await service.upsertAprobacionesConfig('emp-1', { items: [], confirmar_vaciar: true }, 'usr-1');
    expect(tx.requisicion_aprobacion_config.deleteMany).toHaveBeenCalledWith({ where: { empresa_id: 'emp-1' } });
  });

  it('vacío sin niveles previos pasa sin confirmar (no hay nada que perder)', async () => {
    const { service, tx } = armarConfig(0);
    await service.upsertAprobacionesConfig('emp-1', { items: [] }, 'usr-1');
    expect(tx.requisicion_aprobacion_config.deleteMany).toHaveBeenCalled();
  });

  it('el DTO acepta confirmar_vaciar booleano y rechaza otro tipo', async () => {
    const pipe = new ValidationPipe({ transform: true, whitelist: true, forbidNonWhitelisted: true });
    const { UpsertRequisicionAprobacionConfigDto } = await import('./dto/requisicion-config.dto');
    const meta = { type: 'body' as const, metatype: UpsertRequisicionAprobacionConfigDto };
    await expect(pipe.transform({ items: [], confirmar_vaciar: true }, meta)).resolves.toMatchObject({ confirmar_vaciar: true });
    await expect(pipe.transform({ items: [], confirmar_vaciar: 'si' }, meta)).rejects.toBeDefined();
  });

  it('aplicar recomendada crea los perfiles con VER y APROBAR (en COMPRAS, sin duplicar)', async () => {
    const { service, tx } = armarConfig(0);
    tx.perfiles.findFirst.mockResolvedValue(null);
    tx.perfiles.create.mockImplementation(async ({ data }: any) => ({ id: `nuevo-${data.perfil}` }));
    await service.aplicarConfiguracionRecomendada('emp-1', 'usr-1');
    expect(tx.perfiles.create).toHaveBeenCalledTimes(4);
    const filas = tx.perfiles_privilegios.create.mock.calls.map((c: any[]) => c[0].data);
    expect(filas).toHaveLength(8);
    for (const perfil of ['Compras Jr', 'Compras Sr', 'Gte Compras', 'Dir Financiero']) {
      for (const priv of ['pr-ver', 'pr-aprobar']) {
        expect(filas).toContainEqual({ perfil_id: `nuevo-${perfil}`, privilegio_id: priv, modulo_id: 'mod-compras', active: true });
      }
    }
  });

  it.each([
    ['falta el módulo COMPRAS', 'MODULO_COMPRAS_INEXISTENTE', (tx: any) => tx.modulos.findFirst.mockResolvedValue(null)],
    [
      'falta un privilegio de Requisiciones',
      'PRIVILEGIOS_REQUISICION_INEXISTENTES',
      (tx: any) => tx.privilegios.findMany.mockResolvedValue([{ id: 'pr-ver', codigo: 'CMP_REQ_REQUISICION_VER' }]),
    ],
  ])('aplicar recomendada: %s → error con código, sin dejar niveles ni permisos a medias', async (_t, codigo, preparar) => {
    const { service, tx } = armarConfig(0);
    preparar(tx);
    const e = await error(service.aplicarConfiguracionRecomendada('emp-1', 'usr-1'));
    expect(e.getStatus()).toBe(500);
    expect(cuerpo(e)).toMatchObject({ codigo });
    expect(tx.perfiles_privilegios.create).not.toHaveBeenCalled();
    expect(tx.requisicion_aprobacion_config.createMany).not.toHaveBeenCalled();
  });

  it('aplicar recomendada solo asigna los privilegios contratados por la empresa (mismo filtro que el árbol)', async () => {
    const { service, tx } = armarConfig(0);
    tx.perfiles.findFirst.mockResolvedValue(null);
    tx.perfiles.create.mockImplementation(async ({ data }: any) => ({ id: `nuevo-${data.perfil}` }));
    (privilegiosContratados as jest.Mock).mockResolvedValueOnce(new Set(['pr-ver']));
    await service.aplicarConfiguracionRecomendada('emp-1', 'usr-1');
    expect(privilegiosContratados).toHaveBeenCalledWith(tx, 'emp-1');
    const ids = tx.perfiles_privilegios.create.mock.calls.map((c: any[]) => c[0].data.privilegio_id);
    expect(ids).toHaveLength(4);
    expect(new Set(ids)).toEqual(new Set(['pr-ver']));
  });

  it('aplicar recomendada sin COMPRAS contratado no asigna permisos', async () => {
    const { service, tx } = armarConfig(0);
    (privilegiosContratados as jest.Mock).mockResolvedValueOnce(new Set());
    await service.aplicarConfiguracionRecomendada('emp-1', 'usr-1');
    expect(tx.perfiles_privilegios.create).not.toHaveBeenCalled();
  });

  it('aplicar recomendada no duplica lo que el perfil ya tiene', async () => {
    const { service, tx } = armarConfig(0);
    tx.perfiles_privilegios.findFirst.mockResolvedValue({ id: 'ya' });
    await service.aplicarConfiguracionRecomendada('emp-1', 'usr-1');
    expect(tx.perfiles_privilegios.create).not.toHaveBeenCalled();
  });
});
