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

/**
 * Anular una factura hecha desde un pedido o una orden de venta devuelve el
 * pedido a como estaba antes de facturarse (S11).
 *
 * - Pedido (mayorista, compra asistida): la factura lo había pasado a
 *   «facturado» y había soltado toda su reserva → vuelve a «confirmado», sin
 *   factura, y vuelve a reservar lo pendiente en el depósito de cada renglón.
 * - Orden de venta: la factura había descontado lo facturado de `cant_pendiente`
 *   y, si la orden reservaba, había soltado esa parte → se devuelve lo facturado
 *   por ESTA factura a lo pendiente (nunca por encima de lo pedido), se vuelve a
 *   reservar esa misma cantidad si la orden reservaba y se recalcula el estado.
 *
 * Idempotente: la anulación local, el evento ECAN/EINU y `FacturasService.anular`
 * pueden pasar por acá más de una vez. El pedido queda bloqueado (FOR UPDATE)
 * mientras se revisa la marca:
 * - pedido: solo se revierte si sigue «facturado» con ESTA factura;
 * - orden: solo si tiene el historial de facturación de esta factura y todavía
 *   no tiene el de reversión (`ACCION_REVERSION` con el mismo `factura_id`).
 *
 * Volver a reservar escribe una fila de `stock_deposito` por renglón: antes de la primera se bloquean todas juntas en el orden del
 * cierre de inventario (`bloquearStockOrdenado`); renglón por renglón se cruzaban con el cierre (40P01).
 */

type Tx = Prisma.TransactionClient;
type Db = Pick<PrismaClient, '$transaction'>;

export const ACCION_REVERSION = 'revertido_anulacion_factura';

export type ResultadoReversionPedido =
  | { revertido: false }
  | {
      revertido: true;
      pedidoId: string;
      numeroPedido: string | null;
      tipo: 'pedido' | 'orden_venta';
      estadoAnterior: string;
      estadoNuevo: string;
      reservado: number;
      facturaNumero: string;
    };

async function reservar(tx: Tx, depositoId: string, productoId: string, cantidad: number): Promise<number> {
  if (!(cantidad > 0)) return 0;
  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: 0, cantidad_reservada: cantidad },
    update: { cantidad_reservada: { increment: cantidad }, updated_at: new Date() },
  });
  return cantidad;
}

function filtroFactura(facturaId: string) {
  return { path: ['factura_id'], equals: facturaId } as Prisma.JsonNullableFilter<'pedido_historial'>;
}

/**
 * Si la orden reservaba al facturarse con esta factura. Facturar la orden entera
 * pone `stock_reservado = false` (ya no queda nada apartado), así que se mira la
 * marca `reservaba` que deja `facturarOrden` en el historial; las facturaciones
 * anteriores a esa marca usan la configuración de la sucursal.
 */
async function ordenReservaba(
  tx: Tx,
  orden: { stock_reservado: boolean | null; sucursal_id: string | null },
  historialFacturacion: { datos: Prisma.JsonValue } | null,
): Promise<boolean> {
  if (orden.stock_reservado === true) return true;
  const datos = (historialFacturacion?.datos ?? null) as Record<string, unknown> | null;
  if (datos && typeof datos.reservaba === 'boolean') return datos.reservaba;
  if (!orden.sucursal_id) return false;
  const sucursal = await tx.empresas_sucursales.findUnique({
    where: { id: orden.sucursal_id },
    select: { config: true },
  });
  return (sucursal?.config as Record<string, unknown> | null)?.orden_reserva_stock === true;
}

