import { BadRequestException, Logger, UnprocessableEntityException } from '@nestjs/common';
import { Prisma } from '@prisma/client';
import { monedaBaseId } from 'src/monedas/moneda-base';

/**
 * Montos en varias monedas: nunca se suman monedas distintas sin convertir. «Convertido» = cada documento con SU
 * cotización a la moneda base; un documento sin cotización queda fuera de lo convertido (el llamador lo cuenta en
 * `sin_cotizacion`) y sigue en `por_moneda`, que es la suma por código sin convertir (forma de `pagos-proveedor`).
 * La cotización de los documentos está en guaraníes por unidad de la moneda del documento (dticam, cotizacion,
 * tipo_cambio_usd).
 */
export type Cotizable = { codigo: string | null; cotizacion: Prisma.Decimal | number | string | null };

const PYG = 'PYG';

const cotizacionDe = (v: Cotizable['cotizacion']): number => (v === null || v === undefined ? NaN : Number(String(v)));

/**
 * Una cotización válida para un documento que no está en la base. `<= 1` no lo es: `compra_cab.cotizacion` y la de la
 * NC de compra tienen `@default(1)`, que en un documento en USD no es una cotización (F18).
 */
const cotizacionValida = (cot: number) => Number.isFinite(cot) && cot > 1;

/**
 * Mismo código → monto (un documento sin moneda está en la base, F2). Base PYG y cotización válida → round(monto × cot).
 * Documento PYG con base ≠ PYG y cotización válida → monto / cot a 2 decimales. Si no → null (sin cotización).
 */
export function aMonedaBase(monto: number, doc: Cotizable, codigoBase: string): number | null {
  const base = codigoBase.toUpperCase();
  const codigo = (doc.codigo || base).toUpperCase();
  if (codigo === base) return monto;
  const cot = cotizacionDe(doc.cotizacion);
  if (!cotizacionValida(cot)) return null;
  if (base === PYG) return Math.round(monto * cot);
  if (codigo === PYG) return Math.round((monto / cot) * 100) / 100;
  return null;
}

/**
 * Lo inverso de `aMonedaBase`: un monto guardado en la base (el costo de productos) a la moneda del documento, con la
 * cotización del documento. PYG sin decimales, otra moneda a 2 decimales. Sin cotización válida → null.
 */
export function desdeMonedaBase(montoBase: number, doc: Cotizable, codigoBase: string): number | null {
  const base = codigoBase.toUpperCase();
  const codigo = (doc.codigo || base).toUpperCase();
  if (codigo === base) return montoBase;
  const cot = cotizacionDe(doc.cotizacion);
  if (!cotizacionValida(cot)) return null;
  if (base === PYG) return Math.round((montoBase / cot) * 100) / 100;
  if (codigo === PYG) return Math.round(montoBase * cot);
  return null;
}

/** Suma por código, nunca entre códigos; campos a texto con 2 decimales; ordenado por código; los null de código van a la base. */
export function porMoneda<C extends string>(
  filas: Array<{ codigo: string | null } & Record<C, number>>,
  campos: C[],
  codigoBase: string,
): Array<{ codigo: string } & Record<C, string>> {
  const sumas = new Map<string, Record<string, Prisma.Decimal>>();
  for (const fila of filas) {
    const codigo = fila.codigo || codigoBase;
    const acc = sumas.get(codigo) ?? Object.fromEntries(campos.map((c) => [c, new Prisma.Decimal(0)]));
    for (const c of campos) acc[c] = acc[c].plus(new Prisma.Decimal(String(fila[c] ?? 0)));
    sumas.set(codigo, acc);
  }
  return [...sumas]
    .sort(([a], [b]) => a.localeCompare(b))
    .map(([codigo, acc]) => ({ codigo, ...Object.fromEntries(campos.map((c) => [c, acc[c].toFixed(2)])) }) as { codigo: string } & Record<C, string>);
}

/** La moneda base con su código, o null si la empresa no tiene (para quien puede seguir sin ella, como un listado). */
export async function monedaBaseOpcional(db: Prisma.TransactionClient, empresaId: string): Promise<{ id: string; codigo: string } | null> {
  const id = await monedaBaseId(db, empresaId);
  const moneda = id ? await db.moneda.findUnique({ where: { id }, select: { id: true, codigo: true } }) : null;
  return moneda?.codigo ? { id: moneda.id, codigo: moneda.codigo } : null;
}

/** La moneda base de la empresa con su código (ver `monedaBaseId`). Sin moneda base no hay cómo rotular ni convertir. */
export async function codigoMonedaBase(db: Prisma.TransactionClient, empresaId: string): Promise<{ id: string; codigo: string }> {
  const moneda = await monedaBaseOpcional(db, empresaId);
  if (!moneda) {
    throw new UnprocessableEntityException({
      message: 'La empresa no tiene una moneda principal cargada',
      codigo: 'EMPRESA_SIN_MONEDA_BASE',
    });
  }
  return { id: moneda.id, codigo: moneda.codigo };
}

