import { NotFoundException } from '@nestjs/common';
import { Prisma } from '@prisma/client';
import { submoduloHabilitado } from 'src/auth/guards/submodulo.guard';
import { alcanceSucursalUsuario } from 'src/utils/alcance-sucursal';
import { RequisicionesService } from './requisiciones.service';
import { armar, Opts } from './requisiciones-lecturas.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;

const D = (v: string | number) => new Prisma.Decimal(v);

const EMP = 'emp-1';
const USR = 'usr-1';
const SUC_1 = 'aaaaaaaa-0000-4000-8000-000000000001';
const SUC_2 = 'aaaaaaaa-0000-4000-8000-000000000002';
const PERFIL_1 = 'bbbbbbbb-0000-4000-8000-000000000001';
const PERFIL_2 = 'bbbbbbbb-0000-4000-8000-000000000002';
const PERFIL_3 = 'bbbbbbbb-0000-4000-8000-000000000003';
const APROBAR = 'CMP_REQ_REQUISICION_APROBAR';
const VER_CONFIG = 'ADM_CCFG_CONFIG_VER';

async function error(p: Promise<unknown>): Promise<any> {
  try {
    await p;
  } catch (e) {
    return e;
  }
  throw new Error('Se esperaba un error y no hubo');
}

/** Una fila como la devuelve Prisma para el listado (cabecera + relaciones + `_count`). */
const filaDb = (id: string, over: Record<string, unknown> = {}) => ({
  id,
  numero_requisicion: `REQ-2026-${id.slice(-4)}`,
  origen_tipo: 'compra',
  estado: 'aprobada',
  fecha_requisicion: new Date('2026-10-05T00:00:00.000Z'),
  descripcion: 'Insumos de oficina',
  total_estimado: D('1000000'),
  total_para_aprobacion: D('1000000'),
  total_ejecutado: D('0'),
  updated_at: new Date('2026-10-05T12:00:00.000Z'),
  sucursal_id: SUC_1,
  empresas_sucursales: { id: SUC_1, descripcion: 'Casa Central' },
  solicitante: { id: USR, nombres: 'Ana', apellidos: 'Gómez' },
  _count: { requisicion_det: 2 },
  ...over,
});

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

const whereDe = (prisma: any) => prisma.requisicion_cab.findMany.mock.calls[0][0].where;