async function revertirPedido(
  tx: Tx,
  pedido: { id: string; estado: string; numero_pedido: string | null },
  facturaId: string,
  facturaNumero: string,
  empresaId: string,
): Promise<ResultadoReversionPedido> {
  const estadoAnterior = pedido.estado;
  const renglones = await tx.pedido_detalle.findMany({
    where: { pedido_id: pedido.id, deposito_id: { not: null }, producto: { maneja_inventario: true } },
    select: { producto_id: true, deposito_id: true, cantidad: true, cantidad_base: true, cant_pendiente: true },
    orderBy: { created_at: 'asc' },
  });
  await bloquearStockOrdenado(
    tx,
    empresaId,
    renglones.map((r) => ({ productoId: r.producto_id, depositoId: r.deposito_id as string })),
  );
  let reservado = 0;
  for (const r of renglones) {
    const base = Number(r.cantidad_base ?? 0);
    const cantidad = Number(r.cantidad ?? 0);
    const pendiente =
      r.cant_pendiente == null ? base : Number(r.cant_pendiente) * (cantidad > 0 ? base / cantidad : 1);
    reservado += await reservar(tx, r.deposito_id as string, r.producto_id, Math.max(0, pendiente));
  }
  await tx.pedidos.update({
    where: { id: pedido.id },
    data: { estado: 'confirmado', factura_id: null, updated_at: new Date() },
  });
  await tx.pedido_historial.create({
    data: {
      pedido_id: pedido.id,
      accion: ACCION_REVERSION,
      descripcion: `Vuelve a «confirmado» por la anulación de la factura ${facturaNumero}`,
      datos: { factura_id: facturaId, factura_numero: facturaNumero, estado_anterior: estadoAnterior, reservado },
    },
  });
  return {
    revertido: true,
    pedidoId: pedido.id,
    numeroPedido: pedido.numero_pedido,
    tipo: 'pedido',
    estadoAnterior,
    estadoNuevo: 'confirmado',
    reservado,
    facturaNumero,
  };
}

async function revertirOrden(
  tx: Tx,
  orden: {
    id: string;
    estado_orden: string | null;
    numero_pedido: string | null;
    stock_reservado: boolean | null;
    sucursal_id: string | null;
  },
  facturaId: string,
  facturaNumero: string,
  empresaId: string,
): Promise<ResultadoReversionPedido> {
  const estadoAnterior = String(orden.estado_orden ?? '');
  const historial = await tx.pedido_historial.findMany({
    where: { pedido_id: orden.id, datos: filtroFactura(facturaId) },
    select: { accion: true, datos: true },
    orderBy: { created_at: 'asc' },
  });
  if (historial.some((h) => h.accion === ACCION_REVERSION)) return { revertido: false };
  // Sin historial de facturación con esta factura, la orden nunca la descontó.
  const facturacion = historial.find((h) => h.accion === 'facturada' || h.accion === 'facturada_parcial') ?? null;
  if (!facturacion) return { revertido: false };

  const reservaba = await ordenReservaba(tx, orden, facturacion);

  const facturaDets = await tx.factura_det.findMany({
    where: { factura_cab_id: facturaId },
    select: { producto_id: true, dcantproser: true },
  });
  const renglones = await tx.pedido_detalle.findMany({
    where: { pedido_id: orden.id },
    select: {
      id: true,
      producto_id: true,
      deposito_id: true,
      cantidad: true,
      cantidad_base: true,
      cant_pendiente: true,
      producto: { select: { maneja_inventario: true } },
    },
    orderBy: { created_at: 'asc' },
  });
  if (reservaba) {
    await bloquearStockOrdenado(
      tx,
      empresaId,
      renglones
        .filter((r) => r.deposito_id && r.producto?.maneja_inventario)
        .map((r) => ({ productoId: r.producto_id, depositoId: r.deposito_id as string })),
    );
  }

  let reservado = 0;
  for (const fd of facturaDets) {
    let resta = Number(fd.dcantproser ?? 0);
    for (const r of renglones) {
      if (!(resta > 0)) break;
      if (r.producto_id !== fd.producto_id) continue;
      const cantidad = Number(r.cantidad ?? 0);
      const pendiente = r.cant_pendiente != null ? Number(r.cant_pendiente) : cantidad;
      // Nunca más que lo pedido: lo que se devuelve es lo que esta factura había descontado.
      const vuelve = Math.min(resta, Math.max(0, cantidad - pendiente));
      if (!(vuelve > 0)) continue;
      resta -= vuelve;
      r.cant_pendiente = new Prisma.Decimal(pendiente + vuelve);
      await tx.pedido_detalle.update({ where: { id: r.id }, data: { cant_pendiente: pendiente + vuelve } });
      if (reservaba && r.deposito_id && r.producto?.maneja_inventario) {
        const factor = cantidad > 0 ? Number(r.cantidad_base ?? 0) / cantidad : 1;
        reservado += await reservar(tx, r.deposito_id, r.producto_id, vuelve * factor);
      }
    }
  }

  const todoPendiente = renglones.every(
    (r) => (r.cant_pendiente != null ? Number(r.cant_pendiente) : Number(r.cantidad)) >= Number(r.cantidad),
  );
  let estadoNuevo = 'facturada_parcial';
  if (todoPendiente) {
    // El estado desde el que se facturó: «aprobada» o, si se la aprobó o inició a mano, «en_proceso».
    const enProceso = await tx.pedido_historial.count({
      where: { pedido_id: orden.id, accion: { in: ['aprobada', 'en_proceso'] } },
    });
    estadoNuevo = enProceso > 0 ? 'en_proceso' : 'aprobada';
  }

  await tx.pedidos.update({
    where: { id: orden.id },
    data: {
      estado_orden: estadoNuevo as Prisma.pedidosUpdateInput['estado_orden'],
      ...(reservaba ? { stock_reservado: true } : {}),
      updated_at: new Date(),
    },
  });
  await tx.pedido_historial.create({
    data: {
      pedido_id: orden.id,
      accion: ACCION_REVERSION,
      descripcion: `Vuelve a «${estadoNuevo}» por la anulación de la factura ${facturaNumero}`,
      datos: {
        factura_id: facturaId,
        factura_numero: facturaNumero,
        estado_anterior: estadoAnterior,
        reservado,
      },
    },
  });
  return {
    revertido: true,
    pedidoId: orden.id,
    numeroPedido: orden.numero_pedido,
    tipo: 'orden_venta',
    estadoAnterior,
    estadoNuevo,
    reservado,
    facturaNumero,
  };
}

