import { ValidationPipe } from '@nestjs/common';
import { alcanceSucursalUsuario } from 'src/utils/alcance-sucursal';
import { CreateRequisicionDto } from './dto/create-requisicion.dto';
import { UpdateRequisicionDto } from './dto/update-requisicion.dto';
import { requisicionEnAlcance } from './alcance-requisicion';
import { RequisicionesService } from './requisiciones.service';

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

const alcanceMock = alcanceSucursalUsuario as jest.Mock;

const SUC = 'aaaaaaaa-0000-4000-8000-000000000001';
const OTRA_SUC = 'aaaaaaaa-0000-4000-8000-000000000002';
const UPDATED = new Date('2026-10-05T12:00:00.000Z');

const cuerpo = (e: any) => e.getResponse();

/** Captura el error de una promesa para inspeccionar `response` (codigo, campo, linea) y el status. */
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');
}

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

type Usos = Array<{ requisicion_det_id: string }>;
function armar(
  opts: {
    productoRow?: any;
    maxNumero?: string | null;
    existing?: any;
    habilitada?: boolean;
    usadas?: { oc?: Usos; compras?: Usos; gastos?: Usos };
  } = {},
) {
  const orden: string[] = [];
  const tx: any = {
    $executeRaw: jest.fn().mockImplementation(async (_s: unknown, clave: string) => {
      orden.push(`lock:${clave}`);
    }),
    config_compras: {
      findUnique: jest.fn().mockResolvedValue({ habilitar_requisicion_compra: opts.habilitada ?? true }),
      create: jest.fn(),
    },
    empresas_sucursales: { findFirst: jest.fn().mockImplementation(async ({ where }: any) => ({ id: where.id })) },
    cont_centros_costo: { findFirst: jest.fn().mockResolvedValue({ id: 'cc-1' }) },
    productos: { findFirst: jest.fn().mockResolvedValue(opts.productoRow ?? producto()) },
    tipo_gasto: { findFirst: jest.fn().mockResolvedValue({ id: 'tg-1' }) },
    requisicion_cab: {
      findFirst: jest.fn().mockImplementation(async (args: any) => {
        if (args?.select?.numero_requisicion) {
          orden.push('max');
          return opts.maxNumero ? { numero_requisicion: opts.maxNumero } : null;
        }
        orden.push('relectura');
        return opts.existing ?? null;
      }),
      count: jest.fn().mockResolvedValue(99),
      create: jest.fn().mockResolvedValue({ id: 'req-1' }),
      update: jest.fn().mockResolvedValue(undefined),
    },
    requisicion_det: {
      createMany: jest.fn().mockResolvedValue(undefined),
      deleteMany: jest.fn().mockResolvedValue(undefined),
      update: jest.fn().mockResolvedValue(undefined),
    },
    // Documentos que usan las líneas (edición por diferencia): ninguno salvo que el test lo diga.
    orden_compra_det: { findMany: jest.fn().mockResolvedValue(opts.usadas?.oc ?? []) },
    compra_det: { findMany: jest.fn().mockResolvedValue(opts.usadas?.compras ?? []) },
    gasto_det: { findMany: jest.fn().mockResolvedValue(opts.usadas?.gastos ?? []) },
    requisicion_historial: { create: jest.fn().mockResolvedValue(undefined) },
  };
  const prisma: any = { $transaction: jest.fn().mockImplementation(async (cb: any) => cb(tx)), ...tx };
  const service = new RequisicionesService(prisma, {} as any, { logEnTransaccion: jest.fn() } as any);
  jest.spyOn(service, 'findOne').mockResolvedValue({ id: 'req-1' } as any);
  return { service, tx, prisma, orden };
}

const linea = (over: Record<string, unknown> = {}) => ({
  descripcion: 'Resma de papel',
  cantidad_solicitada: 2,
  precio_unitario: 1000,
  ...over,
});

const altaDto = (items: any[], cab: Record<string, unknown> = {}): CreateRequisicionDto =>
  ({ cabecera: { origen_tipo: 'compra', sucursal_id: SUC, ...cab }, items }) as CreateRequisicionDto;

beforeEach(() => {
  alcanceMock.mockReset();
  alcanceMock.mockResolvedValue(null); // sin restricción
});