/**
 * Código de cada `moneda_id` de un KPI. Una moneda NULL (legacy) es la base de la empresa. Una moneda sin código (no
 * existe, o la empresa no tiene moneda base) queda afuera del mapa con un WARN: el KPI la omite en vez de mostrar un
 * código vacío, y nunca la suma a otra.
 */
export async function codigosDeMonedas(
  db: Prisma.TransactionClient,
  empresaId: string,
  monedaIds: Array<string | null | undefined>,
  donde: string,
  logger: Logger,
  /** La moneda base, si el llamador ya la leyó (así no se consulta dos veces). */
  baseLeida?: string | null,
): Promise<Map<string | null, string>> {
  const out = new Map<string | null, string>();
  if (!monedaIds.length) return out;
  const base =
    baseLeida !== undefined
      ? baseLeida || null
      : monedaIds.some((id) => !id)
        ? await monedaBaseId(db, empresaId)
        : null;
  const reales = [...new Set(monedaIds.map((id) => id || base).filter((id): id is string => Boolean(id)))];
  const monedas = reales.length
    ? await db.moneda.findMany({ where: { id: { in: reales } }, select: { id: true, codigo: true } })
    : [];
  const codigo = new Map(monedas.map((m) => [m.id, m.codigo]));
  for (const id of new Set(monedaIds.map((x) => x ?? null))) {
    const real = id || base;
    const c = real ? codigo.get(real) : undefined;
    if (c) out.set(id, c);
    else
      logger.warn(
        `Moneda sin código en ${donde} (moneda_id=${id ?? 'NULL'}${id ? '' : ', sin moneda base'}, empresa ${empresaId}): se omite`,
      );
  }
  return out;
}

/** Qué moneda muestra un dashboard del Tablero: la elegida (filtra) o, sin elegir, la base (convierte). */
export type MonedaTablero = {
  convertir: boolean;
  base: { id: string; codigo: string };
  /** La elegida o, con «Convertido», la base. Es el `moneda` de la respuesta. */
  moneda: { id: string; codigo: string };
};

const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;

export async function resolverMonedaTablero(
  db: Prisma.TransactionClient,
  empresaId: string,
  monedaId?: string | null,
): Promise<MonedaTablero> {
  const base = await codigoMonedaBase(db, empresaId);
  if (!monedaId) return { convertir: true, base, moneda: base };
  const moneda = UUID.test(monedaId)
    ? await db.moneda.findUnique({ where: { id: monedaId }, select: { id: true, codigo: true } })
    : null;
  if (!moneda?.codigo) {
    throw new BadRequestException({ message: 'La moneda pedida no existe', codigo: 'MONEDA_INVALIDA', campo: 'moneda_id' });
  }
  return { convertir: false, base, moneda: { id: moneda.id, codigo: moneda.codigo } };
}

/**
 * El filtro por la moneda elegida, para ir dentro de un `AND` (no pisa otro `OR` del where). Con la base incluye los
 * documentos sin moneda (F2). Con «Convertido», nada.
 */
export function whereMonedaTablero(m: MonedaTablero): { moneda_id: string } | { OR: Array<{ moneda_id: string | null }> } | undefined {
  if (m.convertir) return undefined;
  if (m.moneda.id === m.base.id) return { OR: [{ moneda_id: m.moneda.id }, { moneda_id: null }] };
  return { moneda_id: m.moneda.id };
}

/**
 * Cada monto de un documento pasado a otra moneda con `conv`. Si alguno no se puede convertir, null: el documento
 * queda fuera entero (nunca a medias) y el llamador lo cuenta en `sin_cotizacion`.
 */
export function convertirMontos<M extends Record<string, number>>(montos: M, conv: (monto: number) => number | null): M | null {
  const out = {} as Record<string, number>;
  for (const [k, v] of Object.entries(montos)) {
    const c = conv(v);
    if (c === null) return null;
    out[k] = c;
  }
  return out as M;
}

/** Cada número de un bloque de totales a 2 decimales (para `en_moneda`; los campos de siempre no pasan por acá). */
export function redondearBloque<T>(bloque: T): T {
  if (typeof bloque === 'number') return (Math.round(bloque * 100) / 100) as T;
  if (!bloque || typeof bloque !== 'object' || Array.isArray(bloque)) return bloque;
  return Object.fromEntries(Object.entries(bloque).map(([k, v]) => [k, redondearBloque(v)])) as T;
}
