import { BadRequestException, ConflictException, NotFoundException } from '@nestjs/common';
import { consumirSaldosRemision, saldoFacturable, validarCantidadesRemision } from './aplicacion-remision';

/**
 * I-B (re-revisión de la ola 5 de Existencias): `aplicaciones_remision[].nota_remision_det_id` se buscaba solo por id.
 * - Con el renglón de remisión de otra empresa se escribía en ella (cantidad_facturada, aplicación, vínculo) y el 400 decía su saldo.
 * - Con el de otro producto u otro cliente, el ítem se vendía sin descontar stock.
 * - El saldo se leía y se sumaba sin bloqueo: dos facturas a la vez sobrefacturaban la remisión.
 * Ahora el renglón tiene que ser de una remisión aprobada de la empresa y del cliente, del mismo producto, y el saldo se consume
 * con un UPDATE condicional.
 */
const item = (over: any = {}) => ({
  producto_id: 'prod-1',
  descripcion: 'ZZ Tornillo',
  cantidad: 3,
  aplicaciones_remision: [{ nota_remision_det_id: 'det-1', cantidad: 3 }],
  ...over,
});

const txCon = (renglones: Record<string, any>, consumidos: string[] = Object.keys(renglones)) => {
  const sql: string[] = [];
  return {
    sql,
    nota_remision_det: {
      findFirst: jest.fn(({ where }: any) => Promise.resolve(renglones[where.id] ?? null)),
    },
    $queryRaw: jest.fn((partes: TemplateStringsArray, ...valores: any[]) => {
      sql.push(partes.join('?'));
      const id = valores.find((v) => typeof v === 'string' && renglones[v]);
      if (partes.join('').includes('UPDATE')) return Promise.resolve(consumidos.includes(id) ? [{ id }] : []);
      return Promise.resolve([{ disponible: 1 }]);
    }),
  };
};
const ctx = { empresaId: 'emp-1', clienteId: 'cli-1' };

