import { Prisma } from '@prisma/client';
import type { LotesService } from 'src/lotes/lotes.service';

type Tx = Prisma.TransactionClient;

/**
 * Stock que devuelve una NC de venta (dentro de la transacción del alta): cada ítem con inventario que devuelve mercadería (S4: un
 * descuento o una bonificación no reponen) vuelve a su depósito (el del ítem en la factura, o el de respaldo), a los lotes de los
 * que salió y deja sus movimientos DEV_VENTA: uno por lote y uno por lo que volvió sin lote (así la anulación sabe qué lote tocar).
 *
 * Primero resuelve todos los depósitos y bloquea las filas en el orden del cierre de inventario (`bloquearStockDe`), y después
 * escribe con incremento atómico. Antes leía `stock_deposito` sin bloqueo y escribía `leído + cantidad` renglón por renglón,
 * stock antes que lotes: pisaba el conteo de un cierre (o la venta de otro) y daba 40P01 contra el cierre.
 */
export async function reponerStockNotaCredito(
  tx: Tx,
  lotes: Pick<LotesService, 'bloquearStockDe' | 'restoreFacturaDetLotes'>,
  p: {
    empresaId: string;
    ncId: string;
    numeroNC: string;
    tipoMovimientoId: string;
    items: Array<{ producto_id: string; cantidad: number }>;
    devuelvePorIndice: boolean[];
    productosMap: Map<string, { maneja_inventario?: boolean | null } | undefined>;
    depositosPorItem: Map<string, string>;
    depositoFallback: { id: string } | null;
    lotesEnabled: boolean;
    facturaDetPorProducto: Map<string, { id: string }>;
  },
): Promise<void> {
  const aReponer: Array<{ productoId: string; depositoId: string; cantidad: number }> = [];
  for (const [indice, item] of p.items.entries()) {
    if (!p.productosMap.get(item.producto_id)?.maneja_inventario || !p.devuelvePorIndice[indice]) continue;
    // Depósito: el del ítem en la factura (si sigue activo) o el de respaldo.
    const depositoItem = p.depositosPorItem.get(item.producto_id);
    const deposito =
      (depositoItem
        ? await tx.depositos.findFirst({ where: { id: depositoItem, empresa_id: p.empresaId, active: true }, select: { id: true } })
        : null) ?? p.depositoFallback;
    if (deposito) aReponer.push({ productoId: item.producto_id, depositoId: deposito.id, cantidad: Number(item.cantidad) });
  }

  await lotes.bloquearStockDe(tx, p.empresaId, aReponer.map(({ productoId, depositoId }) => ({ productoId, depositoId })));

  for (const { productoId, depositoId, cantidad } of aReponer) {
    await tx.stock_deposito.upsert({
      where: { deposito_id_producto_id: { deposito_id: depositoId, producto_id: productoId } },
      create: { deposito_id: depositoId, producto_id: productoId, cantidad_disponible: cantidad },
      update: { cantidad_disponible: { increment: cantidad }, updated_at: new Date() },
    });

    let restaurados: Array<{ lote_id: string; cantidad: number }> = [];
    const facturaDet = p.lotesEnabled ? p.facturaDetPorProducto.get(productoId) : undefined;
    if (facturaDet?.id) {
      restaurados = await lotes.restoreFacturaDetLotes(tx, { facturaDetId: facturaDet.id, depositoId, cantidad });
    }

    const enLotes = restaurados.reduce((a, r) => a + Number(r.cantidad), 0);
    const partes: Array<{ lote_id: string | null; cantidad: number }> = [
      ...restaurados.map((r) => ({ lote_id: r.lote_id, cantidad: Number(r.cantidad) })),
      ...(cantidad - enLotes > 0.0001 ? [{ lote_id: null, cantidad: cantidad - enLotes }] : []),
    ];
    for (const parte of partes) {
      await tx.movimientos_inventario.create({
        data: {
          deposito_origen_id: depositoId,
          deposito_destino_id: depositoId,
          producto_id: productoId,
          tipo_movimiento_id: p.tipoMovimientoId,
          cantidad: parte.cantidad,
          documento_origen: 'nota_credito',
          documento_id: p.ncId,
          observaciones: `Devolución NC ${p.numeroNC}`,
          lote_id: parte.lote_id,
        },
      });
    }
  }
}
