import { MiddlewareSifenService } from './middleware-sifen.service';

/**
 * Anular una factura reponía el stock dos veces: `anularFactura` lo devolvía en su
 * propia transacción y después `revertirFacturaAnulada` lo volvía a devolver (con
 * SIFEN, `esperarYConsultarEstado` y `anularFactura` también llamaban los dos).
 *
 * Caso real (local, 24/10/2026): factura 001-002-0000010 de 1 juego de tazas.
 * Stock 16 → venta 15 → anulación 17, con dos movimientos de entrada.
 *
 * Ahora la reversión mira lo que la venta descontó de verdad (sus movimientos
 * «Venta Fact.») menos lo que ya se repuso, así que es idempotente y una factura
 * hecha desde remisiones (que no descontó) no repone nada.
 */
describe('MiddlewareSifenService — revertirStockFactura es idempotente', () => {
  type Mov = { deposito_origen_id: string; producto_id: string; cantidad: number; documento_origen: string; documento_id: string; observaciones: string; tipo_movimiento_id?: string };

  const crear = (opciones: { movimientos?: Mov[]; detalles?: any[]; lotes?: boolean; ncs?: string[] } = {}) => {
    const stock = new Map<string, number>([['dep-1|prod-1', 15]]);
    const movimientos: Mov[] = [...(opciones.movimientos ?? [])];
    const service = Object.create(MiddlewareSifenService.prototype) as any;
    service.logger = { log: jest.fn(), warn: jest.fn(), error: jest.fn(), debug: jest.fn() };
    service.lotesService = {
      isEnabledForEmpresa: jest.fn().mockResolvedValue(!!opciones.lotes),
      restoreFacturaDetLotes: jest.fn().mockResolvedValue(undefined),
      bloquearStockDe: jest.fn().mockResolvedValue(undefined),
    };
    service.prisma = {
      // Una sola transacción: el mock le pasa el mismo cliente.
      $transaction: jest.fn(async (fn: any) => fn(service.prisma)),
      factura_det: {
        findMany: jest.fn().mockResolvedValue(
          opciones.detalles ?? [{ id: 'det-1', producto_id: 'prod-1', deposito_id: null, dcantproser: 1, productos: { maneja_inventario: true } }],
        ),
      },
      factura_cab: { findUnique: jest.fn().mockResolvedValue({ dest: '001', dpunexp: '002', dnumdoc: '0000010' }) },
      tipo_movimiento_inventario: {
        findUnique: jest.fn().mockResolvedValue({ id: 'tipo-anul-venta' }),
        findMany: jest.fn().mockResolvedValue([
          { id: 'tipo-dev', codigo: 'DEV_VENTA' },
          { id: 'tipo-anul-dev', codigo: 'ANUL_DEV_VENTA' },
        ]),
      },
      nota_credito_cab: { findMany: jest.fn().mockResolvedValue((opciones.ncs ?? []).map((id) => ({ id }))) },
      depositos: { findFirst: jest.fn().mockResolvedValue({ sucursal_id: 'suc-1' }) },
      movimientos_inventario: {
        findMany: jest.fn(async ({ where }: any) =>
          movimientos.filter((m) =>
            typeof where.documento_origen === 'string'
              ? m.documento_origen === where.documento_origen && where.documento_id.in.includes(m.documento_id)
              : m.documento_id === where.documento_id && where.documento_origen.in.includes(m.documento_origen),
          ),
        ),
        create: jest.fn(async ({ data }: any) => {
          movimientos.push({ ...data, documento_id: data.documento_id });
          return data;
        }),
      },
      stock_deposito: {
        upsert: jest.fn(async ({ where, create, update }: any) => {
          const clave = `${where.deposito_id_producto_id.deposito_id}|${where.deposito_id_producto_id.producto_id}`;
          const actual = stock.get(clave);
          stock.set(clave, actual === undefined ? create.cantidad_disponible : actual + update.cantidad_disponible.increment);
        }),
      },
    };
    return { service, stock, movimientos };
  };

  const venta: Mov = {
    deposito_origen_id: 'dep-1',
    producto_id: 'prod-1',
    cantidad: 1,
    documento_origen: 'factura_venta',
    documento_id: 'fac-1',
    observaciones: 'Venta Fact. 001-002-0000010',
  };

  it('repone lo vendido una sola vez aunque se llame dos veces', async () => {
    const { service, stock, movimientos } = crear({ movimientos: [venta] });

    await service.revertirStockFactura('fac-1', 'emp-1');
    await service.revertirStockFactura('fac-1', 'emp-1');

    expect(stock.get('dep-1|prod-1')).toBe(16);
    const reposiciones = movimientos.filter((m) => m.documento_origen === 'anulacion_factura');
    expect(reposiciones).toHaveLength(1);
    expect(reposiciones[0]).toMatchObject({ deposito_origen_id: 'dep-1', producto_id: 'prod-1', cantidad: 1 });
  });

  it('no repone si ya había una reversión vieja («Reversión stock por cancelación»)', async () => {
    const vieja: Mov = { ...venta, observaciones: 'Reversión stock por cancelación Fact. 001-002-0000010' };
    const { service, stock } = crear({ movimientos: [venta, vieja] });

    await service.revertirStockFactura('fac-1', 'emp-1');

    expect(stock.get('dep-1|prod-1')).toBe(15);
  });

  it('una factura sin movimiento de venta (hecha desde remisiones) no repone nada', async () => {
    const { service, stock, movimientos } = crear({ movimientos: [] });

    await service.revertirStockFactura('fac-1', 'emp-1');

    expect(stock.get('dep-1|prod-1')).toBe(15);
    expect(movimientos).toHaveLength(0);
  });

  it('repone en el depósito del que salió la venta, no en el principal', async () => {
    const { service, stock } = crear({ movimientos: [{ ...venta, deposito_origen_id: 'dep-2', cantidad: 3 }] });

    await service.revertirStockFactura('fac-1', 'emp-1');

    expect(stock.get('dep-2|prod-1')).toBe(3);
    expect(stock.get('dep-1|prod-1')).toBe(15);
  });

  it('devuelve los lotes solo la primera vez', async () => {
    const { service } = crear({ movimientos: [venta], lotes: true });

    await service.revertirStockFactura('fac-1', 'emp-1');
    await service.revertirStockFactura('fac-1', 'emp-1');

    expect(service.lotesService.restoreFacturaDetLotes).toHaveBeenCalledTimes(1);
    expect(service.lotesService.restoreFacturaDetLotes).toHaveBeenCalledWith(service.prisma, {
      facturaDetId: 'det-1',
      depositoId: 'dep-1',
      cantidad: 1,
    });
  });

  it('no repone lo que ya volvió por una NC de devolución vigente (sí lo de una NC anulada)', async () => {
    const vendido: Mov = { ...venta, cantidad: 4 };
    const devNC1: Mov = { deposito_origen_id: 'dep-1', producto_id: 'prod-1', cantidad: 2, documento_origen: 'nota_credito', documento_id: 'nc-1', observaciones: 'Devolución NC', tipo_movimiento_id: 'tipo-dev' };
    const devNC2: Mov = { ...devNC1, documento_id: 'nc-2', cantidad: 1 };
    const anulNC2: Mov = { ...devNC2, tipo_movimiento_id: 'tipo-anul-dev', observaciones: 'Reversión stock por cancelación NC' };
    const { service, stock, movimientos } = crear({ movimientos: [vendido, devNC1, devNC2, anulNC2], ncs: ['nc-1', 'nc-2'] });

    await service.revertirStockFactura('fac-1', 'emp-1');

    // Vendió 4, la NC 1 devolvió 2 (vigente) y la NC 2 devolvió 1 pero se anuló: se reponen 2.
    expect(stock.get('dep-1|prod-1')).toBe(17);
    expect(movimientos.filter((m) => m.documento_origen === 'anulacion_factura')[0]).toMatchObject({ cantidad: 2 });
  });

  /**
   * Ola 3: antes cada escritura confirmaba sola (sin transacción) y el lote se reponía con un absoluto leído sin bloqueo: otra venta
   * del mismo lote en el medio se perdía (3/3 en real, `anular-factura-lote-pisado`). Ahora todo va en una transacción que bloquea
   * en el orden del cierre antes de escribir y recién después calcula lo pendiente (dos anulaciones a la vez no reponen dos veces).
   */
  it('una sola transacción: bloquea los pares de la venta antes de calcular lo pendiente y de escribir', async () => {
    const { service } = crear({ movimientos: [venta, { ...venta, producto_id: 'prod-0' }], lotes: true });
    await service.revertirStockFactura('fac-1', 'emp-1');
    expect(service.prisma.$transaction).toHaveBeenCalledTimes(1);
    const bloquear = service.lotesService.bloquearStockDe;
    expect(bloquear).toHaveBeenCalledWith(service.prisma, 'emp-1', [
      { productoId: 'prod-1', depositoId: 'dep-1' },
      { productoId: 'prod-0', depositoId: 'dep-1' },
    ]);
    const orden = (f: jest.Mock) => f.mock.invocationCallOrder;
    // Lo pendiente se calcula con los movimientos leídos DESPUÉS del bloqueo (la segunda lectura).
    expect(orden(bloquear)[0]).toBeLessThan(orden(service.prisma.movimientos_inventario.findMany).at(-1));
    expect(orden(bloquear)[0]).toBeLessThan(orden(service.prisma.stock_deposito.upsert)[0]);
    expect(orden(bloquear)[0]).toBeLessThan(orden(service.lotesService.restoreFacturaDetLotes)[0]);
  });

  it('si las NC ya devolvieron todo, la anulación no repone nada', async () => {
    const devTotal: Mov = { deposito_origen_id: 'dep-1', producto_id: 'prod-1', cantidad: 1, documento_origen: 'nota_credito', documento_id: 'nc-1', observaciones: 'Devolución NC', tipo_movimiento_id: 'tipo-dev' };
    const { service, stock } = crear({ movimientos: [venta, devTotal], ncs: ['nc-1'] });

    await service.revertirStockFactura('fac-1', 'emp-1');

    expect(stock.get('dep-1|prod-1')).toBe(15);
  });
});

