import { Prisma } from '@prisma/client';
import { bloquearStockOrdenado, ParStock } from 'src/lotes/bloqueo-stock';

/**
 * Reservas de stock de pedidos y órdenes de venta.
 *
 * Vive fuera de PedidosService porque la usa también FacturasService, dentro
 * de la transacción de la factura: inyectar PedidosService ahí cerraría un
 * círculo (OrdenFacturacionService ya depende de los dos).
 *
 * Regla: un renglón reserva, en `stock_deposito.cantidad_reservada` de SU
 * depósito (`pedido_detalle.deposito_id`), lo que todavía falta facturar. La
 * reserva NO descuenta stock: el descuento real (con movimiento de inventario)
 * lo hace siempre la factura. Al facturar solo se suelta la reserva.
 *
 * Bloqueos: reservar o soltar varios renglones escribe varias filas de `stock_deposito`. Antes de la primera escritura se toman
 * todas juntas con `bloquearStockOrdenado` (orden del cierre de inventario); renglón por renglón se cruzaban con el cierre (40P01).
 */

type Tx = Prisma.TransactionClient;

type RenglonReserva = {
  cantidad: Prisma.Decimal | number | null;
  cantidad_base: Prisma.Decimal | number | null;
  cant_pendiente: Prisma.Decimal | number | null;
};

/** Si el pedido tiene stock reservado hoy. Misma regla que la migración de recálculo. */
export function pedidoTieneReserva(pedido: {
  tipo_pedido?: string | null;
  estado?: string | null;
  estado_orden?: string | null;
  stock_reservado?: boolean | null;
}): boolean {
  if (pedido.tipo_pedido === 'orden_venta') {
    return pedido.stock_reservado === true;
  }
  return pedido.estado === 'confirmado';
}

/** Cantidad base todavía reservada de un renglón: lo pendiente de facturar. */
export function reservaPendienteBase(item: RenglonReserva): number {
  const base = Number(item.cantidad_base ?? 0);
  if (item.cant_pendiente == null) return Math.max(0, base);
  const cantidad = Number(item.cantidad ?? 0);
  const factor = cantidad > 0 ? base / cantidad : 1;
  return Math.max(0, Number(item.cant_pendiente) * factor);
}

async function soltar(tx: Tx, depositoId: string, productoId: string, cantidad: number): Promise<number> {
  if (!(cantidad > 0)) return 0;
  const stock = await tx.stock_deposito.findUnique({
    where: { deposito_id_producto_id: { deposito_id: depositoId, producto_id: productoId } },
    select: { cantidad_reservada: true },
  });
  if (!stock) return 0;
  // Nunca por debajo de cero: si la fila ya estaba descuadrada, se suelta lo que hay.
  const liberar = Math.min(cantidad, Number(stock.cantidad_reservada));
  if (liberar > 0) {
    await tx.stock_deposito.update({
      where: { deposito_id_producto_id: { deposito_id: depositoId, producto_id: productoId } },
      data: { cantidad_reservada: { decrement: liberar }, updated_at: new Date() },
    });
  }
  return liberar;
}

async function renglonesConReserva(tx: Tx, pedidoId: string) {
  return tx.pedido_detalle.findMany({
    where: { pedido_id: pedidoId, deposito_id: { not: null }, producto: { maneja_inventario: true } },
    select: {
      id: true,
      producto_id: true,
      deposito_id: true,
      cantidad: true,
      cantidad_base: true,
      cant_pendiente: true,
      pedido: { select: { empresa_id: true } },
    },
    orderBy: { created_at: 'asc' },
  });
}

const paresDe = (renglones: Array<{ producto_id: string; deposito_id: string | null }>): ParStock[] =>
  renglones.map((r) => ({ productoId: r.producto_id, depositoId: r.deposito_id as string }));

/** Las filas de `stock_deposito` que tocan las reservas del pedido: la venta las suma a lo que bloquea antes de soltarlas. */
export async function paresReservaPedido(tx: Tx, pedidoId: string): Promise<ParStock[]> {
  return paresDe(await renglonesConReserva(tx, pedidoId));
}

