import { resolverPermisos } from 'src/productos/permisos-columnas';
import { PrismaService } from 'src/prisma/prisma.service';

/** Permiso que habilita ver el costo en Inventario. Sin él, el costo no sale por ninguna ruta. */
export const PRIVILEGIO_COSTO = 'INV_STK_COSTO_VER';

/**
 * Copia de la fila sin costo: `producto.precio_costo` (el `include: producto: true` lo trae entero) y, si la fila es un movimiento,
 * su propio `costo_unitario` (queda en `null`: la clave sigue, el valor no sale).
 */
export function sinCosto<T extends { producto?: unknown; costo_unitario?: unknown }>(fila: T): T {
  if (!fila || typeof fila !== 'object') return fila;
  let copia: T = fila;
  if (fila.producto && typeof fila.producto === 'object') {
    const { precio_costo: _costo, ...producto } = fila.producto as Record<string, unknown>;
    copia = { ...copia, producto };
  }
  if ('costo_unitario' in fila) copia = { ...copia, costo_unitario: null };
  return copia;
}

/** ¿El usuario tiene `INV_STK_COSTO_VER`? Sin usuario, no. Superadmin, sí (`resolverPermisos`). */
export async function veCosto(prisma: PrismaService, usuario_id: string | undefined): Promise<boolean> {
  if (!usuario_id) return false;
  return (await resolverPermisos(prisma, usuario_id, [PRIVILEGIO_COSTO])).has(PRIVILEGIO_COSTO);
}

/**
 * Productos tal como salen de una ruta general (`GET /productos`, `/productos/:id`, `/productos/search`, la respuesta de
 * `PUT /productos/:id` y el precio resuelto de las listas): sin la clave del costo (`precio_costo` en el producto,
 * `precioCosto` en el precio resuelto) salvo que el usuario tenga `INV_STK_COSTO_VER`. Lo decide el permiso del usuario
 * en el servidor, nunca un parámetro del pedido. Una sola consulta de permisos para toda la lista.
 *
 * Nada que use el costo en el servidor (tope de descuento del POS, piso de venta, solicitud de crédito, compras) pasa
 * por acá: esto solo recorta lo que se entrega.
 */
export async function sinCostoSiNoCorresponde<T extends object>(
  prisma: PrismaService,
  usuario_id: string | undefined,
  filas: T[],
  claves: string | string[] = 'precio_costo',
): Promise<T[]> {
  if (await veCosto(prisma, usuario_id)) return filas;
  return quitarClaves(filas, claves);
}

/** Copia de cada fila sin esas claves (las que no las tienen quedan igual). Para cuando el permiso ya se resolvió. */
export function quitarClaves<T extends object>(filas: T[], claves: string | string[]): T[] {
  const lista = Array.isArray(claves) ? claves : [claves];
  return filas.map((fila) => {
    if (!fila || typeof fila !== 'object' || !lista.some((c) => c in fila)) return fila;
    const copia = { ...fila } as Record<string, unknown>;
    for (const c of lista) delete copia[c];
    return copia as T;
  });
}

/**
 * Para los `include` de un producto en respuestas al front o a la app (facturas, NC, remisiones, sincronización):
 * `productos: { omit: OMITIR_COSTO_PRODUCTO }`. El producto llega con todas sus columnas menos el costo. Si un flujo
 * lo necesitara en la respuesta, se lo agrega con `sinCostoSiNoCorresponde`, nunca trayendo el producto entero.
 */
export const OMITIR_COSTO_PRODUCTO = { precio_costo: true } as const;

/** Columnas del costo de venta de `factura_det` y de sus lotes (`factura_det_lote`). */
export const OMITIR_COSTO_DETALLE_VENTA = { costo_unitario_venta: true, costo_total_venta: true } as const;
const COSTOS_DETALLE_VENTA = Object.keys(OMITIR_COSTO_DETALLE_VENTA);
const COSTOS_LOTE_VENTA = ['costo_unitario', 'costo_total'];

/** Copia de la factura sin el costo de venta de sus líneas ni de los lotes de cada línea (con `factura_det` o sin él). */
export function facturaSinCostoDeVenta<T extends object>(factura: T): T {
  const dets = (factura as { factura_det?: unknown }).factura_det;
  if (!Array.isArray(dets)) return factura;
  const factura_det = quitarClaves(dets as object[], COSTOS_DETALLE_VENTA).map((d) => {
    const lotes = (d as { factura_det_lote?: unknown }).factura_det_lote;
    return Array.isArray(lotes) ? { ...d, factura_det_lote: quitarClaves(lotes as object[], COSTOS_LOTE_VENTA) } : d;
  });
  return { ...factura, factura_det } as T;
}

/** Facturas de `GET /facturas` y `/facturas/:id`: sin el costo de venta salvo con `INV_STK_COSTO_VER`. */
export async function facturasSinCostoSiNoCorresponde<T extends object>(prisma: PrismaService, usuario_id: string | undefined, facturas: T[]): Promise<T[]> {
  if (await veCosto(prisma, usuario_id)) return facturas;
  return facturas.map((f) => facturaSinCostoDeVenta(f));
}