describe('Requisiciones - alta', () => {
  it('con la bandera apagada → REQUISICIONES_DESHABILITADAS (400)', async () => {
    const { service } = armar({ habilitada: false });
    const e = await error(service.create(altaDto([linea()]), 'emp-1', 'usr-1'));
    expect(e.getStatus()).toBe(400);
    expect(cuerpo(e)).toMatchObject({ codigo: 'REQUISICIONES_DESHABILITADAS' });
  });

  it('alta sin sucursal → SUCURSAL_REQUERIDA (400, campo sucursal_id)', async () => {
    const { service } = armar();
    const e = await error(service.create(altaDto([linea()], { sucursal_id: undefined }), 'emp-1', 'usr-1'));
    expect(e.getStatus()).toBe(400);
    expect(cuerpo(e)).toMatchObject({ codigo: 'SUCURSAL_REQUERIDA', campo: 'sucursal_id' });
  });

  it('alta con una sucursal fuera del alcance → 403 SUCURSAL_FUERA_DE_ALCANCE', async () => {
    alcanceMock.mockResolvedValue({ sucursalIds: [OTRA_SUC], puntosEstablecimiento: [], depositoIds: [] });
    const { service, tx } = armar();
    const e = await error(service.create(altaDto([linea()]), 'emp-1', 'usr-1'));
    expect(e.getStatus()).toBe(403);
    expect(cuerpo(e)).toMatchObject({ codigo: 'SUCURSAL_FUERA_DE_ALCANCE', campo: 'sucursal_id' });
    expect(tx.requisicion_cab.create).not.toHaveBeenCalled();
  });

  it('orden en el alta: la sucursal fuera del alcance va antes que «items es obligatorio»', async () => {
    alcanceMock.mockResolvedValue({ sucursalIds: [OTRA_SUC], puntosEstablecimiento: [], depositoIds: [] });
    const fuera = armar();
    const e = await error(fuera.service.create(altaDto([]), 'emp-1', 'usr-1'));
    expect(cuerpo(e)).toMatchObject({ codigo: 'SUCURSAL_FUERA_DE_ALCANCE' });
    alcanceMock.mockResolvedValue(null);
    const dentro = armar();
    const e2 = await error(dentro.service.create(altaDto([]), 'emp-1', 'usr-1'));
    expect(e2.getStatus()).toBe(400);
    expect(cuerpo(e2)).toMatchObject({ codigo: 'ITEMS_REQUERIDOS', campo: 'items' });
  });

  it('un ítem libre sin precio → PRECIO_ESTIMADO_REQUERIDO con linea 2', async () => {
    const { service } = armar();
    const e = await error(service.create(altaDto([linea(), linea({ precio_unitario: undefined })]), 'emp-1', 'usr-1'));
    expect(e.getStatus()).toBe(400);
    expect(cuerpo(e)).toMatchObject({ codigo: 'PRECIO_ESTIMADO_REQUERIDO', campo: 'precio_unitario', linea: 2 });
  });

  it('con precio 0 también → PRECIO_ESTIMADO_REQUERIDO', async () => {
    const { service } = armar();
    const e = await error(service.create(altaDto([linea({ precio_unitario: 0 })]), 'emp-1', 'usr-1'));
    expect(cuerpo(e)).toMatchObject({ codigo: 'PRECIO_ESTIMADO_REQUERIDO', linea: 1 });
  });

  it('cantidad 0 o con 5 decimales → CANTIDAD_INVALIDA con linea; sin producto ni texto → ITEM_SIN_DESCRIPCION', async () => {
    const { service } = armar();
    const e1 = await error(service.create(altaDto([linea({ cantidad_solicitada: 0 })]), 'emp-1', 'usr-1'));
    expect(cuerpo(e1)).toMatchObject({ codigo: 'CANTIDAD_INVALIDA', campo: 'cantidad_solicitada', linea: 1 });
    const e2 = await error(service.create(altaDto([linea(), linea({ cantidad_solicitada: 1.00001 })]), 'emp-1', 'usr-1'));
    expect(cuerpo(e2)).toMatchObject({ codigo: 'CANTIDAD_INVALIDA', linea: 2 });
    const e3 = await error(service.create(altaDto([linea({ descripcion: '   ' })]), 'emp-1', 'usr-1'));
    expect(cuerpo(e3)).toMatchObject({ codigo: 'ITEM_SIN_DESCRIPCION', campo: 'descripcion', linea: 1 });
    const gasto = await error(service.create(altaDto([linea({ descripcion: '' })], { origen_tipo: 'gasto' }), 'emp-1', 'usr-1'));
    expect(cuerpo(gasto)).toMatchObject({ codigo: 'ITEM_SIN_DESCRIPCION', linea: 1 });
  });

  it('el orden por línea es cantidad, descripción y precio', async () => {
    const { service } = armar();
    const e = await error(service.create(altaDto([{ cantidad_solicitada: 0, precio_unitario: 0 }]), 'emp-1', 'usr-1'));
    expect(cuerpo(e).codigo).toBe('CANTIDAD_INVALIDA');
    const e2 = await error(service.create(altaDto([{ cantidad_solicitada: 1, precio_unitario: 0 }]), 'emp-1', 'usr-1'));
    expect(cuerpo(e2).codigo).toBe('ITEM_SIN_DESCRIPCION');
  });

  it('un producto graba costo_referencia y total_para_aprobacion con el mayor (precio menor y precio mayor al costo)', async () => {
    const { service, tx } = armar({ productoRow: producto({ precio_costo: 1500, precio: 1800 }) });
    await service.create(
      altaDto([
        linea({ producto_id: 'prod-1', descripcion: undefined, cantidad_solicitada: 2, precio_unitario: 1000 }), // 1000 < 1500
        linea({ producto_id: 'prod-1', descripcion: undefined, cantidad_solicitada: 1, precio_unitario: 2000 }), // 2000 > 1500
      ]),
      'emp-1',
      'usr-1',
    );
    const cab = tx.requisicion_cab.create.mock.calls[0][0].data;
    expect(Number(cab.total_estimado)).toBe(4000); // 2×1000 + 1×2000
    expect(Number(cab.total_para_aprobacion)).toBe(5000); // 2×1500 + 1×2000
    const filas = tx.requisicion_det.createMany.mock.calls[0][0].data;
    expect(filas.map((f: any) => f.costo_referencia)).toEqual([1500, 1500]);
    // Sin texto, la línea de producto queda sin descripción (F5).
    expect(filas.map((f: any) => f.descripcion)).toEqual([null, null]);
  });

  it('producto sin costo ni lista: costo_referencia 0 y el nivel usa lo cargado (F2)', async () => {
    const { service, tx } = armar({ productoRow: producto() });
    await service.create(altaDto([linea({ producto_id: 'prod-1', cantidad_solicitada: 3, precio_unitario: 700 })]), 'emp-1', 'usr-1');
    const filas = tx.requisicion_det.createMany.mock.calls[0][0].data;
    expect(filas[0].costo_referencia).toBe(0);
    const cab = tx.requisicion_cab.create.mock.calls[0][0].data;
    expect(Number(cab.total_para_aprobacion)).toBe(2100);
  });

  it('libres y gastos guardan costo_referencia null (aunque tengan producto en un gasto)', async () => {
    const { service, tx } = armar({ productoRow: producto({ precio_costo: 5000 }) });
    await service.create(altaDto([linea()]), 'emp-1', 'usr-1');
    expect(tx.requisicion_det.createMany.mock.calls[0][0].data[0].costo_referencia).toBeNull();
    await service.create(altaDto([linea({ producto_id: 'prod-1' })], { origen_tipo: 'gasto' }), 'emp-1', 'usr-1');
    expect(tx.requisicion_det.createMany.mock.calls[1][0].data[0].costo_referencia).toBeNull();
  });

  it('el número toma req-num: antes de leer y sale del máximo, no del count', async () => {
    const { service, tx, orden } = armar({ maxNumero: 'REQ-2026-000041' });
    jest.useFakeTimers().setSystemTime(new Date('2026-10-05T15:00:00.000Z'));
    try {
      await service.create(altaDto([linea()]), 'emp-1', 'usr-1');
    } finally {
      jest.useRealTimers();
    }
    expect(tx.requisicion_cab.create.mock.calls[0][0].data.numero_requisicion).toBe('REQ-2026-000042');
    expect(tx.requisicion_cab.count).not.toHaveBeenCalled();
    expect(orden).toEqual(['lock:req-num:emp-1', 'max']);
  });

  it('el primero del año es 000001', async () => {
    const { service, tx } = armar({ maxNumero: null });
    jest.useFakeTimers().setSystemTime(new Date('2026-10-05T15:00:00.000Z'));
    try {
      await service.create(altaDto([linea()]), 'emp-1', 'usr-1');
    } finally {
      jest.useRealTimers();
    }
    expect(tx.requisicion_cab.create.mock.calls[0][0].data.numero_requisicion).toBe('REQ-2026-000001');
  });

  it('el número usa el año de hoyComoFechaPY a las 01:30 UTC del 01/01', async () => {
    const { service, tx } = armar({ maxNumero: 'REQ-2026-000007' });
    jest.useFakeTimers().setSystemTime(new Date('2027-01-01T01:30:00.000Z')); // 31/12 22:30 en Paraguay
    try {
      await service.create(altaDto([linea()]), 'emp-1', 'usr-1');
    } finally {
      jest.useRealTimers();
    }
    const data = tx.requisicion_cab.create.mock.calls[0][0].data;
    expect(data.numero_requisicion).toBe('REQ-2026-000008');
    expect(data.fecha_requisicion.toISOString()).toBe('2026-12-31T00:00:00.000Z'); // la fecha por defecto también es la de Paraguay
    const buscado = tx.requisicion_cab.findFirst.mock.calls.find((c: any[]) => c[0]?.select?.numero_requisicion)[0];
    expect(buscado.where.numero_requisicion.startsWith).toBe('REQ-2026-');
  });

  it('historial creada con comentario null y los dos totales grabados', async () => {
    const { service, tx } = armar();
    await service.create(altaDto([linea()]), 'emp-1', 'usr-1');
    expect(tx.requisicion_historial.create.mock.calls[0][0].data).toMatchObject({
      accion: 'creada',
      estado_nuevo: 'borrador',
      comentario: null,
    });
    const cab = tx.requisicion_cab.create.mock.calls[0][0].data;
    expect(Number(cab.total_estimado)).toBe(2000);
    expect(Number(cab.total_para_aprobacion)).toBe(2000);
  });
});