describe('Requisiciones - listado (findAll)', () => {
  it('fila: cabecera, moneda, sucursal, solicitante, items y items_ejecutados sin traer las líneas', async () => {
    const { service, prisma } = armar({ filas: [filaDb('r-0001')], ejecutadosTotales: [{ requisicion_id: 'r-0001', n: 1 }] });
    const r = await service.findAll(EMP, USR, {});
    expect(r.data[0]).toMatchObject({
      id: 'r-0001',
      origen_tipo: 'compra',
      estado: 'aprobada',
      moneda: { codigo: 'PYG' },
      sucursal: { id: SUC_1, descripcion: 'Casa Central' },
      solicitante: { id: USR, nombres: 'Ana', apellidos: 'Gómez' },
      items: 2,
      items_ejecutados: 1,
      nivel_pendiente: null,
      puedo_aprobar: false,
    });
    expect(r.data[0]).not.toHaveProperty('requisicion_det');
    expect(r.data[0]).not.toHaveProperty('empresas_sucursales');
    expect(r.page).toBe(1);
    expect(r.lastPage).toBe(1);
    const args = prisma.requisicion_cab.findMany.mock.calls[0][0];
    expect(args.include?.requisicion_det).toBeUndefined();
    expect(args.select?.requisicion_det).toBeUndefined();
  });

  it('fila: nivel_pendiente y puedo_aprobar con el perfil del nivel y _APROBAR; sin _APROBAR, puedo_aprobar false', async () => {
    const filas = [filaDb('r-0001', { estado: 'pendiente_aprobacion' })];
    const aprobaciones = [{ requisicion_id: 'r-0001', nivel: 1, estado: 'pendiente', perfil_id: PERFIL_1, perfiles: { id: PERFIL_1, perfil: 'JEFE', desc_perfil: 'Jefe de compras' } }];

    const con = armar({ filas, aprobaciones, perfilesUsuario: [PERFIL_1], privilegios: [APROBAR] });
    const a = await con.service.findAll(EMP, USR, {});
    expect(a.data[0].nivel_pendiente).toEqual({ nivel: 1, perfil: { id: PERFIL_1, nombre: 'Jefe de compras' } });
    expect(a.data[0].puedo_aprobar).toBe(true);

    const sinPrivilegio = armar({ filas, aprobaciones, perfilesUsuario: [PERFIL_1], privilegios: [] });
    const b = await sinPrivilegio.service.findAll(EMP, USR, {});
    expect(b.data[0].nivel_pendiente).toMatchObject({ nivel: 1 });
    expect(b.data[0].puedo_aprobar).toBe(false);

    const otroPerfil = armar({ filas, aprobaciones, perfilesUsuario: [PERFIL_2], privilegios: [APROBAR] });
    expect((await otroPerfil.service.findAll(EMP, USR, {})).data[0].puedo_aprobar).toBe(false);
  });

  it('nivel_pendiente es el menor nivel pendiente aunque ya haya aprobado el anterior; perfil.nombre cae a perfil', async () => {
    const filas = [filaDb('r-0001', { estado: 'pendiente_aprobacion' })];
    const aprobaciones = [
      { requisicion_id: 'r-0001', nivel: 3, estado: 'pendiente', perfil_id: PERFIL_3, perfiles: { id: PERFIL_3, perfil: 'GERENTE', desc_perfil: null } },
      { requisicion_id: 'r-0001', nivel: 2, estado: 'pendiente', perfil_id: PERFIL_2, perfiles: { id: PERFIL_2, perfil: 'SUPERVISOR', desc_perfil: null } },
    ];
    const { service } = armar({ filas, aprobaciones });
    const r = await service.findAll(EMP, USR, {});
    expect(r.data[0].nivel_pendiente).toEqual({ nivel: 2, perfil: { id: PERFIL_2, nombre: 'SUPERVISOR' } });
  });

  it('fila: con_disponible_oc es true en REQ-9 aunque su única OC esté cancelada (R21); ordenes_abiertas solo trae las abiertas', async () => {
    const filas = [filaDb('r-0009')];
    const { service, prisma } = armar({
      filas,
      lineas: [{ id: 'd-1', requisicion_id: 'r-0009', cantidad_solicitada: 10 }],
      pedidas: [], // la OC cancelada no cuenta: la consulta excluye estado 'cancelada'
      ordenesAbiertas: [],
    });
    const r = await service.findAll(EMP, USR, {});
    expect(r.data[0].con_disponible_oc).toBe(true);
    expect(r.data[0].ordenes_abiertas).toEqual([]);
    expect(prisma.orden_compra_det.findMany.mock.calls[0][0].where.orden_compra_cab.estado).toEqual({ not: 'cancelada' });
    const filtroOc = prisma.orden_compra_cab.findMany.mock.calls[0][0].where;
    expect(JSON.stringify(filtroOc)).toContain('"notIn":["cancelada","completada"]');
    // Una OC dada de baja tampoco cuenta como abierta (mismo filtro que Documentos del detalle y que cancelar).
    expect(filtroOc.activo).toEqual({ not: false });
  });

  it('fila: sin disponible (todo pedido) con_disponible_oc false; con OC abierta la lista; gasto nunca ofrece OC', async () => {
    const filas = [filaDb('r-0001'), filaDb('r-0002', { origen_tipo: 'gasto' }), filaDb('r-0003', { estado: 'borrador' })];
    const { service } = armar({
      filas,
      lineas: [
        { id: 'd-1', requisicion_id: 'r-0001', cantidad_solicitada: 10, cantidad_ejecutada: 0 },
        { id: 'd-2', requisicion_id: 'r-0002', cantidad_solicitada: 5, cantidad_ejecutada: 5 },
      ],
      pedidas: [{ requisicion_det_id: 'd-1', cantidad: 10 }],
      ordenesAbiertas: [{ id: 'oc-1', numero_orden: 'OC-1', requisicion_id: 'r-0001' }],
    });
    const r = await service.findAll(EMP, USR, {});
    const [a, b, c] = r.data;
    expect(a.con_disponible_oc).toBe(false);
    expect(a.ordenes_abiertas).toEqual([{ id: 'oc-1', numero_orden: 'OC-1' }]);
    expect(a.con_pendiente).toBe(true);
    expect(b.con_disponible_oc).toBe(false);
    expect(b.con_pendiente).toBe(false);
    expect(c.con_disponible_oc).toBe(false);
    expect(c.con_pendiente).toBe(false);
  });

  it('fila: ejecutado_sobre_aprobado con un gasto más caro que lo aprobado (matriz 17); igual no lo marca', async () => {
    // La fuente es la suma de las líneas, no la columna de la cabecera (que acá miente a propósito).
    const filas = [
      filaDb('r-0001', { estado: 'ejecutada_parcial', total_estimado: D('1000000'), total_ejecutado: D('0') }),
      filaDb('r-0002', { estado: 'ejecutada_total', total_estimado: D('1000000'), total_ejecutado: D('9999999') }),
    ];
    const { service } = armar({
      filas,
      lineas: [
        { id: 'd-1', requisicion_id: 'r-0001', cantidad_solicitada: 10, cantidad_ejecutada: 5, monto_ejecutado: 700000 },
        { id: 'd-2', requisicion_id: 'r-0001', cantidad_solicitada: 10, cantidad_ejecutada: 5, monto_ejecutado: 500000 },
        { id: 'd-3', requisicion_id: 'r-0002', cantidad_solicitada: 10, cantidad_ejecutada: 10, monto_ejecutado: 1000000 },
      ],
    });
    const r = await service.findAll(EMP, USR, {});
    expect(r.data.map((f: any) => f.ejecutado_sobre_aprobado)).toEqual([true, false]);
  });

  it('stats sobre todo el filtro (no la página), rechazadas y canceladas separadas', async () => {
    const { service, prisma } = armar({
      filas: [filaDb('r-0001')],
      total: 41,
      grupos: [
        { estado: 'borrador', n: 5 },
        { estado: 'pendiente_aprobacion', n: 4 },
        { estado: 'aprobada', n: 10 },
        { estado: 'ejecutada_parcial', n: 3 },
        { estado: 'ejecutada_total', n: 12 },
        { estado: 'rechazada', n: 2 },
        { estado: 'cancelada', n: 5 },
      ],
    });
    const r = await service.findAll(EMP, USR, { limit: '1', estado: 'aprobada', origen_tipo: 'compra' });
    expect(r.stats).toEqual({
      total: 41,
      borrador: 5,
      pendiente_aprobacion: 4,
      esperan_mi_aprobacion: 0,
      aprobada: 10,
      ejecutada_parcial: 3,
      ejecutada_total: 12,
      rechazada: 2,
      cancelada: 5,
    });
    expect(prisma.requisicion_cab.groupBy.mock.calls[0][0].where).toEqual(whereDe(prisma));
    expect(prisma.requisicion_cab.count.mock.calls[0][0].where).toEqual(whereDe(prisma));
    expect(prisma.requisicion_cab.findMany.mock.calls[0][0].take).toBe(1);
    expect(r.lastPage).toBe(41);
  });

  describe('esperan mi aprobación', () => {
    const pend = (requisicion_id: string, nivel: number, perfil_id: string) => ({ requisicion_id, nivel, estado: 'pendiente', perfil_id, perfiles: { id: perfil_id, perfil: 'P', desc_perfil: null } });
    // A: nivel 1 mío. B: nivel 1 de otro. C: nivel 1 ya aprobado, nivel 2 mío (el menor pendiente). D: nivel 1 de otro y nivel 2 mío (no es mi turno).
    const aprobaciones = [pend('A', 1, PERFIL_1), pend('B', 1, PERFIL_2), pend('C', 2, PERFIL_1), pend('D', 1, PERFIL_2), pend('D', 2, PERFIL_1)];

    it('cuenta solo las del nivel de un perfil del usuario con _APROBAR y en su alcance (Review Focus)', async () => {
      alcanceMock.mockResolvedValue({ sucursalIds: [SUC_1], puntosEstablecimiento: [], depositoIds: [] });
      const { service, prisma } = armar({ filas: [], aprobaciones, perfilesUsuario: [PERFIL_1], privilegios: [APROBAR] });
      const r = await service.findAll(EMP, USR, {});
      expect(r.stats.esperan_mi_aprobacion).toBe(2);
      // La consulta de pendientes respeta el alcance por sucursal y solo mira las pendientes de aprobación.
      const w = prisma.requisicion_aprobacion.findMany.mock.calls[0][0].where;
      expect(w.requisicion_cab).toMatchObject({ empresa_id: EMP, estado: 'pendiente_aprobacion', sucursal_id: SUC_1 });
    });

    it('sin _APROBAR o sin el perfil no cuenta ninguna', async () => {
      const sinPriv = armar({ aprobaciones, perfilesUsuario: [PERFIL_1], privilegios: [] });
      expect((await sinPriv.service.findAll(EMP, USR, {})).stats.esperan_mi_aprobacion).toBe(0);
      const sinPerfil = armar({ aprobaciones, perfilesUsuario: [], privilegios: [APROBAR] });
      expect((await sinPerfil.service.findAll(EMP, USR, {})).stats.esperan_mi_aprobacion).toBe(0);
    });

    it('un superadmin sin el perfil del nivel no cuenta (sin excepción)', async () => {
      const { service } = armar({ aprobaciones, perfilesUsuario: [], privilegios: [], superadmin: true });
      expect((await service.findAll(EMP, USR, {})).stats.esperan_mi_aprobacion).toBe(0);
    });

    it('un usuario con dos perfiles en la misma requisición la cuenta una vez', async () => {
      const dos = [pend('E', 1, PERFIL_1), pend('E', 2, PERFIL_2)];
      const { service, prisma } = armar({ aprobaciones: dos, perfilesUsuario: [PERFIL_1, PERFIL_2], privilegios: [APROBAR] });
      expect((await service.findAll(EMP, USR, { esperan_mi_aprobacion: true })).stats.esperan_mi_aprobacion).toBe(1);
      expect(whereDe(prisma).id).toEqual({ in: ['E'] });
    });

    it('esperan_mi_aprobacion=true filtra lo mismo que cuenta', async () => {
      const { service, prisma } = armar({ filas: [], aprobaciones, perfilesUsuario: [PERFIL_1], privilegios: [APROBAR] });
      await service.findAll(EMP, USR, { esperan_mi_aprobacion: true });
      expect(whereDe(prisma).id).toEqual({ in: ['A', 'C'] });
      expect(whereDe(prisma).estado).toBe('pendiente_aprobacion');
    });

    it('esperan_mi_aprobacion=true sin ninguna no trae nada (no ignora el filtro)', async () => {
      const { service, prisma } = armar({ filas: [], aprobaciones, perfilesUsuario: [], privilegios: [APROBAR] });
      await service.findAll(EMP, USR, { esperan_mi_aprobacion: true });
      expect(whereDe(prisma).id).toEqual({ in: [] });
    });
  });

  describe('alcance por sucursal (Review Focus)', () => {
    it('restringido a SUC_1: el where limita a su sucursal (las sin sucursal quedan afuera)', async () => {
      alcanceMock.mockResolvedValue({ sucursalIds: [SUC_1], puntosEstablecimiento: [], depositoIds: [] });
      const { service, prisma } = armar({ filas: [filaDb('r-0001')] });
      await service.findAll(EMP, USR, {});
      expect(whereDe(prisma).sucursal_id).toBe(SUC_1);
      expect(whereDe(prisma)).toMatchObject({ empresa_id: EMP, activo: true });
    });

    it('restringido con varias sucursales: { in }; pide otra sucursal que no tiene: { in: [] }', async () => {
      alcanceMock.mockResolvedValue({ sucursalIds: [SUC_1, SUC_2], puntosEstablecimiento: [], depositoIds: [] });
      const a = armar();
      await a.service.findAll(EMP, USR, {});
      expect(whereDe(a.prisma).sucursal_id).toEqual({ in: [SUC_1, SUC_2] });

      alcanceMock.mockResolvedValue({ sucursalIds: [SUC_1], puntosEstablecimiento: [], depositoIds: [] });
      const b = armar();
      await b.service.findAll(EMP, USR, { sucursal_id: SUC_2 });
      expect(whereDe(b.prisma).sucursal_id).toEqual({ in: [] });
    });

    it('sin restricción las ve todas (sin filtro) y con sucursal_id filtra por esa', async () => {
      const a = armar();
      await a.service.findAll(EMP, USR, {});
      expect(whereDe(a.prisma)).not.toHaveProperty('sucursal_id');
      const b = armar();
      await b.service.findAll(EMP, USR, { sucursal_id: SUC_2 });
      expect(whereDe(b.prisma).sucursal_id).toBe(SUC_2);
    });
  });

  it('fecha_desde y fecha_hasta con los límites del día en UTC sobre fecha_requisicion (@db.Date)', async () => {
    const { service, prisma } = armar();
    await service.findAll(EMP, USR, { fecha_desde: '2026-10-05', fecha_hasta: '2026-10-05' });
    expect(whereDe(prisma).fecha_requisicion).toEqual({
      gte: new Date('2026-10-05T00:00:00.000Z'),
      lte: new Date('2026-10-05T23:59:59.999Z'),
    });
  });

  it('búsqueda: número, descripción, descripción o código de un producto de un ítem, ítem libre y nombre del solicitante', async () => {
    const { service, prisma } = armar();
    await service.findAll(EMP, USR, { search: '  tinta ' });
    const texto = JSON.stringify(whereDe(prisma).OR);
    for (const pista of ['numero_requisicion', 'descripcion', 'cod_producto', 'productos', 'solicitante', 'nombres', 'apellidos']) {
      expect(texto).toContain(pista);
    }
    expect(texto).toContain('"contains":"tinta"');
  });

  it('búsqueda «Ana Gómez»: cada palabra en nombres o apellidos, así que encuentra al solicitante Ana Gómez', async () => {
    const { service, prisma } = armar();
    await service.findAll(EMP, USR, { search: ' ana   Gómez ' });
    const contiene = (campo: string, v: string) => ({ [campo]: { contains: v, mode: 'insensitive' } });
    const clausula = whereDe(prisma).OR.find((c: any) => c.solicitante);
    expect(clausula).toEqual({
      solicitante: {
        AND: [
          { OR: [contiene('nombres', 'ana'), contiene('apellidos', 'ana')] },
          { OR: [contiene('nombres', 'Gómez'), contiene('apellidos', 'Gómez')] },
        ],
      },
    });
  });

  describe('sin N+1: las consultas auxiliares no crecen con la cantidad de filas', () => {
    const medir = async (n: number) => {
      const ids = Array.from({ length: n }, (_, i) => `r-${String(i + 1).padStart(4, '0')}`);
      const filas = ids.map((id, i) => filaDb(id, { estado: i % 2 ? 'aprobada' : 'pendiente_aprobacion' }));
      const lineas = ids.flatMap((id, i) => [`${id}-a`, `${id}-b`].map((l) => ({ id: l, requisicion_id: id, cantidad_solicitada: 10, cantidad_ejecutada: i % 2 ? 2 : 0, monto_ejecutado: 0 })));
      const { service, prisma } = armar({
        filas,
        lineas,
        aprobaciones: ids.map((id) => ({ requisicion_id: id, nivel: 1, estado: 'pendiente', perfil_id: PERFIL_1, perfiles: { id: PERFIL_1, perfil: 'P', desc_perfil: null } })),
        ejecutadosTotales: ids.map((id) => ({ requisicion_id: id, n: 1 })),
        perfilesUsuario: [PERFIL_1],
        privilegios: [APROBAR],
      });
      const r = await service.findAll(EMP, USR, {});
      const c = (m: any) => m.mock.calls.length;
      return {
        r,
        llamadas: {
          ordenes: c(prisma.orden_compra_cab.findMany),
          perfiles: c(prisma.usuario_perfiles.findMany),
          privilegios: c(prisma.perfiles_privilegios.findFirst),
          lineas: c(prisma.requisicion_det.findMany),
          ejecutadas: c(prisma.requisicion_det.groupBy),
          aprobaciones: c(prisma.requisicion_aprobacion.findMany),
          pedidas: c(prisma.orden_compra_det.findMany),
          facturadas: c(prisma.compra_det.findMany),
          gastadas: c(prisma.gasto_det.findMany),
        },
      };
    };

    it('filas aprobadas con líneas y disponible para OC: una consulta por tipo, igual con 2 que con 6 filas', async () => {
      const chica = await medir(2);
      const grande = await medir(6);
      expect(grande.r.data).toHaveLength(6);
      expect(grande.r.data.filter((f: any) => f.con_disponible_oc)).toHaveLength(3);
      expect(grande.llamadas).toEqual(chica.llamadas);
      expect(grande.llamadas).toEqual({ ordenes: 1, perfiles: 1, privilegios: 1, lineas: 1, ejecutadas: 1, aprobaciones: 2, pedidas: 1, facturadas: 1, gastadas: 1 });
    });
  });

  it('con la bandeja apagada responde igual (F4b): no 400 y no escribe la config', async () => {
    const { service, prisma } = armar({ filas: [filaDb('r-0001')], config: { habilitar_requisicion_compra: false } });
    await expect(service.findAll(EMP, USR, {})).resolves.toMatchObject({ total: 1 });
    expect(prisma.config_compras.create).not.toHaveBeenCalled();
  });
});