/** Los renglones que reservan, con sus filas de stock ya bloqueadas en el orden del cierre. */
async function renglonesBloqueados(tx: Tx, pedidoId: string) {
  const renglones = await renglonesConReserva(tx, pedidoId);
  if (renglones.length) await bloquearStockOrdenado(tx, renglones[0].pedido.empresa_id, paresDe(renglones));
  return renglones;
}

/** Suelta la reserva de un renglón (antes de borrarlo o cambiarle la cantidad). */
export async function liberarReservaRenglon(
  tx: Tx,
  item: RenglonReserva & { producto_id: string; deposito_id: string | null },
): Promise<number> {
  if (!item.deposito_id) return 0;
  return soltar(tx, item.deposito_id, item.producto_id, reservaPendienteBase(item));
}

/** Suelta todo lo que el pedido tiene reservado (cancelar, vencer, facturar el pedido entero). */
export async function liberarReservasPedido(tx: Tx, pedidoId: string): Promise<number> {
  let total = 0;
  for (const item of await renglonesBloqueados(tx, pedidoId)) {
    total += await soltar(tx, item.deposito_id as string, item.producto_id, reservaPendienteBase(item));
  }
  return total;
}

/**
 * Suelta solo la parte facturada (orden de venta facturada en partes).
 * `facturado` va en las unidades del renglón del pedido (`cantidad`), igual
 * que descuenta `cant_pendiente`. Se llama ANTES de bajar `cant_pendiente`.
 */
export async function liberarReservasFacturadas(
  tx: Tx,
  pedidoId: string,
  facturado: Array<{ producto_id: string | null; cantidad: Prisma.Decimal | number | null }>,
): Promise<number> {
  const porProducto = new Map<string, number>();
  for (const f of facturado) {
    if (!f.producto_id) continue;
    porProducto.set(f.producto_id, (porProducto.get(f.producto_id) ?? 0) + Number(f.cantidad ?? 0));
  }
  let total = 0;
  for (const item of await renglonesBloqueados(tx, pedidoId)) {
    const resta = porProducto.get(item.producto_id) ?? 0;
    if (!(resta > 0)) continue;
    const cantidad = Number(item.cantidad ?? 0);
    const factor = cantidad > 0 ? Number(item.cantidad_base ?? 0) / cantidad : 1;
    const pendiente = item.cant_pendiente != null ? Number(item.cant_pendiente) : cantidad;
    const usa = Math.min(resta, Math.max(0, pendiente));
    porProducto.set(item.producto_id, resta - usa);
    total += await soltar(tx, item.deposito_id as string, item.producto_id, usa * factor);
  }
  return total;
}

/**
 * Lo llama FacturasService dentro de su transacción cuando la factura trae
 * `pedido_id`, antes de validar y descontar stock: así la política "estricto"
 * no choca contra la reserva del mismo pedido que se está facturando.
 * - Pedido (mayorista, compra asistida): la factura lo cierra entero → suelta todo.
 * - Orden de venta: suelta solo lo que esta factura factura.
 */
export async function liberarReservaAlFacturar(
  tx: Tx,
  args: {
    pedidoId: string;
    empresaId: string;
    items: Array<{ producto_id: string | null; cantidad: Prisma.Decimal | number | null }>;
  },
): Promise<number> {
  const pedido = await tx.pedidos.findFirst({
    where: { id: args.pedidoId, empresa_id: args.empresaId, active: true },
    select: { tipo_pedido: true, estado: true, estado_orden: true, stock_reservado: true },
  });
  if (!pedido || !pedidoTieneReserva(pedido)) return 0;
  if (pedido.tipo_pedido === 'orden_venta') {
    return liberarReservasFacturadas(tx, args.pedidoId, args.items);
  }
  return liberarReservasPedido(tx, args.pedidoId);
}
