import { PedidosService } from './pedidos.service';
import {
  liberarReservaAlFacturar,
  liberarReservasPedido,
  pedidoTieneReserva,
  reservaPendienteBase,
} from './reservas-pedido';

/**
 * Tx en memoria: stock_deposito por (deposito, producto) y renglones de pedido.
 * Alcanza para las reservas, que solo leen renglones y tocan cantidad_reservada.
 */
function crearTx(opts: {
  pedido?: Record<string, unknown> | null;
  renglones: Array<Record<string, unknown>>;
  stock: Record<string, { cantidad_disponible: number; cantidad_reservada: number }>;
  factura?: Record<string, unknown> | null;
  facturaDets?: Array<Record<string, unknown>>;
}) {
  const key = (w: any) => `${w.deposito_id_producto_id.deposito_id}|${w.deposito_id_producto_id.producto_id}`;
  const tx: any = {
    // Bloqueo ordenado de las filas de stock (bloquearStockOrdenado) antes de soltar la reserva.
    $queryRaw: jest.fn(async () => []),
    pedidos: {
      findFirst: jest.fn(async () => opts.pedido ?? null),
      update: jest.fn(async () => ({})),
    },
    pedido_detalle: {
      findMany: jest.fn(async () => opts.renglones.map((r) => ({ pedido: { empresa_id: 'emp-1' }, ...r }))),
      update: jest.fn(async ({ where, data }: any) => {
        const r = opts.renglones.find((x) => x.id === where.id);
        if (r) Object.assign(r, data);
        return r;
      }),
    },
    stock_deposito: {
      findUnique: jest.fn(async ({ where }: any) => opts.stock[key(where)] ?? null),
      update: jest.fn(async ({ where, data }: any) => {
        const s = opts.stock[key(where)];
        if (data.cantidad_reservada?.decrement != null) s.cantidad_reservada -= data.cantidad_reservada.decrement;
        if (data.cantidad_disponible?.decrement != null) s.cantidad_disponible -= data.cantidad_disponible.decrement;
        return s;
      }),
    },
    factura_cab: {
      findUnique: jest.fn(async () => opts.factura ?? null),
      findFirst: jest.fn(async () => opts.factura ?? null),
    },
    factura_det: { findMany: jest.fn(async () => opts.facturaDets ?? []) },
  };
  return tx;
}

describe('reservas de pedidos', () => {
  it('pedidoTieneReserva: pedido confirmado sí; orden de venta solo si reservó', () => {
    expect(pedidoTieneReserva({ tipo_pedido: 'mayorista', estado: 'confirmado' })).toBe(true);
    expect(pedidoTieneReserva({ tipo_pedido: 'mayorista', estado: 'borrador' })).toBe(false);
    expect(pedidoTieneReserva({ tipo_pedido: 'mayorista', estado: 'facturado' })).toBe(false);
    expect(pedidoTieneReserva({ tipo_pedido: 'orden_venta', estado: 'confirmado', stock_reservado: false })).toBe(false);
    expect(pedidoTieneReserva({ tipo_pedido: 'orden_venta', stock_reservado: true })).toBe(true);
  });

  it('reservaPendienteBase: lo pendiente pasado a unidades base', () => {
    expect(reservaPendienteBase({ cantidad: 2, cantidad_base: 24, cant_pendiente: null })).toBe(24);
    expect(reservaPendienteBase({ cantidad: 2, cantidad_base: 24, cant_pendiente: 1 })).toBe(12);
    expect(reservaPendienteBase({ cantidad: 2, cantidad_base: 24, cant_pendiente: 0 })).toBe(0);
  });

  it('facturar un pedido suelta toda su reserva y no toca el disponible', async () => {
    const stock = { 'd1|p1': { cantidad_disponible: 10, cantidad_reservada: 5 } };
    const tx = crearTx({
      pedido: { tipo_pedido: 'mayorista', estado: 'confirmado' },
      renglones: [{ id: 'r1', producto_id: 'p1', deposito_id: 'd1', cantidad: 3, cantidad_base: 3, cant_pendiente: null }],
      stock,
    });
    const liberado = await liberarReservaAlFacturar(tx, {
      pedidoId: 'ped-1',
      empresaId: 'emp-1',
      items: [{ producto_id: 'p1', cantidad: 3 }],
    });
    expect(liberado).toBe(3);
    expect(stock['d1|p1']).toEqual({ cantidad_disponible: 10, cantidad_reservada: 2 });
  });

  it('facturar parte de una orden de venta suelta solo lo facturado', async () => {
    const stock = {
      'd1|p1': { cantidad_disponible: 20, cantidad_reservada: 10 },
      'd1|p2': { cantidad_disponible: 20, cantidad_reservada: 4 },
    };
    const tx = crearTx({
      pedido: { tipo_pedido: 'orden_venta', estado_orden: 'aprobada', stock_reservado: true },
      renglones: [
        { id: 'r1', producto_id: 'p1', deposito_id: 'd1', cantidad: 10, cantidad_base: 10, cant_pendiente: 10 },
        { id: 'r2', producto_id: 'p2', deposito_id: 'd1', cantidad: 4, cantidad_base: 4, cant_pendiente: 4 },
      ],
      stock,
    });
    await liberarReservaAlFacturar(tx, {
      pedidoId: 'ov-1',
      empresaId: 'emp-1',
      items: [{ producto_id: 'p1', cantidad: 3 }],
    });
    expect(stock['d1|p1'].cantidad_reservada).toBe(7);
    expect(stock['d1|p2'].cantidad_reservada).toBe(4);
    expect(stock['d1|p1'].cantidad_disponible).toBe(20);
  });

  it('una orden de venta que no reservó no suelta nada (no se come reservas ajenas)', async () => {
    const stock = { 'd1|p1': { cantidad_disponible: 20, cantidad_reservada: 6 } };
    const tx = crearTx({
      pedido: { tipo_pedido: 'orden_venta', stock_reservado: false },
      renglones: [{ id: 'r1', producto_id: 'p1', deposito_id: 'd1', cantidad: 3, cantidad_base: 3, cant_pendiente: 3 }],
      stock,
    });
    expect(
      await liberarReservaAlFacturar(tx, { pedidoId: 'ov-2', empresaId: 'emp-1', items: [{ producto_id: 'p1', cantidad: 3 }] }),
    ).toBe(0);
    expect(stock['d1|p1'].cantidad_reservada).toBe(6);
  });

  it('nunca deja el reservado negativo', async () => {
    const stock = { 'd1|p1': { cantidad_disponible: 5, cantidad_reservada: 1 } };
    const tx = crearTx({
      renglones: [{ id: 'r1', producto_id: 'p1', deposito_id: 'd1', cantidad: 4, cantidad_base: 4, cant_pendiente: null }],
      stock,
    });
    expect(await liberarReservasPedido(tx, 'ped-1')).toBe(1);
    expect(stock['d1|p1'].cantidad_reservada).toBe(0);
  });
});