/** Punto único: lo llama `MiddlewareSifenService` en todos los caminos de anulación. */
export async function revertirPedidoPorAnulacionFactura(
  db: Db,
  facturaId: string,
  empresaId: string,
): Promise<ResultadoReversionPedido> {
  return db.$transaction(async (tx) => {
    const factura = await tx.factura_cab.findFirst({
      where: { id: facturaId, empresa_id: empresaId },
      select: { pedido_id: true, dest: true, dpunexp: true, dnumdoc: true },
    });
    if (!factura) return { revertido: false };
    // El pedido puede venir por la factura (`pedido_id`) o haberse marcado
    // facturado con ella después (`pedidos.factura_id`, «Marcar facturado»).
    const candidato = await tx.pedidos.findFirst({
      where: {
        empresa_id: empresaId,
        OR: [...(factura.pedido_id ? [{ id: factura.pedido_id }] : []), { factura_id: facturaId }],
      },
      select: { id: true },
    });
    if (!candidato) return { revertido: false };
    await tx.$queryRaw`SELECT id FROM pedidos WHERE id = ${candidato.id}::uuid FOR UPDATE`;
    const pedido = await tx.pedidos.findUnique({
      where: { id: candidato.id },
      select: {
        id: true,
        tipo_pedido: true,
        estado: true,
        estado_orden: true,
        factura_id: true,
        numero_pedido: true,
        stock_reservado: true,
        sucursal_id: true,
      },
    });
    if (!pedido) return { revertido: false };
    const facturaNumero = `${factura.dest}-${factura.dpunexp}-${factura.dnumdoc}`;

    if (pedido.tipo_pedido === 'orden_venta') {
      return revertirOrden(tx, { ...pedido, estado_orden: pedido.estado_orden as string | null }, facturaId, facturaNumero, empresaId);
    }
    if (pedido.estado !== 'facturado' || pedido.factura_id !== facturaId) return { revertido: false };
    return revertirPedido(tx, pedido, facturaId, facturaNumero, empresaId);
  });
}