describe('MiddlewareSifenService — revertirStockNC (anular una NC de venta)', () => {
  const crearNC = () => {
    const service = Object.create(MiddlewareSifenService.prototype) as any;
    service.logger = { log: jest.fn(), warn: jest.fn(), error: jest.fn(), debug: jest.fn() };
    service.lotesService = { bloquearStockDe: jest.fn().mockResolvedValue(undefined) };
    service.prisma = {
      $transaction: jest.fn(async (fn: any) => fn(service.prisma)),
      $queryRaw: jest.fn().mockResolvedValue([{ id: 'nc-1' }]),
      nota_credito_cab: { findUnique: jest.fn().mockResolvedValue({ dest: '001', dpunexp: '001', dnumdoc: '0000009', factura_cab_id: 'fac-1' }) },
      nota_credito_det: {
        findMany: jest.fn().mockResolvedValue([
          { producto_id: 'p-b', deposito_id: 'dep-1', dcantproser: 1, devuelve_mercaderia: true, productos: { maneja_inventario: true } },
          { producto_id: 'p-a', deposito_id: null, dcantproser: 2, devuelve_mercaderia: true, productos: { maneja_inventario: true } },
          { producto_id: 'p-c', deposito_id: 'dep-1', dcantproser: 1, devuelve_mercaderia: false, productos: { maneja_inventario: true } },
        ]),
      },
      factura_det: { findMany: jest.fn().mockResolvedValue([{ producto_id: 'p-a', deposito_id: 'dep-2' }]) },
      depositos: { findFirst: jest.fn().mockResolvedValue({ id: 'dep-principal' }) },
      tipo_movimiento_inventario: { findUnique: jest.fn().mockResolvedValue({ id: 'tipo-x' }) },
      movimientos_inventario: {
        findMany: jest.fn().mockResolvedValue([{ lote_id: 'lote-1', deposito_origen_id: 'dep-1', producto_id: 'p-l', cantidad: 1 }]),
        count: jest.fn().mockResolvedValue(0),
        create: jest.fn(),
      },
      stock_lote: { findUnique: jest.fn().mockResolvedValue({ id: 'sl-1', cantidad_disponible: 5 }), update: jest.fn() },
      lotes_producto: { update: jest.fn() },
      factura_det_lote: { findMany: jest.fn().mockResolvedValue([]), update: jest.fn() },
      stock_deposito: { upsert: jest.fn() },
    };
    return service;
  };

  it('una sola transacción: bloquea líneas y lotes de la NC antes de sacar del lote y del depósito', async () => {
    const service = crearNC();
    await service.revertirStockNC('nc-1', 'emp-1');
    expect(service.prisma.$transaction).toHaveBeenCalledTimes(1);
    const bloquear = service.lotesService.bloquearStockDe;
    expect(bloquear).toHaveBeenCalledTimes(1);
    expect(bloquear).toHaveBeenCalledWith(service.prisma, 'emp-1', [
      { productoId: 'p-b', depositoId: 'dep-1' },
      { productoId: 'p-a', depositoId: 'dep-2' },
      { productoId: 'p-l', depositoId: 'dep-1' },
    ]);
    const orden = (f: jest.Mock) => f.mock.invocationCallOrder[0];
    expect(orden(bloquear)).toBeLessThan(orden(service.prisma.stock_lote.update));
    expect(orden(bloquear)).toBeLessThan(orden(service.prisma.stock_deposito.upsert));
    // Lo de siempre: decremento atómico en el depósito de cada línea y un movimiento con la observación del camino.
    expect(service.prisma.stock_deposito.upsert.mock.calls.map((c: any[]) => [c[0].where.deposito_id_producto_id, c[0].update.cantidad_disponible])).toEqual([
      [{ deposito_id: 'dep-1', producto_id: 'p-b' }, { decrement: 1 }],
      [{ deposito_id: 'dep-2', producto_id: 'p-a' }, { decrement: 2 }],
    ]);
    expect(service.prisma.movimientos_inventario.create.mock.calls[0][0].data.observaciones).toBe('Reversión stock por cancelación NC 001-001-0000009');
  });

  it('el evento SIFEN de la NC usa el mismo camino, con su observación', async () => {
    const service = crearNC();
    await service.revertirStockNC('nc-1', 'emp-1', 'Reversión stock NC por EINU aprobado');
    expect(service.prisma.movimientos_inventario.create.mock.calls[0][0].data.observaciones).toBe('Reversión stock NC por EINU aprobado');
  });
});