describe('Requisiciones - edición', () => {
  const existente = (over: Record<string, unknown> = {}) => ({
    id: 'req-1',
    empresa_id: 'emp-1',
    sucursal_id: SUC,
    estado: 'borrador',
    origen_tipo: 'compra',
    motivo_rechazo: null,
    updated_at: UPDATED,
    fecha_requisicion: new Date('2026-10-05T00:00:00.000Z'),
    requisicion_det: [],
    ...over,
  });
  const edicion = (over: Record<string, unknown> = {}): UpdateRequisicionDto =>
    ({ updated_at: UPDATED.toISOString(), items: [linea()], ...over }) as UpdateRequisicionDto;

  it('editar una rechazada la pasa a borrador con actualizada y conserva motivo_rechazo (R14)', async () => {
    const { service, tx, orden } = armar({ existing: existente({ estado: 'rechazada', motivo_rechazo: 'Falta presupuesto' }) });
    await service.update('req-1', edicion(), 'emp-1', 'usr-1');
    const patch = tx.requisicion_cab.update.mock.calls[0][0].data;
    expect(patch.estado).toBe('borrador');
    expect(patch).not.toHaveProperty('motivo_rechazo');
    expect(tx.requisicion_historial.create.mock.calls[0][0].data).toMatchObject({
      accion: 'actualizada',
      estado_anterior: 'rechazada',
      estado_nuevo: 'borrador',
      comentario: null,
    });
    expect(orden.slice(0, 2)).toEqual(['lock:req:req-1', 'relectura']); // la relectura va después del lock
  });

  it('editar graba el cambio de origen (R15) y recalcula los dos totales', async () => {
    const { service, tx } = armar({ existing: existente() });
    await service.update(
      'req-1',
      edicion({ cabecera: { origen_tipo: 'gasto' }, items: [linea({ tipo_gasto_id: 'tg-1', cantidad_solicitada: 4, precio_unitario: 250 })] }),
      'emp-1',
      'usr-1',
    );
    const patch = tx.requisicion_cab.update.mock.calls[0][0].data;
    expect(patch.origen_tipo).toBe('gasto');
    expect(Number(patch.total_estimado)).toBe(1000);
    expect(Number(patch.total_para_aprobacion)).toBe(1000);
    expect(tx.requisicion_det.createMany).toHaveBeenCalled();
  });

  it('editar con updated_at viejo → 409 DATOS_CAMBIADOS', async () => {
    const { service, tx } = armar({ existing: existente() });
    const e = await error(service.update('req-1', edicion({ updated_at: '2026-10-05T11:00:00.000Z' }), 'emp-1', 'usr-1'));
    expect(e.getStatus()).toBe(409);
    expect(cuerpo(e)).toMatchObject({ codigo: 'DATOS_CAMBIADOS' });
    expect(tx.requisicion_cab.update).not.toHaveBeenCalled();
  });

  it.each(['aprobada', 'pendiente_aprobacion', 'cancelada', 'ejecutada_parcial'])(
    'editar una %s → 409 REQUISICION_ESTADO_CAMBIADO con estado_actual',
    async (estado) => {
      const { service } = armar({ existing: existente({ estado }) });
      const e = await error(service.update('req-1', edicion(), 'emp-1', 'usr-1'));
      expect(e.getStatus()).toBe(409);
      expect(cuerpo(e)).toMatchObject({ codigo: 'REQUISICION_ESTADO_CAMBIADO', estado_actual: estado });
    },
  );

  it('editar con la bandera apagada → REQUISICIONES_DESHABILITADAS', async () => {
    const { service } = armar({ habilitada: false, existing: existente() });
    const e = await error(service.update('req-1', edicion(), 'emp-1', 'usr-1'));
    expect(cuerpo(e)).toMatchObject({ codigo: 'REQUISICIONES_DESHABILITADAS' });
  });

  it('editar una requisición fuera del alcance → 404 (el where lleva el filtro de sucursal)', async () => {
    alcanceMock.mockResolvedValue({ sucursalIds: [OTRA_SUC], puntosEstablecimiento: [], depositoIds: [] });
    const { service, tx } = armar({ existing: null });
    const e = await error(service.update('req-1', edicion(), 'emp-1', 'usr-1'));
    expect(e.getStatus()).toBe(404);
    expect(tx.requisicion_cab.findFirst.mock.calls[0][0].where).toMatchObject({ id: 'req-1', empresa_id: 'emp-1', sucursal_id: OTRA_SUC });
    expect(tx.requisicion_cab.update).not.toHaveBeenCalled();
  });

  it('cambiar a una sucursal fuera del alcance → 403 SUCURSAL_FUERA_DE_ALCANCE', async () => {
    alcanceMock.mockResolvedValue({ sucursalIds: [SUC], puntosEstablecimiento: [], depositoIds: [] });
    const { service, tx } = armar({ existing: existente() });
    const e = await error(service.update('req-1', edicion({ cabecera: { origen_tipo: 'compra', sucursal_id: OTRA_SUC } }), 'emp-1', 'usr-1'));
    expect(e.getStatus()).toBe(403);
    expect(cuerpo(e)).toMatchObject({ codigo: 'SUCURSAL_FUERA_DE_ALCANCE', campo: 'sucursal_id' });
    expect(tx.requisicion_cab.update).not.toHaveBeenCalled();
  });

  it('dejar la sucursal vacía → SUCURSAL_REQUERIDA; los ítems siguen los códigos del alta', async () => {
    const { service } = armar({ existing: existente() });
    const e = await error(service.update('req-1', edicion({ cabecera: { origen_tipo: 'compra', sucursal_id: '' } }), 'emp-1', 'usr-1'));
    expect(cuerpo(e)).toMatchObject({ codigo: 'SUCURSAL_REQUERIDA' });
    const e2 = await error(service.update('req-1', edicion({ items: [linea({ precio_unitario: 0 })] }), 'emp-1', 'usr-1'));
    expect(cuerpo(e2)).toMatchObject({ codigo: 'PRECIO_ESTIMADO_REQUERIDO', linea: 1 });
  });

  const lineaGuardada = (over: Record<string, unknown> = {}) => ({
    id: 'det-1',
    producto_id: null,
    tipo_gasto_id: null,
    centro_costo_id: null,
    descripcion: null,
    cantidad_solicitada: 2,
    precio_unitario: 1000,
    costo_referencia: null,
    porcentaje_iva: 10,
    ...over,
  });

  it('compra -> gasto sin ítems: una línea de producto sin descripción → ITEM_SIN_DESCRIPCION con su línea', async () => {
    const { service, tx } = armar({
      existing: existente({ requisicion_det: [lineaGuardada({ descripcion: 'Libre' }), lineaGuardada({ producto_id: 'prod-1', costo_referencia: 1500 })] }),
    });
    const e = await error(service.update('req-1', { updated_at: UPDATED.toISOString(), cabecera: { origen_tipo: 'gasto', sucursal_id: SUC } } as any, 'emp-1', 'usr-1'));
    expect(e.getStatus()).toBe(400);
    expect(cuerpo(e)).toMatchObject({ codigo: 'ITEM_SIN_DESCRIPCION', campo: 'descripcion', linea: 2 });
    expect(tx.requisicion_cab.update).not.toHaveBeenCalled();
  });

  it('compra -> gasto sin ítems: con descripción, costo_referencia pasa a null y total_para_aprobacion al precio', async () => {
    const { service, tx } = armar({
      existing: existente({ requisicion_det: [lineaGuardada({ producto_id: 'prod-1', descripcion: 'Papel', costo_referencia: 1500 })] }),
    });
    await service.update('req-1', { updated_at: UPDATED.toISOString(), cabecera: { origen_tipo: 'gasto', sucursal_id: SUC } } as any, 'emp-1', 'usr-1');
    // La línea se actualiza en su lugar (conserva su id).
    expect(tx.requisicion_det.update.mock.calls[0][0]).toMatchObject({ where: { id: 'det-1' }, data: { costo_referencia: null } });
    expect(tx.requisicion_det.createMany).not.toHaveBeenCalled();
    const patch = tx.requisicion_cab.update.mock.calls[0][0].data;
    expect(Number(patch.total_estimado)).toBe(2000);
    expect(Number(patch.total_para_aprobacion)).toBe(2000); // antes: 2 × max(1000, 1500) = 3000
  });

  it('gasto -> compra sin ítems: una línea con tipo de gasto y sin texto → ITEM_SIN_DESCRIPCION; con texto se le quita el tipo', async () => {
    const mala = armar({ existing: existente({ origen_tipo: 'gasto', requisicion_det: [lineaGuardada({ tipo_gasto_id: 'tg-1' })] }) });
    const e = await error(mala.service.update('req-1', { updated_at: UPDATED.toISOString(), cabecera: { origen_tipo: 'compra', sucursal_id: SUC } } as any, 'emp-1', 'usr-1'));
    expect(cuerpo(e)).toMatchObject({ codigo: 'ITEM_SIN_DESCRIPCION', linea: 1 });

    const buena = armar({
      existing: existente({
        origen_tipo: 'gasto',
        requisicion_det: [lineaGuardada({ tipo_gasto_id: 'tg-1', descripcion: 'Flete' }), lineaGuardada({ id: 'det-2', producto_id: 'prod-1' })],
      }),
      productoRow: producto({ precio_costo: 1500 }),
    });
    await buena.service.update('req-1', { updated_at: UPDATED.toISOString(), cabecera: { origen_tipo: 'compra', sucursal_id: SUC } } as any, 'emp-1', 'usr-1');
    const filas = buena.tx.requisicion_det.update.mock.calls.map((c: any[]) => c[0].data);
    expect(buena.tx.requisicion_det.update.mock.calls.map((c: any[]) => c[0].where.id)).toEqual(['det-1', 'det-2']);
    expect(filas.map((f: any) => f.tipo_gasto_id)).toEqual([null, null]);
    expect(filas.map((f: any) => f.costo_referencia)).toEqual([null, 1500]);
    expect(Number(buena.tx.requisicion_cab.update.mock.calls[0][0].data.total_para_aprobacion)).toBe(5000); // 2×1000 + 2×max(1000,1500)
  });

  describe('líneas por diferencia (rechazada vieja con OC canceladas: I3 de la revisión final)', () => {
    const rechazada = () =>
      existente({
        estado: 'rechazada',
        requisicion_det: [
          lineaGuardada({ id: 'det-1', descripcion: 'Resma A4', cantidad_ejecutada: 0 }),
          lineaGuardada({ id: 'det-2', descripcion: 'Toner' }),
        ],
      });

    it('conserva el id de las líneas que siguen (las usa una OC cancelada), crea las nuevas y borra la que no usa nadie', async () => {
      const { service, tx } = armar({ existing: rechazada(), usadas: { oc: [{ requisicion_det_id: 'det-1' }] } });
      await service.update(
        'req-1',
        edicion({ items: [linea({ id: 'det-1', descripcion: 'Resma A4', cantidad_solicitada: 5 }), linea({ descripcion: 'Carpetas' })] }),
        'emp-1',
        'usr-1',
      );
      expect(tx.requisicion_det.update).toHaveBeenCalledTimes(1);
      expect(tx.requisicion_det.update.mock.calls[0][0]).toMatchObject({
        where: { id: 'det-1' },
        data: { cantidad_solicitada: 5, descripcion: 'Resma A4', estado: 'pendiente' },
      });
      expect(tx.requisicion_det.update.mock.calls[0][0].data).not.toHaveProperty('cantidad_ejecutada');
      expect(tx.requisicion_det.deleteMany).toHaveBeenCalledWith({ where: { id: { in: ['det-2'] }, requisicion_id: 'req-1' } });
      expect(tx.requisicion_det.createMany.mock.calls[0][0].data).toEqual([
        expect.objectContaining({ requisicion_id: 'req-1', descripcion: 'Carpetas', cantidad_ejecutada: 0 }),
      ]);
      expect(tx.requisicion_cab.update.mock.calls[0][0].data.estado).toBe('borrador');
    });

    it.each([
      ['una OC (cancelada)', { oc: [{ requisicion_det_id: 'det-2' }] }],
      ['una factura (anulada)', { compras: [{ requisicion_det_id: 'det-2' }] }],
      ['un gasto (anulado)', { gastos: [{ requisicion_det_id: 'det-2' }] }],
    ])('quitar una línea que usa %s → 409 LINEA_CON_DOCUMENTOS y no se borra nada', async (_n, usadas) => {
      const { service, tx } = armar({ existing: rechazada(), usadas });
      const e = await error(service.update('req-1', edicion({ items: [linea({ id: 'det-1' })] }), 'emp-1', 'usr-1'));
      expect(e.getStatus()).toBe(409);
      expect(cuerpo(e)).toMatchObject({ codigo: 'LINEA_CON_DOCUMENTOS', requisicion_det_id: 'det-2' });
      expect(cuerpo(e).message).toContain('«Toner»');
      expect(tx.requisicion_det.deleteMany).not.toHaveBeenCalled();
      expect(tx.requisicion_cab.update).not.toHaveBeenCalled();
    });

    it('sin ids (un cliente viejo): las líneas sin documentos se reemplazan como antes', async () => {
      const { service, tx } = armar({ existing: rechazada() });
      await service.update('req-1', edicion({ items: [linea()] }), 'emp-1', 'usr-1');
      expect(tx.requisicion_det.deleteMany).toHaveBeenCalledWith({ where: { id: { in: ['det-1', 'det-2'] }, requisicion_id: 'req-1' } });
      expect(tx.requisicion_det.createMany).toHaveBeenCalledTimes(1);
      expect(tx.requisicion_det.update).not.toHaveBeenCalled();
    });

    it('un id que no es de esta requisición se toma como línea nueva', async () => {
      const { service, tx } = armar({ existing: existente({ requisicion_det: [] }) });
      await service.update('req-1', edicion({ items: [linea({ id: '0f8a3c7e-0000-4000-8000-000000000000' })] }), 'emp-1', 'usr-1');
      expect(tx.requisicion_det.update).not.toHaveBeenCalled();
      expect(tx.requisicion_det.createMany.mock.calls[0][0].data[0]).not.toHaveProperty('id');
    });
  });

  it('sin cambio de origen y sin ítems no toca las líneas', async () => {
    const { service, tx } = armar({ existing: existente({ requisicion_det: [lineaGuardada({ descripcion: 'x' })] }) });
    await service.update('req-1', { updated_at: UPDATED.toISOString(), cabecera: { origen_tipo: 'compra', descripcion: 'Nueva' } } as any, 'emp-1', 'usr-1');
    expect(tx.requisicion_det.deleteMany).not.toHaveBeenCalled();
    expect(tx.requisicion_cab.update.mock.calls[0][0].data).not.toHaveProperty('total_estimado');
  });

  it('orden en la edición: la bandera apagada y el 404 de alcance van antes que «items no puede ser vacío»', async () => {
    const apagada = armar({ habilitada: false, existing: existente() });
    const e1 = await error(apagada.service.update('req-1', edicion({ items: [] }), 'emp-1', 'usr-1'));
    expect(cuerpo(e1)).toMatchObject({ codigo: 'REQUISICIONES_DESHABILITADAS' });
    const fuera = armar({ existing: null });
    const e2 = await error(fuera.service.update('req-1', edicion({ items: [] }), 'emp-1', 'usr-1'));
    expect(e2.getStatus()).toBe(404);
    const dentro = armar({ existing: existente() });
    const e3 = await error(dentro.service.update('req-1', edicion({ items: [] }), 'emp-1', 'usr-1'));
    expect(e3.getStatus()).toBe(400);
    expect(cuerpo(e3)).toMatchObject({ codigo: 'ITEMS_REQUERIDOS', campo: 'items' });
  });

  it('updated_at: null con null es igual; null contra una fecha, o al revés, es DATOS_CAMBIADOS', async () => {
    const igual = armar({ existing: existente({ updated_at: null }) });
    await expect(igual.service.update('req-1', edicion({ updated_at: null }), 'emp-1', 'usr-1')).resolves.toBeDefined();
    const baseNull = armar({ existing: existente({ updated_at: null }) });
    const e1 = await error(baseNull.service.update('req-1', edicion(), 'emp-1', 'usr-1'));
    expect(cuerpo(e1)).toMatchObject({ codigo: 'DATOS_CAMBIADOS' });
    const clienteNull = armar({ existing: existente() });
    const e2 = await error(clienteNull.service.update('req-1', edicion({ updated_at: null }), 'emp-1', 'usr-1'));
    expect(cuerpo(e2)).toMatchObject({ codigo: 'DATOS_CAMBIADOS' });
  });
});

