import { Logger } from '@nestjs/common';
import { Prisma } from '@prisma/client';
import { codigoMonedaBase, codigosDeMonedas } from 'src/utils/montos-moneda';

/**
 * De dónde salió la moneda de un recibo: su cabecera (`recibos_cobro.moneda_id`) o, si es nula, la base de la empresa.
 * No se deduce de los documentos aplicados: es la misma regla que el Tablero (`getCuentasCobrarDashboard` agrupa por
 * `moneda_id`+`cotizacion` del recibo y `whereMonedaTablero` cuenta el nulo como base), así un recibo da el mismo
 * número en el Tablero y en Reportes.
 */
export type OrigenMonedaRecibo = 'recibo' | 'base';

export interface MonedaRecibo {
  codigo: string;
  moneda_id: string;
  /** La del recibo si es válida (> 1); si no, null: `aMonedaBase` lo deja fuera de lo convertido (`sin_cotizacion`). */
  cotizacion: Prisma.Decimal | null;
  origen: OrigenMonedaRecibo;
}

/** Tope de ids por consulta (Postgres admite 32.767 parámetros por sentencia). */
const LOTE = 10_000;

/** `<= 1` no es una cotización (mismo criterio que `aMonedaBase`). */
const cotizacionValida = (c: Prisma.Decimal | null): Prisma.Decimal | null => (c !== null && new Prisma.Decimal(c).gt(1) ? new Prisma.Decimal(c) : null);

/** Resultado de `monedasDeRecibos`: lo que no se pudo resolver vuelve explícito, para contarlo al lado de `sin_cotizacion`. */
export interface MonedasDeRecibos {
  monedas: Map<string, MonedaRecibo>;
  /** Recibos cuya moneda no tiene código (no existe): fuera de `en_moneda` y `por_moneda`; el llamador los cuenta en `sin_moneda`. */
  sin_moneda: string[];
  /** Ids pedidos que no son recibos de esas empresas (filtro de tenencia) o no existen. */
  no_encontrados: string[];
}

/**
 * Una pasada por lote: ids de recibos → su moneda. Acepta una empresa o varias (holding: cada recibo nulo toma la base
 * de SU empresa). Una empresa con recibos y sin moneda base es 422 `EMPRESA_SIN_MONEDA_BASE`, igual que el Tablero.
 * Nada se descarta en silencio: lo no resuelto vuelve en `sin_moneda` / `no_encontrados`, en el orden pedido.
 */
export async function monedasDeRecibos(
  db: Prisma.TransactionClient,
  empresaId: string | string[],
  reciboIds: string[],
  logger: Logger,
): Promise<MonedasDeRecibos> {
  const monedas = new Map<string, MonedaRecibo>();
  const ids = [...new Set(reciboIds)];
  if (!ids.length) return { monedas, sin_moneda: [], no_encontrados: [] };
  const empresas = Array.isArray(empresaId) ? [...new Set(empresaId)] : [empresaId];
  const whereEmpresa = empresas.length === 1 ? empresas[0] : { in: empresas };

  type Fila = { id: string; empresa_id: string; moneda_id: string | null; cotizacion: Prisma.Decimal | null };
  const porEmpresa = new Map<string, Fila[]>();
  for (let i = 0; i < ids.length; i += LOTE) {
    const filas = await db.recibos_cobro.findMany({
      where: { empresa_id: whereEmpresa, id: { in: ids.slice(i, i + LOTE) } },
      select: { id: true, empresa_id: true, moneda_id: true, cotizacion: true },
    });
    for (const r of filas) {
      let grupo = porEmpresa.get(r.empresa_id);
      if (!grupo) porEmpresa.set(r.empresa_id, (grupo = []));
      grupo.push(r);
    }
  }

  const sinMoneda = new Set<string>();
  for (const [empresa, deLaEmpresa] of porEmpresa) {
    const base = await codigoMonedaBase(db, empresa);
    const codigos = await codigosDeMonedas(db, empresa, deLaEmpresa.map((r) => r.moneda_id), 'la moneda de los recibos', logger, base.id);
    for (const r of deLaEmpresa) {
      const codigo = codigos.get(r.moneda_id ?? null);
      if (!codigo) {
        sinMoneda.add(r.id);
        continue;
      }
      monedas.set(r.id, {
        codigo,
        moneda_id: r.moneda_id ?? base.id,
        cotizacion: cotizacionValida(r.cotizacion),
        origen: r.moneda_id ? 'recibo' : 'base',
      });
    }
  }
  return {
    monedas,
    sin_moneda: ids.filter((id) => sinMoneda.has(id)),
    no_encontrados: ids.filter((id) => !monedas.has(id) && !sinMoneda.has(id)),
  };
}