describe('consumirSaldosRemision', () => {
  it('busca el renglón solo en una remisión aprobada de la empresa y del cliente', async () => {
    const tx = txCon({ 'det-1': { id: 'det-1', producto_id: 'prod-1', nota_remision_cab_id: 'rem-1' } });
    const r = await consumirSaldosRemision(tx as any, { ...ctx, items: [item()] });
    expect(r.get('det-1')).toBe('rem-1');
    expect(tx.nota_remision_det.findFirst).toHaveBeenCalledWith(
      expect.objectContaining({
        where: {
          id: 'det-1',
          nota_remision_cab: { empresa_id: 'emp-1', cliente_id: 'cli-1', estado: 'Aprobado', tipo_documento_asociado: null },
        },
      }),
    );
  });

  it('el saldo se consume con un UPDATE condicionado al disponible', async () => {
    const tx = txCon({ 'det-1': { id: 'det-1', producto_id: 'prod-1', nota_remision_cab_id: 'rem-1' } });
    await consumirSaldosRemision(tx as any, { ...ctx, items: [item()] });
    const update = tx.sql.find((q) => q.includes('UPDATE'))!;
    expect(update).toMatch(/cantidad_facturada = cantidad_facturada \+/);
    expect(update).toMatch(/dcantproser - cantidad_facturada - COALESCE\(cantidad_aplicada, 0\) >=/);
    expect(update).toMatch(/RETURNING/);
  });

  it('m-D: el saldo resta también lo aplicado por la factura de la que salió la remisión (cantidad_aplicada)', async () => {
    const tx = txCon({ 'det-1': { id: 'det-1', producto_id: 'prod-1', nota_remision_cab_id: 'rem-1' } }, []);
    await consumirSaldosRemision(tx as any, { ...ctx, items: [item()] }).catch(() => undefined);
    expect(tx.sql.find((q) => q.includes('UPDATE'))).toMatch(/dcantproser - cantidad_facturada - COALESCE\(cantidad_aplicada, 0\) >=/);
    expect(tx.sql.find((q) => q.includes('SELECT'))).toMatch(/dcantproser - cantidad_facturada - COALESCE\(cantidad_aplicada, 0\)/);
  });

  it('m-D: saldoFacturable = remisionado − facturado − aplicado por su factura de origen', () => {
    expect(saldoFacturable({ dcantproser: 10, cantidad_facturada: 4, cantidad_aplicada: 0 })).toBe(6);
    expect(saldoFacturable({ dcantproser: 849, cantidad_facturada: 0, cantidad_aplicada: 849 })).toBe(0);
    expect(saldoFacturable({ dcantproser: 5, cantidad_facturada: null, cantidad_aplicada: null })).toBe(5);
  });

  it('renglón de otra empresa (o de otro cliente): 404 sin cifras y sin escribir', async () => {
    const tx = txCon({});
    const e = await consumirSaldosRemision(tx as any, { ...ctx, items: [item()] }).catch((x) => x);
    expect(e).toBeInstanceOf(NotFoundException);
    expect(e.getResponse()).toMatchObject({ codigo: 'REMISION_ITEM_NO_ENCONTRADO' });
    expect(e.message).not.toMatch(/\d/);
    expect(tx.$queryRaw).not.toHaveBeenCalled();
  });

  it('renglón de otro producto: 404 y no se escribe (antes se vendía ese producto sin descontar su stock)', async () => {
    const tx = txCon({ 'det-1': { id: 'det-1', producto_id: 'prod-barato', nota_remision_cab_id: 'rem-1' } });
    const e = await consumirSaldosRemision(tx as any, { ...ctx, items: [item()] }).catch((x) => x);
    expect(e).toBeInstanceOf(NotFoundException);
    expect(e.getResponse()).toMatchObject({ codigo: 'REMISION_ITEM_NO_ENCONTRADO' });
    expect(tx.$queryRaw).not.toHaveBeenCalled();
  });

  it('dos facturas a la vez: la que llega sin saldo no gana el UPDATE → 409 REMISION_SALDO_INSUFICIENTE', async () => {
    const tx = txCon({ 'det-1': { id: 'det-1', producto_id: 'prod-1', nota_remision_cab_id: 'rem-1' } }, []);
    const e = await consumirSaldosRemision(tx as any, { ...ctx, items: [item()] }).catch((x) => x);
    expect(e).toBeInstanceOf(ConflictException);
    expect(e.getResponse()).toMatchObject({ codigo: 'REMISION_SALDO_INSUFICIENTE' });
  });

  it('dos ítems sobre el mismo renglón suman su cantidad y se bloquean en orden de id', async () => {
    const tx = txCon({
      'det-b': { id: 'det-b', producto_id: 'prod-1', nota_remision_cab_id: 'rem-1' },
      'det-a': { id: 'det-a', producto_id: 'prod-2', nota_remision_cab_id: 'rem-1' },
    });
    await consumirSaldosRemision(tx as any, {
      ...ctx,
      items: [
        item({ cantidad: 2, aplicaciones_remision: [{ nota_remision_det_id: 'det-b', cantidad: 2 }] }),
        item({ producto_id: 'prod-2', cantidad: 1, aplicaciones_remision: [{ nota_remision_det_id: 'det-a', cantidad: 1 }] }),
        item({ cantidad: 1, aplicaciones_remision: [{ nota_remision_det_id: 'det-b', cantidad: 1 }] }),
      ],
    });
    const ids = tx.nota_remision_det.findFirst.mock.calls.map((c: any) => c[0].where.id);
    expect(ids).toEqual(['det-a', 'det-b']);
    const valores = tx.$queryRaw.mock.calls.map((c: any) => c.slice(1));
    expect(valores[1]).toEqual(expect.arrayContaining([3, 'det-b']));
  });
});

describe('validarCantidadesRemision', () => {
  it('la cantidad del ítem tiene que ser la remisionada aplicada (si no, el excedente salía sin descontar stock)', () => {
    expect(() => validarCantidadesRemision([item({ cantidad: 50 })])).toThrow(BadRequestException);
    try {
      validarCantidadesRemision([item({ cantidad: 50 })]);
    } catch (e: any) {
      expect(e.getResponse()).toMatchObject({ codigo: 'REMISION_CANTIDAD_DISTINTA' });
    }
  });

  it('m-C: el mensaje dice lo que la pantalla permite (otra factura), no «otro ítem» (también se aplicaría a la remisión)', () => {
    const e = (() => { try { validarCantidadesRemision([item({ cantidad: 5 })]); } catch (x: any) { return x; } })();
    expect(e.getResponse().message).toMatch(/Facturá hasta lo remisionado \(3\); el resto, en otra factura\./);
    expect(e.getResponse().message).not.toMatch(/otro ítem/);
  });

  it('aplicaciones en cero no convierten un ítem en «de remisión» sin descontar stock', () => {
    expect(() => validarCantidadesRemision([item({ aplicaciones_remision: [{ nota_remision_det_id: 'det-1', cantidad: 0 }] })])).toThrow(BadRequestException);
  });

  it('igual (con tolerancia de redondeo) o sin remisión: pasa', () => {
    expect(() => validarCantidadesRemision([item(), item({ cantidad: 3.00001 }), item({ aplicaciones_remision: undefined, cantidad: 9 })])).not.toThrow();
  });
});
