import { Prisma } from '@prisma/client';
import { liberarReservaAlFacturar, paresReservaPedido } from 'src/pedidos/reservas-pedido';
import type { LotesService } from 'src/lotes/lotes.service';
import type { FifoService } from 'src/lotes/fifo.service';

type Tx = Prisma.TransactionClient;
type ItemVenta = { producto_id: string; cantidad: number; precio_unitario?: number };

/**
 * Pares producto + depósito que la venta va a escribir (lotes y stock_deposito): los ítems con inventario que no vienen de una
 * remisión (esos ya descontaron al remisionar). Sin depósito no hay nada que bloquear.
 */
export function paresStockVenta(
  items: ItemVenta[],
  productosMap: Map<string, { maneja_inventario?: boolean | null } | undefined>,
  esItemDeRemision: (item: ItemVenta) => boolean,
  depositoId: string | null | undefined,
): Array<{ productoId: string; depositoId: string }> {
  if (!depositoId) return [];
  const productos = new Set(
    items.filter((it) => productosMap.get(it.producto_id)?.maneja_inventario && !esItemDeRemision(it)).map((it) => it.producto_id),
  );
  return [...productos].map((productoId) => ({ productoId, depositoId }));
}

/**
 * Lo primero que escribe stock en la venta: bloquea en el orden del cierre de inventario las filas que la venta va a descontar y,
 * si sale de un pedido u orden, las de su reserva; recién después suelta la reserva (`cantidad_reservada`). Antes la reserva se
 * soltaba renglón por renglón y antes del bloqueo, y se cruzaba con el cierre (40P01). Se suelta antes de validar y descontar,
 * así «estricto» no choca contra lo apartado para esta misma venta.
 */
export async function bloquearStockVenta(
  tx: Tx,
  lotes: Pick<LotesService, 'bloquearStockDe'>,
  p: {
    empresaId: string;
    items: ItemVenta[];
    productosMap: Map<string, { maneja_inventario?: boolean | null } | undefined>;
    esItemDeRemision: (item: ItemVenta) => boolean;
    depositoId: string | null | undefined;
    pedidoId: string | null | undefined;
  },
): Promise<void> {
  const pares = [
    ...paresStockVenta(p.items, p.productosMap, p.esItemDeRemision, p.depositoId),
    ...(p.pedidoId ? await paresReservaPedido(tx, p.pedidoId) : []),
  ];
  await lotes.bloquearStockDe(tx, p.empresaId, pares);
  if (p.pedidoId) {
    await liberarReservaAlFacturar(tx, {
      pedidoId: p.pedidoId,
      empresaId: p.empresaId,
      items: p.items.map((it) => ({ producto_id: it.producto_id, cantidad: it.cantidad })),
    });
  }
}

/**
 * Stock de la factura automática (`POST /facturas/automatico`, un solo producto con inventario), igual que la venta normal y en una
 * sola transacción: bloquea el par producto + depósito en el orden del cierre, descuenta lotes por FEFO si corresponde, y descuenta
 * `stock_deposito` con un decremento atómico y su movimiento VENTA. Antes solo descontaba lotes: el depósito no bajaba y, sin el
 * movimiento, anularla tampoco reponía. Devuelve lo del FEFO (o null sin lotes) para costear el renglón.
 */
export async function descontarStockFacturaAuto(
  tx: Pick<Tx, 'stock_deposito' | 'movimientos_inventario'>,
  lotes: Pick<LotesService, 'bloquearStockDe'>,
  fifo: Pick<FifoService, 'deductFifo'>,
  p: {
    empresaId: string;
    productoId: string;
    depositoId: string;
    cantidad: number;
    precioUnitario?: number;
    conLotes: boolean;
    tipoMovimientoId: string;
    facturaId: string;
    numeroFactura: string;
  },
) {
  await lotes.bloquearStockDe(tx as Tx, p.empresaId, [{ productoId: p.productoId, depositoId: p.depositoId }]);
  const fefo = p.conLotes ? await fifo.deductFifo(tx as Tx, p.empresaId, p.productoId, p.depositoId, p.cantidad) : null;
  await descontarStockDepositoVenta(tx, {
    items: [{ producto_id: p.productoId, cantidad: p.cantidad, precio_unitario: p.precioUnitario }],
    productosMap: new Map([[p.productoId, { maneja_inventario: true }]]),
    esItemDeRemision: () => false,
    depositoId: p.depositoId,
    tipoMovimientoId: p.tipoMovimientoId,
    facturaId: p.facturaId,
    numeroFactura: p.numeroFactura,
  });
  return fefo;
}

/**
 * Descuenta stock_deposito por cada ítem con inventario (no los de remisión) y deja su movimiento VENTA. Decremento atómico: el
 * valor que se escribe sale de la fila al momento de escribir, no de una lectura anterior, así que no pisa lo que otro (un cierre
 * de inventario, otra venta) confirmó en el medio. Permite negativo para no frenar la venta (política «advertencia»).
 */
export async function descontarStockDepositoVenta(
  tx: Pick<Tx, 'stock_deposito' | 'movimientos_inventario'>,
  p: {
    items: ItemVenta[];
    productosMap: Map<string, { maneja_inventario?: boolean | null } | undefined>;
    esItemDeRemision: (item: ItemVenta) => boolean;
    depositoId: string;
    tipoMovimientoId: string;
    facturaId: string;
    numeroFactura: string;
  },
): Promise<void> {
  for (const item of p.items) {
    if (p.esItemDeRemision(item)) continue;
    if (!p.productosMap.get(item.producto_id)?.maneja_inventario) continue;
    await tx.stock_deposito.upsert({
      where: { deposito_id_producto_id: { deposito_id: p.depositoId, producto_id: item.producto_id } },
      create: { deposito_id: p.depositoId, producto_id: item.producto_id, cantidad_disponible: -item.cantidad },
      update: { cantidad_disponible: { decrement: item.cantidad }, updated_at: new Date() },
    });
    await tx.movimientos_inventario.create({
      data: {
        deposito_origen_id: p.depositoId,
        producto_id: item.producto_id,
        tipo_movimiento_id: p.tipoMovimientoId,
        cantidad: item.cantidad,
        precio_unitario: item.precio_unitario,
        documento_origen: 'factura_venta',
        documento_id: p.facturaId,
        observaciones: `Venta Fact. ${p.numeroFactura}`,
      },
    });
  }
}
