import type { Prisma } from '@prisma/client';
import { conflicto, noEncontrado, solicitudInvalida } from 'src/common/utils/error-estructurado';

/** Tolerancia de redondeo de las cantidades (numeric(14,4)). */
const EPS = 0.0001;

type ItemConRemision = {
  producto_id: string;
  descripcion?: string | null;
  cantidad: number;
  aplicaciones_remision?: Array<{ nota_remision_det_id: string; cantidad: number }> | null;
};

/**
 * Lo que queda por facturar de un renglón de remisión: lo remisionado menos lo ya facturado desde la remisión
 * (`cantidad_facturada`) y menos lo que cubre la factura de la que salió la remisión (`cantidad_aplicada`, remisión hecha
 * desde factura: esa mercadería ya está facturada y la remisión no descontó stock). Es la misma regla que el UPDATE de
 * `consumirSaldosRemision`.
 */
export function saldoFacturable(d: { dcantproser: unknown; cantidad_facturada?: unknown; cantidad_aplicada?: unknown }): number {
  return Number(d.dcantproser) - Number(d.cantidad_facturada ?? 0) - Number(d.cantidad_aplicada ?? 0);
}

const aplicacionesDe = (item: ItemConRemision) => (item.aplicaciones_remision ?? []).filter((a) => Number(a.cantidad || 0) > 0);

/**
 * Un ítem que sale de remisiones no descuenta stock (ya lo descontó la remisión), así que su cantidad tiene que ser la
 * remisionada que aplica: si fuera mayor, el excedente salía sin descontar stock. La pantalla ya topea la cantidad a lo
 * remisionado (`maxRemision`); esto lo exige también al que llama a la API.
 */
export function validarCantidadesRemision(items: ItemConRemision[]): void {
  for (const item of items) {
    // Cualquier aplicación (aunque sea de cantidad 0) hace que el ítem no descuente stock (`esItemDeRemision`): se mide igual.
    if (!item.aplicaciones_remision?.length) continue;
    const aplicada = aplicacionesDe(item).reduce((s, a) => s + Number(a.cantidad), 0);
    if (Math.abs(aplicada - Number(item.cantidad || 0)) > EPS) {
      throw solicitudInvalida({
        message: `La cantidad de "${item.descripcion ?? 'un ítem'}" (${Number(item.cantidad)}) no coincide con lo remisionado que aplica (${aplicada}). Facturá hasta lo remisionado (${aplicada}); el resto, en otra factura.`,
        codigo: 'REMISION_CANTIDAD_DISTINTA',
      });
    }
  }
}

/**
 * Consume, dentro de la transacción de la venta, el saldo de los renglones de remisión que aplica la factura. Devuelve
 * renglón → remisión (para el vínculo de cabecera).
 *
 * - El renglón tiene que ser de una remisión aprobada, de la empresa y del cliente de la factura, sin documento asociado
 *   (las mismas que ofrece `findFacturables`), y del mismo producto que el ítem. Si no: 404 sin datos del renglón (antes
 *   se escribía en la remisión de otra empresa y el 400 decía su saldo).
 * - El saldo se consume con un UPDATE condicionado al disponible: dos facturas a la vez sobre el mismo renglón esperan
 *   el bloqueo de la fila y la segunda, sin saldo, responde 409 (antes se leía y se sumaba sin bloqueo y se sobrefacturaba).
 * - Los renglones se toman en orden de id, una vez cada uno (sumando los ítems que lo aplican), para que dos facturas no se
 *   esperen en orden cruzado.
 */