describe('MiddlewareSifenService — revertirLotesDevolucionNC', () => {
  it('saca del lote lo que devolvió la NC y baja cantidad_restaurada del consumo de la factura', async () => {
    const service = Object.create(MiddlewareSifenService.prototype) as any;
    const updatesConsumo: any[] = [];
    service.prisma = {
      tipo_movimiento_inventario: { findUnique: jest.fn().mockResolvedValue({ id: 'tipo-dev' }) },
      nota_credito_cab: { findUnique: jest.fn().mockResolvedValue({ factura_cab_id: 'fac-1' }) },
      movimientos_inventario: {
        findMany: jest.fn().mockResolvedValue([{ lote_id: 'lote-1', deposito_origen_id: 'dep-1', cantidad: 2 }]),
      },
      stock_lote: {
        findUnique: jest.fn().mockResolvedValue({ id: 'sl-1', cantidad_disponible: 5 }),
        update: jest.fn(),
      },
      lotes_producto: { update: jest.fn() },
      factura_det_lote: {
        findMany: jest.fn().mockResolvedValue([
          { id: 'fdl-1', cantidad_restaurada: 1 },
          { id: 'fdl-2', cantidad_restaurada: 3 },
        ]),
        update: jest.fn(async (args: any) => updatesConsumo.push(args)),
      },
    };

    await service.revertirLotesDevolucionNC('nc-1', service.prisma);

    expect(service.prisma.stock_lote.update).toHaveBeenCalledWith(
      expect.objectContaining({ data: expect.objectContaining({ cantidad_disponible: 3 }) }),
    );
    expect(service.prisma.factura_det_lote.findMany).toHaveBeenCalledWith(
      expect.objectContaining({ where: expect.objectContaining({ lote_id: 'lote-1', factura_det: { factura_cab_id: 'fac-1' } }) }),
    );
    expect(updatesConsumo).toEqual([
      { where: { id: 'fdl-1' }, data: { cantidad_restaurada: { decrement: 1 } } },
      { where: { id: 'fdl-2' }, data: { cantidad_restaurada: { decrement: 1 } } },
    ]);
  });
});