describe('requisicionEnAlcance', () => {
  const txCon = (fila: any) => ({ requisicion_cab: { findFirst: jest.fn().mockResolvedValue(fila) } }) as any;

  it('sin restricción no filtra por sucursal (ve también las de sucursal null)', async () => {
    const tx = txCon({ id: 'req-1', sucursal_id: null });
    await expect(requisicionEnAlcance(tx, 'req-1', 'emp-1', 'usr-1')).resolves.toMatchObject({ id: 'req-1' });
    expect(tx.requisicion_cab.findFirst.mock.calls[0][0].where).not.toHaveProperty('sucursal_id');
  });

  it('con restricción filtra con in/igual a las sucursales del usuario: una de sucursal null no coincide → 404', async () => {
    alcanceMock.mockResolvedValue({ sucursalIds: [SUC, OTRA_SUC], puntosEstablecimiento: [], depositoIds: [] });
    const tx = txCon(null);
    const e = await error(requisicionEnAlcance(tx, 'req-1', 'emp-1', 'usr-1'));
    expect(e.getStatus()).toBe(404);
    expect(tx.requisicion_cab.findFirst.mock.calls[0][0].where.sucursal_id).toEqual({ in: [SUC, OTRA_SUC] });
  });

  it('sin sucursales asignadas ({ in: [] }) no ve nada', async () => {
    alcanceMock.mockResolvedValue({ sucursalIds: [], puntosEstablecimiento: [], depositoIds: [] });
    const tx = txCon(null);
    await error(requisicionEnAlcance(tx, 'req-1', 'emp-1', 'usr-1'));
    expect(tx.requisicion_cab.findFirst.mock.calls[0][0].where.sucursal_id).toEqual({ in: [] });
  });
});