describe('Requisiciones - detalle (findOne)', () => {
  const detalleDb = (over: Record<string, unknown> = {}) => ({
    id: 'r-0001',
    empresa_id: EMP,
    sucursal_id: SUC_1,
    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: D('1000000'),
    total_para_aprobacion: D('1200000'),
    total_ejecutado: D('1150000'),
    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: SUC_1, descripcion: 'Casa Central', punto_establecimiento: '001' },
    solicitante: { id: USR, username: 'ana', nombres: 'Ana', apellidos: 'Gómez' },
    aprobador_final: null,
    requisicion_det: [
      {
        id: 'd-1',
        producto_id: 'p-1',
        cantidad_solicitada: D('10'),
        cantidad_ejecutada: D('4'),
        precio_unitario: D('100000'),
        costo_referencia: D('120000'),
        monto_ejecutado: D('550000'),
        estado: 'ejecutada_parcial',
        productos: { id: 'p-1', descripcion: 'Tinta', cod_producto: 'TIN-1' },
        tipo_gasto: null,
        cont_centros_costo: { id: 'cc-1', codigo: '01', descripcion: 'Administración' },
      },
      {
        id: 'd-2',
        producto_id: null,
        cantidad_solicitada: D('2'),
        cantidad_ejecutada: D('0'),
        precio_unitario: D('50000'),
        costo_referencia: null,
        monto_ejecutado: D('600000'),
        estado: 'pendiente',
        productos: null,
        tipo_gasto: null,
        cont_centros_costo: null,
      },
    ],
    requisicion_aprobacion: [
      {
        id: 'ap-1',
        nivel: 1,
        estado: 'aprobada',
        perfil_id: PERFIL_1,
        fecha_resuelta: new Date('2026-10-06T10:00:00.000Z'),
        comentario: 'ok',
        perfiles: { id: PERFIL_1, perfil: 'JEFE', desc_perfil: 'Jefe de compras' },
        usuario: { id: 'u-2', username: 'beto', nombres: 'Beto', apellidos: 'Paz' },
      },
      {
        id: 'ap-2',
        nivel: 2,
        estado: 'pendiente',
        perfil_id: PERFIL_2,
        fecha_resuelta: null,
        comentario: null,
        perfiles: { id: PERFIL_2, perfil: 'GERENTE', desc_perfil: null },
        usuario: null,
      },
    ],
    requisicion_historial: [
      { id: 'h-2', accion: 'vuelta_a_borrador_precio_estimado', estado_anterior: 'pendiente_aprobacion', estado_nuevo: 'borrador', comentario: null, datos: null, usuario: null, created_at: new Date('2026-10-07T10:00:00.000Z') },
      { id: 'h-1', accion: 'aprobada_nivel', estado_anterior: 'pendiente_aprobacion', estado_nuevo: 'pendiente_aprobacion', comentario: 'ok', datos: { nivel: 1 }, usuario: { id: 'u-2', username: 'beto', nombres: 'Beto', apellidos: 'Paz' }, created_at: new Date('2026-10-06T10:00:00.000Z') },
    ],
    ...over,
  });
  const ordenes = [
    { id: 'oc-1', numero_orden: 'OC-1', estado: 'pendiente', total: D('800000'), proveedores: { personas: { razon_social: 'Papelera SA' } }, moneda: { codigo: 'PYG' } },
    { id: 'oc-2', numero_orden: 'OC-2', estado: 'cancelada', total: D('300000'), proveedores: { personas: { razon_social: 'Otra SA' } }, moneda: { codigo: 'PYG' } },
  ];
  const facturas = [
    { id: 'f-1', numero_factura: '001-001-0000001', estado: 'pendiente', anulado: false, total: D('600000'), proveedores: { personas: { razon_social: 'Papelera SA' } }, moneda: { codigo: 'PYG' } },
    { id: 'f-2', numero_factura: '001-001-0000002', estado: 'pendiente', anulado: true, total: D('999'), proveedores: { personas: { razon_social: 'Papelera SA' } }, moneda: { codigo: 'PYG' } },
  ];
  const gastos = [
    { id: 'g-1', numero_factura: 'INV-9', estado: 'registrado', anulado: false, total: D('100'), proveedores: null, moneda: { codigo: 'USD' } },
    { id: 'g-2', numero_factura: 'INV-10', estado: 'registrado', anulado: false, total: D('50'), proveedores: null, moneda: { codigo: 'USD' } },
    // Anulado con un estado previo guardado: manda `anulado` (`GastosService.anular` escribe `anulado`, nunca `anulada`).
    { id: 'g-4', numero_factura: 'INV-11', estado: 'registrado', anulado: true, total: D('999'), proveedores: null, moneda: { codigo: 'USD' } },
  ];

  it('trae aprobaciones con usuario, documentos de OC, facturas y gastos, y el ejecutado por moneda con equivalente y excedente', async () => {
    const { service } = armar({
      detalle: detalleDb(),
      perfilesUsuario: [PERFIL_2],
      privilegios: [APROBAR],
      ordenes,
      facturas,
      gastos,
      lineas: [
        { id: 'd-1', requisicion_id: 'r-0001', cantidad_solicitada: 10, cantidad_ejecutada: 4, monto_ejecutado: 550000 },
        { id: 'd-2', requisicion_id: 'r-0001', cantidad_solicitada: 2, cantidad_ejecutada: 0, monto_ejecutado: 600000 },
      ],
    });
    const r: any = await service.findOne('r-0001', EMP, USR);
    expect(r.aprobaciones).toEqual([
      { id: 'ap-1', nivel: 1, perfil: { id: PERFIL_1, nombre: 'Jefe de compras' }, estado: 'aprobada', usuario: { nombres: 'Beto', apellidos: 'Paz' }, fecha_resuelta: new Date('2026-10-06T10:00:00.000Z'), comentario: 'ok' },
      { id: 'ap-2', nivel: 2, perfil: { id: PERFIL_2, nombre: 'GERENTE' }, estado: 'pendiente', usuario: null, fecha_resuelta: null, comentario: null },
    ]);
    expect(r.nivel_pendiente).toEqual({ nivel: 2, perfil: { id: PERFIL_2, nombre: 'GERENTE' } });
    expect(r.puedo_aprobar).toBe(true);
    expect(r.documentos.ordenes).toEqual([
      { id: 'oc-1', numero_orden: 'OC-1', proveedor: 'Papelera SA', estado: 'pendiente', total: D('800000'), moneda: { codigo: 'PYG' } },
      { id: 'oc-2', numero_orden: 'OC-2', proveedor: 'Otra SA', estado: 'cancelada', total: D('300000'), moneda: { codigo: 'PYG' } },
    ]);
    expect(r.documentos.facturas).toEqual([
      { id: 'f-1', numero: '001-001-0000001', proveedor: 'Papelera SA', estado: 'pendiente', total: D('600000'), moneda: { codigo: 'PYG' } },
      { id: 'f-2', numero: '001-001-0000002', proveedor: 'Papelera SA', estado: 'anulada', total: D('999'), moneda: { codigo: 'PYG' } },
    ]);
    expect(r.documentos.gastos).toEqual([
      { id: 'g-1', numero: 'INV-9', proveedor: null, estado: 'registrado', total: D('100'), moneda: { codigo: 'USD' } },
      { id: 'g-2', numero: 'INV-10', proveedor: null, estado: 'registrado', total: D('50'), moneda: { codigo: 'USD' } },
      { id: 'g-4', numero: 'INV-11', proveedor: null, estado: 'anulado', total: D('999'), moneda: { codigo: 'USD' } },
    ]);
    // Facturas y gastos no anulados, por moneda; el equivalente es la suma de lo ejecutado de las líneas. Pendiente
    // de aprobación: todavía no hay monto aprobado ni excedente sobre él.
    expect(r.ejecutado).toEqual({
      aprobado: null,
      por_moneda: [
        { codigo: 'PYG', monto: '600000' },
        { codigo: 'USD', monto: '150' },
      ],
      equivalente: '1150000',
      excedente: null,
    });
  });

  const lineasEjecutadas = [
    { id: 'd-1', requisicion_id: 'r-0001', cantidad_solicitada: 10, cantidad_ejecutada: 4, monto_ejecutado: 550000 },
    { id: 'd-2', requisicion_id: 'r-0001', cantidad_solicitada: 2, cantidad_ejecutada: 0, monto_ejecutado: 600000 },
  ];

  it.each(['aprobada', 'ejecutada_parcial', 'ejecutada_total'])(
    'ejecutado.aprobado: en %s es el total estimado y el excedente se mide contra él',
    async (estado) => {
      const { service } = armar({ detalle: detalleDb({ estado }), facturas, gastos, lineas: lineasEjecutadas });
      const r: any = await service.findOne('r-0001', EMP, USR);
      expect(r.ejecutado).toMatchObject({ aprobado: '1000000', equivalente: '1150000', excedente: '150000' });
    },
  );

  it.each(['borrador', 'pendiente_aprobacion', 'rechazada', 'cancelada'])(
    'ejecutado.aprobado: en %s es null (nunca se aprobó o ya no rige), sin excedente',
    async (estado) => {
      const { service } = armar({ detalle: detalleDb({ estado }), facturas, gastos, lineas: lineasEjecutadas });
      const r: any = await service.findOne('r-0001', EMP, USR);
      expect(r.ejecutado).toMatchObject({ aprobado: null, excedente: null, equivalente: '1150000' });
    },
  );

  it('las facturas anuladas (activo false) también salen en Documentos, y lo ejecutado sigue sin contarlas', async () => {
    const { service, prisma } = armar({ detalle: detalleDb(), facturas, gastos: [] });
    const r: any = await service.findOne('r-0001', EMP, USR);
    expect(prisma.compra_cab.findMany.mock.calls[0][0].where).toMatchObject({ requisicion_id: 'r-0001', OR: [{ activo: true }, { anulado: true }] });
    expect(r.documentos.facturas.map((f: any) => f.estado)).toEqual(['pendiente', 'anulada']);
    expect(r.ejecutado.por_moneda).toEqual([{ codigo: 'PYG', monto: '600000' }]);
  });

  it('el estado de una factura o gasto va en minúscula y el de una factura sin estado es pendiente', async () => {
    const { service } = armar({
      detalle: detalleDb(),
      facturas: [{ ...facturas[0], estado: 'PAGADA' }, { ...facturas[0], id: 'f-9', estado: null }],
      gastos: [{ ...gastos[0], estado: 'PARCIAL' }],
    });
    const r: any = await service.findOne('r-0001', EMP, USR);
    expect(r.documentos.facturas.map((f: any) => f.estado)).toEqual(['pagada', 'pendiente']);
    expect(r.documentos.gastos.map((g: any) => g.estado)).toEqual(['parcial']);
  });

  it('ejecutado sin excedente: excedente null cuando lo ejecutado no supera lo aprobado', async () => {
    const det = detalleDb({ requisicion_det: [{ ...detalleDb().requisicion_det[0], monto_ejecutado: D('400000') }], total_ejecutado: D('400000') });
    const { service } = armar({ detalle: det, lineas: [{ id: 'd-1', requisicion_id: 'r-0001', cantidad_solicitada: 10, cantidad_ejecutada: 4, monto_ejecutado: 400000 }] });
    const r: any = await service.findOne('r-0001', EMP, USR);
    expect(r.ejecutado.equivalente).toBe('400000');
    expect(r.ejecutado.excedente).toBeNull();
    expect(r.ejecutado.por_moneda).toEqual([]);
  });

  it('documento sin moneda: moneda null en Documentos (no se inventa) y suma en guaraníes en ejecutado.por_moneda, como la ejecución', async () => {
    const sinMoneda = { id: 'g-3', numero_factura: 'X-1', estado: 'registrado', anulado: false, total: D('70'), proveedores: null, moneda: null };
    const { service } = armar({ detalle: detalleDb(), gastos: [sinMoneda] });
    const r: any = await service.findOne('r-0001', EMP, USR);
    expect(r.documentos.gastos).toEqual([{ id: 'g-3', numero: 'X-1', proveedor: null, estado: 'registrado', total: D('70'), moneda: null }]);
    expect(r.ejecutado.por_moneda).toEqual([{ codigo: 'PYG', monto: '70' }]);
  });

  it('por línea: pedida_oc, pendiente, tipo_gasto y centro_costo', async () => {
    const { service, prisma } = armar({ detalle: detalleDb() });
    prisma.orden_compra_det.groupBy.mockResolvedValue([{ requisicion_det_id: 'd-1', _sum: { cantidad: D('6') } }]);
    const r: any = await service.findOne('r-0001', EMP, USR);
    const [l1, l2] = r.requisicion_det;
    expect(l1).toMatchObject({ id: 'd-1', pedida_oc: '6.0000', pendiente: '6.0000', tipo_gasto: null, centro_costo: { id: 'cc-1', codigo: '01', nombre: 'Administración' } });
    expect(l2).toMatchObject({ id: 'd-2', pedida_oc: '0.0000', pendiente: '2.0000', centro_costo: null });
    expect(l1.costo_referencia).toEqual(D('120000'));
  });

  it('historial: devuelve los eventos tal cual, también con datos null y sin usuario', async () => {
    const { service } = armar({ detalle: detalleDb() });
    const r: any = await service.findOne('r-0001', EMP, USR);
    expect(r.historial).toHaveLength(2);
    expect(r.historial[0]).toEqual({
      id: 'h-2',
      accion: 'vuelta_a_borrador_precio_estimado',
      estado_anterior: 'pendiente_aprobacion',
      estado_nuevo: 'borrador',
      comentario: null,
      datos: null,
      usuario: null,
      created_at: new Date('2026-10-07T10:00:00.000Z'),
    });
    expect(r.historial[1].datos).toEqual({ nivel: 1 });
    expect(r.historial[1].usuario).toEqual({ id: 'u-2', nombres: 'Beto', apellidos: 'Paz' });
  });

  it('cabecera: sucursal con descripcion, moneda, total_para_aprobacion, motivos y aprobador_final', async () => {
    const { service } = armar({ detalle: detalleDb({ motivo_rechazo: 'caro', aprobador_final: { id: 'u-3', username: 'c', nombres: 'Carla', apellidos: 'Díaz' } }) });
    const r: any = await service.findOne('r-0001', EMP, USR);
    expect(r).toMatchObject({
      sucursal: { id: SUC_1, descripcion: 'Casa Central' },
      moneda: { codigo: 'PYG' },
      total_para_aprobacion: D('1200000'),
      motivo_rechazo: 'caro',
      motivo_cancelacion: null,
      aprobador_final: { nombres: 'Carla', apellidos: 'Díaz' },
    });
  });

  it('F8: devuelve ordenes_abiertas, con_disponible_oc, con_pendiente y ejecutado_sobre_aprobado con el mismo armado que findAll', async () => {
    const det = detalleDb({ estado: 'aprobada' });
    const opciones: Opts = {
      lineas: [{ id: 'd-1', requisicion_id: 'r-0001', cantidad_solicitada: 10, cantidad_ejecutada: 4, monto_ejecutado: 1100000 }],
      pedidas: [],
      ordenesAbiertas: [{ id: 'oc-1', numero_orden: 'OC-1', requisicion_id: 'r-0001' }],
    };
    const uno = armar({ ...opciones, detalle: det });
    const d: any = await uno.service.findOne('r-0001', EMP, USR);
    const dos = armar({ ...opciones, filas: [filaDb('r-0001', { estado: 'aprobada' })] });
    const f: any = (await dos.service.findAll(EMP, USR, {})).data[0];
    for (const campo of ['ordenes_abiertas', 'con_disponible_oc', 'con_pendiente', 'ejecutado_sobre_aprobado']) {
      expect(d[campo]).toEqual(f[campo]);
    }
    expect(d).toMatchObject({ ordenes_abiertas: [{ id: 'oc-1', numero_orden: 'OC-1' }], con_disponible_oc: true, con_pendiente: true, ejecutado_sobre_aprobado: true });
  });

  it('fuera del alcance → 404 (restringido a otra sucursal o requisición sin sucursal)', async () => {
    alcanceMock.mockResolvedValue({ sucursalIds: [SUC_2], puntosEstablecimiento: [], depositoIds: [] });
    const { service, prisma } = armar({ detalle: null });
    const e = await error(service.findOne('r-0001', EMP, USR));
    expect(e).toBeInstanceOf(NotFoundException);
    expect(prisma.requisicion_cab.findFirst.mock.calls[0][0].where).toMatchObject({ id: 'r-0001', empresa_id: EMP, activo: true, sucursal_id: SUC_2 });
  });

  it('sin restricción no filtra por sucursal; sin usuario (create) tampoco', async () => {
    const { service, prisma } = armar({ detalle: detalleDb() });
    await service.findOne('r-0001', EMP, '');
    expect(prisma.requisicion_cab.findFirst.mock.calls[0][0].where).not.toHaveProperty('sucursal_id');
  });

  it('trae los montos a un perfil con solo VER: no hay ningún chequeo de EDITAR que los oculte (R2)', async () => {
    const { service, prisma } = armar({ detalle: detalleDb(), privilegios: [] });
    const r: any = await service.findOne('r-0001', EMP, USR);
    expect(r.total_estimado).toEqual(D('1000000'));
    expect(r.requisicion_det[0].precio_unitario).toEqual(D('100000'));
    expect(r.requisicion_det[0].monto_ejecutado).toEqual(D('550000'));
    const pedidos = prisma.perfiles_privilegios.findFirst.mock.calls.map((c: any[]) => c[0].where.privilegios.codigo.in);
    expect(pedidos).toEqual([[APROBAR]]);
    expect(r.puedo_aprobar).toBe(false);
  });

  it('con la bandera apagada responde igual (F4b)', async () => {
    const { service, prisma } = armar({ detalle: detalleDb(), config: { habilitar_requisicion_compra: false } });
    await expect(service.findOne('r-0001', EMP, USR)).resolves.toMatchObject({ id: 'r-0001' });
    expect(prisma.config_compras.create).not.toHaveBeenCalled();
  });
});