export async function consumirSaldosRemision(
  tx: Pick<Prisma.TransactionClient, 'nota_remision_det' | '$queryRaw'>,
  p: { empresaId: string; clienteId: string; items: ItemConRemision[] },
): Promise<Map<string, string | null>> {
  const porRenglon = new Map<string, { cantidad: number; items: ItemConRemision[] }>();
  for (const item of p.items) {
    for (const ap of aplicacionesDe(item)) {
      const actual = porRenglon.get(ap.nota_remision_det_id) ?? { cantidad: 0, items: [] };
      actual.cantidad += Number(ap.cantidad);
      actual.items.push(item);
      porRenglon.set(ap.nota_remision_det_id, actual);
    }
  }

  const remisiones = new Map<string, string | null>();
  for (const id of [...porRenglon.keys()].sort()) {
    const { cantidad, items } = porRenglon.get(id);
    const renglon = await tx.nota_remision_det.findFirst({
      where: {
        id,
        nota_remision_cab: { empresa_id: p.empresaId, cliente_id: p.clienteId, estado: 'Aprobado', tipo_documento_asociado: null },
      },
      select: { id: true, producto_id: true, nota_remision_cab_id: true },
    });
    const ajeno = items.find((it) => !renglon || renglon.producto_id !== it.producto_id);
    if (!renglon || ajeno) {
      throw noEncontrado({
        message: `La remisión aplicada a "${(ajeno ?? items[0]).descripcion ?? 'un ítem'}" no es una remisión aprobada de este cliente con ese producto. Volvé a importar las remisiones del cliente.`,
        codigo: 'REMISION_ITEM_NO_ENCONTRADO',
      });
    }
    const consumido = await tx.$queryRaw<Array<{ id: string }>>`
      UPDATE nota_remision_det
         SET cantidad_facturada = cantidad_facturada + ${cantidad}::numeric
       WHERE id = ${id}::uuid
         AND dcantproser - cantidad_facturada - COALESCE(cantidad_aplicada, 0) >= ${cantidad}::numeric - ${EPS}::numeric
      RETURNING id`;
    if (!consumido.length) {
      // El renglón es de la empresa (se validó arriba): su saldo se puede decir.
      const [fila] = await tx.$queryRaw<Array<{ disponible: number }>>`
        SELECT (dcantproser - cantidad_facturada - COALESCE(cantidad_aplicada, 0))::float AS disponible FROM nota_remision_det WHERE id = ${id}::uuid`;
      throw conflicto({
        message: `Cantidad a facturar de "${items[0].descripcion ?? 'un ítem'}" (${cantidad}) supera lo que queda por facturar en la remisión (${Number(fila?.disponible ?? 0)}). Otra factura pudo haberla tomado: volvé a importar las remisiones.`,
        codigo: 'REMISION_SALDO_INSUFICIENTE',
      });
    }
    remisiones.set(id, renglon.nota_remision_cab_id);
  }
  return remisiones;
}

/**
 * Remisión hecha desde factura (`facturas_ids`): no descuenta stock (lo descontó la factura), así que cada renglón tiene que
 * quedar aplicado por completo a esas facturas; si no, el resto sería facturable sin que nadie descuente stock. Al revés, con
 * aplicaciones y sin `facturas_ids` la remisión descontaría stock otra vez. La pantalla ya topea cada renglón a lo disponible.
 */
export function validarAplicacionesRemisionDesdeFactura(
  items: Array<{ descripcion?: string | null; cantidad: number; aplicaciones?: Array<{ factura_det_id: string; cantidad: number }> | null }>,
  facturasIds: string[],
): void {
  const desdeFactura = facturasIds.some((id) => !!id);
  for (const item of items) {
    const aplicada = (item.aplicaciones ?? []).reduce((s, a) => s + Number(a.cantidad || 0), 0);
    const nombre = item.descripcion ?? 'un ítem';
    if (!desdeFactura) {
      if (item.aplicaciones?.length) {
        throw solicitudInvalida({
          message: `"${nombre}" trae aplicaciones a ítems de factura pero la remisión no indica las facturas. Indicá las facturas o quitá las aplicaciones.`,
          codigo: 'REMISION_APLICACION_SIN_FACTURA',
        });
      }
      continue;
    }
    if (Math.abs(aplicada - Number(item.cantidad || 0)) > EPS) {
      throw solicitudInvalida({
        message: `La remisión desde factura tiene que aplicar por completo "${nombre}": cantidad ${Number(item.cantidad)}, aplicado ${aplicada}. Ajustá la cantidad a lo aplicado o aplicá el resto.`,
        codigo: 'REMISION_RENGLON_SIN_APLICAR',
      });
    }
  }
}