describe('referenciaProducto', () => {
  it('devuelve el costo, o el precio de lista si no hay costo, o null', async () => {
    const a = armar({ productoRow: producto({ precio_costo: 1500.5, precio: 1800 }) });
    await expect(a.service.referenciaProducto('emp-1', 'prod-1')).resolves.toEqual({ producto_id: 'prod-1', costo_referencia: '1500.5000' });
    const b = armar({ productoRow: producto({ precio_costo: 0, precio: 1800 }) });
    await expect(b.service.referenciaProducto('emp-1', 'prod-1')).resolves.toEqual({ producto_id: 'prod-1', costo_referencia: '1800.0000' });
    const c = armar({ productoRow: producto() });
    await expect(c.service.referenciaProducto('emp-1', 'prod-1')).resolves.toEqual({ producto_id: 'prod-1', costo_referencia: null });
  });

  it('con la bandera apagada → REQUISICIONES_DESHABILITADAS', async () => {
    const { service } = armar({ habilitada: false });
    const e = await error(service.referenciaProducto('emp-1', 'prod-1'));
    expect(cuerpo(e)).toMatchObject({ codigo: 'REQUISICIONES_DESHABILITADAS' });
  });
});

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

  it('precio_unitario 0, cantidad 0 y descripción vacía llegan al servicio (validan solo tipos)', async () => {
    const out: any = await pasar(
      { cabecera: { origen_tipo: 'compra', sucursal_id: SUC }, items: [{ descripcion: '', cantidad_solicitada: 0, precio_unitario: 0 }] },
      CreateRequisicionDto,
    );
    expect(out.items[0].precio_unitario).toBe(0);
    expect(out.items[0].cantidad_solicitada).toBe(0);
  });

  it('un alta sin sucursal ni precio pasa el pipe: el servicio responde con su código', async () => {
    const out: any = await pasar({ cabecera: { origen_tipo: 'compra' }, items: [{ producto_id: 'aaaaaaaa-0000-4000-8000-0000000000aa', cantidad_solicitada: 1 }] }, CreateRequisicionDto);
    expect(out.cabecera.sucursal_id).toBeUndefined();
  });

  it('sigue rechazando tipos mal (precio texto, más de 4 decimales, propiedades de más)', async () => {
    const base = { cabecera: { origen_tipo: 'compra', sucursal_id: SUC } };
    await expect(pasar({ ...base, items: [{ descripcion: 'x', cantidad_solicitada: 1, precio_unitario: 'caro' }] }, CreateRequisicionDto)).rejects.toThrow();
    await expect(pasar({ ...base, items: [{ descripcion: 'x', cantidad_solicitada: 1, precio_unitario: 1.00001 }] }, CreateRequisicionDto)).rejects.toThrow();
    await expect(pasar({ ...base, items: [{ descripcion: 'x', cantidad_solicitada: 1, precio_unitario: 1, costo_referencia: 5 }] }, CreateRequisicionDto)).rejects.toThrow();
  });

  it('la edición acepta updated_at null (fila sin fecha)', async () => {
    await expect(pasar({ updated_at: null }, UpdateRequisicionDto)).resolves.toBeDefined();
  });

  it('la edición exige updated_at ISO 8601', async () => {
    await expect(pasar({ items: [] }, UpdateRequisicionDto)).rejects.toThrow();
    await expect(pasar({ updated_at: 'ayer' }, UpdateRequisicionDto)).rejects.toThrow();
    await expect(pasar({ updated_at: UPDATED.toISOString() }, UpdateRequisicionDto)).resolves.toBeDefined();
  });
});
