import { escaparLike } from 'src/common/utils/busqueda-texto.util';
import { Prisma } from '@prisma/client';

/**
 * Armado puro (sin base de datos) de las lecturas de Stock por depósito: el SQL que valoriza cada fila, el orden por
 * lista blanca, el escape del buscador, el paso de la fila de SQL a la respuesta y el margen. Una sola fuente para
 * `/filas`, `/resumen`, `/excel` y `/pdf`, de modo que lo que se ve, lo que se suma y lo que se exporta no se separen.
 */

export interface FiltrosStock {
  q?: string;
  categoriaIds: string[];
  marcaIds: string[];
  soloBajos: boolean;
}

/** Lista general de la empresa y su moneda base: las mismas dos consultas que `preciosPorProducto`. */
export interface ContextoPrecios {
  listaId: string | null;
  monedaLista: string | null;
  nombreLista: string | null;
  monedaBase: string;
}

export interface PrecioFila {
  valor: number | null;
  moneda: string;
  total: number | null;
}

export interface FilaStock {
  id: string;
  deposito_id: string;
  producto_id: string;
  cantidad_disponible: number;
  cantidad_reservada: number;
  stock_minimo: number;
  stock_maximo: number | null;
  ubicacion: string | null;
  producto: { id: string; descripcion: string; cod_producto: string | null; codigo_barra: string | null; categoria_id: string | null; marca_id: string | null };
  precios: {
    /** Solo con INV_STK_COSTO_VER. */
    costo?: PrecioFila & { fuente: 'lote' | 'producto' };
    venta: PrecioFila & { fuente: 'lista' | 'producto'; lista: string | null };
  };
}

export interface SumaMoneda {
  moneda: string;
  valor: number;
}

export interface ResumenStock {
  /** Sin filtros: el «de M productos». */
  filas_deposito: number;
  /** Con filtros. */
  filas: number;
  unidades: number;
  bajos: number;
  sin_stock: number;
  negativos: number;
  venta: SumaMoneda[];
  /** Solo con INV_STK_COSTO_VER. */
  costo?: SumaMoneda[];
  margen?: { valor: number; moneda: string; pct: number } | null;
}

type Numero = number | string | Prisma.Decimal | bigint | null | undefined;

/** Fila tal como sale del SQL de `baseStockSql`. */
export interface FilaSql {
  id: string;
  deposito_id: string;
  producto_id: string;
  cantidad_disponible: Numero;
  cantidad_reservada: Numero;
  stock_minimo: Numero;
  stock_maximo: Numero;
  ubicacion: string | null;
  producto: string;
  cod_producto: string | null;
  codigo_barra: string | null;
  categoria_id: string | null;
  marca_id: string | null;
  costo_valor: Numero;
  costo_fuente: 'lote' | 'producto';
  costo_moneda: string;
  total_costo: Numero;
  venta_valor: Numero;
  venta_moneda: string;
  venta_fuente: 'lista' | 'producto';
  venta_lista?: string | null;
  total_venta: Numero;
}

/** Clave del orden → columna de la CTE `base`. Lista blanca: nada que venga de afuera llega al SQL. */
export const COLUMNAS_ORDEN: Record<string, string> = {
  producto: 'producto',
  codigo: 'cod_producto',
  disponible: 'cantidad_disponible',
  reservado: 'cantidad_reservada',
  costo: 'costo_valor',
  total_costo: 'total_costo',
  venta: 'venta_valor',
  total_venta: 'total_venta',
  minimo: 'stock_minimo',
  maximo: 'stock_maximo',
  ubicacion: 'ubicacion',
};

/** Órdenes que dejarían ver el costo por un costado: sin el permiso caen al orden por producto. */
export const COLUMNAS_ORDEN_COSTO = ['costo', 'total_costo'];

export const num = (v: Numero): number => (v == null ? 0 : Number(v));
const numONull = (v: Numero): number | null => (v == null ? null : Number(v));

/** Escapa `%`, `_` y `\` para ILIKE: vive en `common/utils/busqueda-texto.util` (lo usan también los buscadores). */
export { escaparLike };

export function resolverOrden(orden: string | undefined, dir: string | undefined, verCosto: boolean): { columna: string; dir: 'ASC' | 'DESC' } {
  const permitido = orden !== undefined && Object.prototype.hasOwnProperty.call(COLUMNAS_ORDEN, orden) && (verCosto || !COLUMNAS_ORDEN_COSTO.includes(orden));
  if (!permitido) return { columna: COLUMNAS_ORDEN.producto, dir: 'ASC' };
  return { columna: COLUMNAS_ORDEN[orden as string], dir: String(dir).toLowerCase() === 'desc' ? 'DESC' : 'ASC' };
}

/**
 * `WITH costo_lote AS (…), base AS (…)`: el stock del depósito con su costo y su venta. Quien la usa le agrega un `SELECT … FROM base`.
 *  - costo: promedio ponderado de los lotes con stock en ESTE depósito si el producto maneja lotes y tiene alguno; si no, `precio_costo`;
 *  - venta: `precio_base` de la lista general si el producto está en ella; si no, `productos.precio`.
 */