describe('Requisiciones - contexto', () => {
  const sucursales = [
    { id: SUC_1, descripcion: 'Casa Central' },
    { id: SUC_2, descripcion: 'Sucursal 2' },
  ];
  const niveles = [
    { origen_tipo: 'compra', perfil_id: PERFIL_1 },
    { origen_tipo: 'compra', perfil_id: PERFIL_2 },
  ];

  it('niveles por origen, aprueba_algun_nivel, puede_ver_config, contabilidad, moneda y sucursales del alcance (matriz 2)', async () => {
    alcanceMock.mockResolvedValue({ sucursalIds: [SUC_1, SUC_2], puntosEstablecimiento: [], depositoIds: [] });
    const { service, prisma } = armar({
      config: { habilitar_requisicion_compra: true, modo_flujo_compra: 'requisicion_opcional', habilitar_orden_compra: true },
      configsNiveles: niveles,
      perfilesUsuario: [PERFIL_2],
      privilegios: [APROBAR, VER_CONFIG],
      contabilidad: true,
      sucursales,
    });
    const r = await service.contexto(EMP, USR);
    expect(r).toEqual({
      habilitada: true,
      modo_flujo: 'requisicion_opcional',
      oc_habilitada: true,
      oc_submodulo: true,
      niveles: { compra: true, gasto: false },
      aprueba_algun_nivel: true,
      contabilidad: true,
      puede_ver_config: true,
      moneda: { codigo: 'PYG' },
      sucursales,
    });
    expect(prisma.empresas_sucursales.findMany.mock.calls[0][0].where).toMatchObject({ empresa_id: EMP, id: { in: [SUC_1, SUC_2] } });
  });

  it('real de Agogó (sin niveles): niveles false en los dos, no aprueba nada, sin ver la config', async () => {
    const { service } = armar({ configsNiveles: [], perfilesUsuario: [PERFIL_1], privilegios: [APROBAR], sucursales });
    const r = await service.contexto(EMP, USR);
    expect(r.niveles).toEqual({ compra: false, gasto: false });
    expect(r.aprueba_algun_nivel).toBe(false);
    expect(r.puede_ver_config).toBe(false);
    expect(r.contabilidad).toBe(false);
  });

  it('aprueba_algun_nivel exige _APROBAR además del perfil de algún nivel', async () => {
    const sinPriv = armar({ configsNiveles: niveles, perfilesUsuario: [PERFIL_1], privilegios: [] });
    expect((await sinPriv.service.contexto(EMP, USR)).aprueba_algun_nivel).toBe(false);
    const otroPerfil = armar({ configsNiveles: niveles, perfilesUsuario: [PERFIL_3], privilegios: [APROBAR] });
    expect((await otroPerfil.service.contexto(EMP, USR)).aprueba_algun_nivel).toBe(false);
  });

  it('con la bandera apagada devuelve habilitada: false (F4b), no 400, y no escribe la config', async () => {
    const { service, prisma } = armar({ config: { habilitar_requisicion_compra: false, modo_flujo_compra: 'directo' }, sucursales });
    const r = await service.contexto(EMP, USR);
    expect(r.habilitada).toBe(false);
    expect(prisma.config_compras.create).not.toHaveBeenCalled();
  });

  it('sin fila de config: habilitada false con los defaults, sin crearla', async () => {
    const { service, prisma } = armar({ config: null });
    const r = await service.contexto(EMP, USR);
    expect(r).toMatchObject({ habilitada: false, modo_flujo: 'directo', oc_habilitada: true });
    expect(prisma.config_compras.create).not.toHaveBeenCalled();
  });

  describe('oc_submodulo (F4b: la misma regla que generar, con submoduloHabilitado)', () => {
    const hoy = new Date();
    const dias = (n: number) => new Date(hoy.getTime() + n * 86_400_000);

    it.each([
      ['habilitado sin prueba', { habilitado: true, fechaFinPrueba: null }, true],
      ['en período de prueba', { habilitado: true, fechaFinPrueba: dias(5) }, true],
      ['prueba vencida (solo lectura): no se puede generar', { habilitado: true, fechaFinPrueba: dias(-5) }, false],
      ['prueba vencida hace más de 30 días (bloqueado)', { habilitado: true, fechaFinPrueba: dias(-60) }, false],
      ['addon no contratado', { habilitado: false, causa: 'addon_no_contratado', mensaje: 'x' }, false],
      ['excluido del plan', { habilitado: false, causa: 'excluido', mensaje: 'x' }, false],
    ])('%s', async (_n, estado, esperado) => {
      submoduloMock.mockResolvedValue(estado);
      const { service, prisma } = armar();
      const r = await service.contexto(EMP, USR);
      expect(r.oc_submodulo).toBe(esperado);
      expect(submoduloMock).toHaveBeenCalledWith(prisma, EMP, 'COMP_ORDENES');
    });

    it('con la OC apagada en Configuración de Compras, oc_habilitada es false aunque el submódulo esté', async () => {
      const { service } = armar({ config: { habilitar_requisicion_compra: true, modo_flujo_compra: 'directo', habilitar_orden_compra: false } });
      const r = await service.contexto(EMP, USR);
      expect(r.oc_habilitada).toBe(false);
      expect(r.oc_submodulo).toBe(true);
    });
  });
});