describe('PedidosService: facturar no descuenta stock dos veces', () => {
  function crearServicio(prismaTx: any, pedido: Record<string, unknown>) {
    const prisma: any = {
      pedidos: { findUnique: jest.fn(async () => pedido) },
      factura_cab: prismaTx.factura_cab,
      $transaction: jest.fn(async (fn: any) => fn(prismaTx)),
    };
    const service = new PedidosService(prisma, {} as any, {} as any, {} as any, {} as any);
    jest.spyOn(service as any, 'logHistorial').mockResolvedValue(undefined);
    jest.spyOn(service as any, 'findOneInternal').mockResolvedValue({});
    return service;
  }

  it('marcarFacturado con factura ajena al pedido: suelta la reserva y no resta disponible', async () => {
    const stock = { 'd1|p1': { cantidad_disponible: 7, cantidad_reservada: 3 } };
    const tx = crearTx({
      renglones: [{ id: 'r1', producto_id: 'p1', deposito_id: 'd1', cantidad: 3, cantidad_base: 3, cant_pendiente: null }],
      stock,
      factura: { dest: '001', dpunexp: '001', dnumdoc: '0000001', pedido_id: null },
    });
    const service = crearServicio(tx, { id: 'ped-1', empresa_id: 'emp-1', estado: 'confirmado' });
    await service.marcarFacturado('ped-1', 'fac-1', 'emp-1', 'u-1');
    expect(stock['d1|p1']).toEqual({ cantidad_disponible: 7, cantidad_reservada: 0 });
  });

  it('marcarFacturado con la factura que ya traía el pedido: no suelta otra vez', async () => {
    const stock = { 'd1|p1': { cantidad_disponible: 7, cantidad_reservada: 3 } };
    const tx = crearTx({
      renglones: [{ id: 'r1', producto_id: 'p1', deposito_id: 'd1', cantidad: 3, cantidad_base: 3, cant_pendiente: null }],
      stock,
      factura: { dest: '001', dpunexp: '001', dnumdoc: '0000001', pedido_id: 'ped-1' },
    });
    const service = crearServicio(tx, { id: 'ped-1', empresa_id: 'emp-1', estado: 'confirmado' });
    await service.marcarFacturado('ped-1', 'fac-1', 'emp-1', 'u-1');
    expect(stock['d1|p1']).toEqual({ cantidad_disponible: 7, cantidad_reservada: 3 });
  });

  it('facturarOrden total: suelta lo facturado, baja el pendiente y no resta disponible', async () => {
    const stock = { 'd1|p1': { cantidad_disponible: 7, cantidad_reservada: 5 } };
    const renglones = [{ id: 'r1', producto_id: 'p1', deposito_id: 'd1', cantidad: 5, cantidad_base: 5, cant_pendiente: 5 }];
    const tx = crearTx({
      renglones,
      stock,
      factura: { pedido_id: null, dest: '001', dpunexp: '001', dnumdoc: '0000002' },
      facturaDets: [{ producto_id: 'p1', dcantproser: 5 }],
    });
    const service = crearServicio(tx, {
      id: 'ov-1',
      empresa_id: 'emp-1',
      tipo_pedido: 'orden_venta',
      estado_orden: 'aprobada',
      stock_reservado: true,
    });
    await service.facturarOrden('ov-1', 'fac-2', 'emp-1', 'u-1');
    expect(stock['d1|p1']).toEqual({ cantidad_disponible: 7, cantidad_reservada: 0 });
    expect(renglones[0].cant_pendiente).toBe(0);
    expect(tx.pedidos.update).toHaveBeenCalledWith(expect.objectContaining({ data: { stock_reservado: false } }));
  });
});