export function baseStockSql(depositoId: string, ctx: ContextoPrecios, filtros: FiltrosStock): Prisma.Sql {
  const condiciones: Prisma.Sql[] = [Prisma.sql`sd.deposito_id = ${depositoId}::uuid`];
  const q = filtros.q?.trim();
  if (q) {
    const patron = `%${escaparLike(q)}%`;
    condiciones.push(Prisma.sql`(p.descripcion ILIKE ${patron} OR p.cod_producto ILIKE ${patron} OR p.codigo_barra ILIKE ${patron})`);
  }
  if (filtros.categoriaIds.length) condiciones.push(Prisma.sql`p.categoria_id = ANY(${filtros.categoriaIds}::uuid[])`);
  if (filtros.marcaIds.length) condiciones.push(Prisma.sql`p.marca_id = ANY(${filtros.marcaIds}::uuid[])`);
  if (filtros.soloBajos) condiciones.push(Prisma.sql`(sd.cantidad_disponible <= 0 OR (sd.stock_minimo > 0 AND sd.cantidad_disponible <= sd.stock_minimo))`);

  return Prisma.sql`
    WITH costo_lote AS (
      SELECT lp.producto_id,
             SUM(sl.cantidad_disponible * lp.costo_unitario) / NULLIF(SUM(sl.cantidad_disponible), 0) AS costo
      FROM stock_lote sl
      JOIN lotes_producto lp ON lp.id = sl.lote_id
      WHERE sl.deposito_id = ${depositoId}::uuid AND sl.active AND sl.cantidad_disponible > 0 AND lp.activo
      GROUP BY lp.producto_id
    ),
    base AS (
      SELECT sd.id, sd.deposito_id, sd.producto_id, sd.cantidad_disponible, sd.cantidad_reservada, sd.stock_minimo, sd.stock_maximo, sd.ubicacion,
             p.descripcion AS producto, p.cod_producto, p.codigo_barra, p.categoria_id, p.marca_id,
             CASE WHEN p.maneja_lote AND cl.costo IS NOT NULL THEN ROUND(cl.costo, 2) ELSE p.precio_costo END AS costo_valor,
             CASE WHEN p.maneja_lote AND cl.costo IS NOT NULL THEN 'lote' ELSE 'producto' END AS costo_fuente,
             ${ctx.monedaBase}::text AS costo_moneda,
             sd.cantidad_disponible * CASE WHEN p.maneja_lote AND cl.costo IS NOT NULL THEN ROUND(cl.costo, 2) ELSE p.precio_costo END AS total_costo,
             CASE WHEN lpp.id IS NOT NULL THEN lpp.precio_base ELSE p.precio END AS venta_valor,
             CASE WHEN lpp.id IS NOT NULL THEN ${ctx.monedaLista ?? ctx.monedaBase}::text ELSE ${ctx.monedaBase}::text END AS venta_moneda,
             CASE WHEN lpp.id IS NOT NULL THEN 'lista' ELSE 'producto' END AS venta_fuente,
             CASE WHEN lpp.id IS NOT NULL THEN ${ctx.nombreLista}::text ELSE NULL END AS venta_lista,
             sd.cantidad_disponible * CASE WHEN lpp.id IS NOT NULL THEN lpp.precio_base ELSE p.precio END AS total_venta
      FROM stock_deposito sd
      JOIN productos p ON p.id = sd.producto_id
      LEFT JOIN costo_lote cl ON cl.producto_id = sd.producto_id
      LEFT JOIN lista_precios_productos lpp ON lpp.producto_id = sd.producto_id AND lpp.lista_precios_id = ${ctx.listaId}::uuid
      WHERE ${Prisma.join(condiciones, ' AND ')}
    )`;
}

/** De la fila de SQL a la respuesta. Sin permiso de costo, la clave `costo` no existe (no vale `null`: ni la forma se filtra). */
export function filaDeSql(r: FilaSql, verCosto: boolean): FilaStock {
  const fila: FilaStock = {
    id: r.id,
    deposito_id: r.deposito_id,
    producto_id: r.producto_id,
    cantidad_disponible: num(r.cantidad_disponible),
    cantidad_reservada: num(r.cantidad_reservada),
    stock_minimo: num(r.stock_minimo),
    stock_maximo: numONull(r.stock_maximo),
    ubicacion: r.ubicacion ?? null,
    producto: {
      id: r.producto_id,
      descripcion: r.producto,
      cod_producto: r.cod_producto ?? null,
      codigo_barra: r.codigo_barra ?? null,
      categoria_id: r.categoria_id ?? null,
      marca_id: r.marca_id ?? null,
    },
    precios: {
      venta: {
        valor: numONull(r.venta_valor),
        moneda: r.venta_moneda,
        total: numONull(r.total_venta),
        fuente: r.venta_fuente,
        lista: r.venta_fuente === 'lista' ? (r.venta_lista ?? null) : null,
      },
    },
  };
  if (verCosto) {
    fila.precios.costo = { valor: numONull(r.costo_valor), moneda: r.costo_moneda, total: numONull(r.total_costo), fuente: r.costo_fuente };
  }
  return fila;
}

/** Margen potencial: solo con costo y venta en una única moneda, la misma, y venta mayor a cero (regla de `StockTab.jsx:405`). */
export function margenDe(costo: SumaMoneda[], venta: SumaMoneda[]): { valor: number; moneda: string; pct: number } | null {
  if (costo.length !== 1 || venta.length !== 1) return null;
  const [c] = costo;
  const [v] = venta;
  if (c.moneda !== v.moneda || !(v.valor > 0)) return null;
  const valor = v.valor - c.valor;
  return { valor, moneda: v.moneda, pct: (valor / v.valor) * 100 };
}