describe('Requisiciones - niveles aplicables', () => {
  // La config recomendada nueva: «hasta 1.000.000» y «desde 1.000.000,01» (sin hueco).
  const configs = [
    { nivel: 1, perfil_id: PERFIL_1, monto_desde: D('0'), monto_hasta: D('1000000'), activo: true, perfiles: { id: PERFIL_1, perfil: 'JEFE', desc_perfil: 'Jefe de compras' } },
    { nivel: 2, perfil_id: PERFIL_2, monto_desde: D('1000000.01'), monto_hasta: null, activo: true, perfiles: { id: PERFIL_2, perfil: 'GERENTE', desc_perfil: null } },
  ];

  it('con la config recomendada y 1000000.5 → el nivel 2 (ya no cae entre los dos rangos)', async () => {
    const { service } = armar({ configsNiveles: configs });
    expect((await service.nivelesAplicables(EMP, 'compra', 1000000.5)).map((n) => n.nivel)).toEqual([2]);
  });

  it('el borde exacto (1000000) aplica el nivel 1 y 1000000.01 el nivel 2; usa la misma nivelesParaMonto que enviar', async () => {
    const { service } = armar({ configsNiveles: configs });
    expect(await service.nivelesAplicables(EMP, 'compra', 1000000)).toEqual([
      { nivel: 1, perfil: { id: PERFIL_1, nombre: 'Jefe de compras' }, monto_desde: '0', monto_hasta: '1000000' },
    ]);
    expect(await service.nivelesAplicables(EMP, 'compra', 1000000.01)).toEqual([
      { nivel: 2, perfil: { id: PERFIL_2, nombre: 'GERENTE' }, monto_desde: '1000000.01', monto_hasta: null },
    ]);
  });

  it('pide solo los niveles activos de ese origen de la empresa', async () => {
    const { service, prisma } = armar({ configsNiveles: configs });
    await service.nivelesAplicables(EMP, 'gasto', 10);
    expect(prisma.requisicion_aprobacion_config.findMany.mock.calls[0][0].where).toEqual({ empresa_id: EMP, origen_tipo: 'gasto', activo: true });
  });

  it('con la bandera apagada responde igual (F4b)', async () => {
    const { service, prisma } = armar({ configsNiveles: configs, config: { habilitar_requisicion_compra: false } });
    await expect(service.nivelesAplicables(EMP, 'compra', 10)).resolves.toHaveLength(1);
    expect(prisma.config_compras.create).not.toHaveBeenCalled();
  });
});
