import { noEncontrado, solicitudInvalida } from '../../common/utils/error-estructurado';

/** La caja maneja guaraníes: apertura, entradas y salidas manuales van en esta moneda. */
const MONEDA_BASE = 'PYG';

export const FORMATOS_ARQUEO = ['a4', 'a4-detallado', 'ticket', 'ticket-detallado'] as const;
export type FormatoArqueo = (typeof FORMATOS_ARQUEO)[number];

export const sesionNoEncontrada = () => noEncontrado({ message: 'Sesión no encontrada', codigo: 'SESION_NO_ENCONTRADA' });
export const arqueoNoEncontrado = () => noEncontrado({ message: 'Arqueo no encontrado', codigo: 'ARQUEO_NO_ENCONTRADO' });

export function formatoArqueo(raw: string | undefined): FormatoArqueo {
  if (raw === undefined) return 'a4';
  if ((FORMATOS_ARQUEO as readonly string[]).includes(raw)) return raw as FormatoArqueo;
  throw solicitudInvalida({ message: `El formato del arqueo tiene que ser uno de: ${FORMATOS_ARQUEO.join(', ')}.`, codigo: 'FORMATO_INVALIDO', campo: 'formato' });
}

/**
 * La sesión no tiene moneda: sale de sus documentos. Los montos propios de la caja llevan la base al conjunto.
 * Con más de una, `codigo` es la base y `mezcla` la lista, con la base primero.
 */
export function monedaDeArqueo(codigos: string[], montos: { apertura: number; entradas: number; salidas: number }): { codigo: string; mezcla: string[] } {
  const conjunto = new Set(codigos);
  if (conjunto.size === 0 || montos.apertura > 0 || montos.entradas > 0 || montos.salidas > 0) conjunto.add(MONEDA_BASE);
  if (conjunto.size === 1) return { codigo: [...conjunto][0], mezcla: [] };
  const otras = [...conjunto].filter((c) => c !== MONEDA_BASE).sort();
  return { codigo: MONEDA_BASE, mezcla: conjunto.has(MONEDA_BASE) ? [MONEDA_BASE, ...otras] : otras };
}

const SIMBOLOS: Record<string, { simbolo: string; decimales: number }> = {
  PYG: { simbolo: 'Gs.', decimales: 0 },
  USD: { simbolo: 'US$', decimales: 2 },
  BRL: { simbolo: 'R$', decimales: 2 },
  ARS: { simbolo: '$', decimales: 2 },
};

/** Se escribe como `fmtMoneda` del front (`_standards/enums/monedas.js`): el texto de la fila es lo que el usuario ve en la pantalla. */
function montoEnTexto(valor: number, codigo: string): string {
  const { simbolo, decimales } = SIMBOLOS[codigo] ?? { simbolo: codigo, decimales: 2 };
  return `${simbolo} ${valor.toLocaleString('es-PY', { minimumFractionDigits: decimales, maximumFractionDigits: decimales })}`;
}

const listar = (codigos: string[]): string => `${codigos.slice(0, -1).join(', ')} y ${codigos[codigos.length - 1]}`;

interface FilaVenta {
  medio_pago: string;
  cantidad: number | null;
  total: number;
  moneda: string;
}

interface FilaMovimiento {
  concepto: string;
  monto: number;
  moneda: string;
}

const sinMoneda = <T extends { moneda: string }>({ moneda: _moneda, ...fila }: T): Omit<T, 'moneda'> => fila;

/**
 * El generador de PDF formatea todo número con la moneda global y su TOTAL suma los números (F1): una fila en otra moneda lleva el
 * monto en el texto y 0 en el número, así ninguna fila rotula dólares como guaraníes y el TOTAL es solo de la base. Nada se convierte.
 * El monto del movimiento va al principio porque A4 corta el concepto a 55 caracteres y el ticket a 60.
 * Un movimiento en otra moneda va rotulado también sin mezcla: lo anulado no cuenta para la moneda de la sesión (F5), pero su movimiento sigue en la lista.
 */
export function rotularMezcla<V extends FilaVenta, M extends FilaMovimiento>(entrada: {
  codigoBase: string;
  mezcla: string[];
  ventas: V[];
  movimientos: M[];
  observaciones: string | null;
}) {
  const { codigoBase, mezcla, ventas, movimientos, observaciones } = entrada;
  const filasMovimiento = movimientos.map((m) => (m.moneda === codigoBase ? sinMoneda(m) : { ...sinMoneda(m), concepto: `${montoEnTexto(m.monto, m.moneda)} · ${m.concepto}`, monto: 0 }));
  if (!mezcla.length) return { ventas_por_medio: ventas.map(sinMoneda<V>) as Array<Omit<FilaVenta, 'moneda'>>, movimientos: filasMovimiento, observaciones };

  const totalesPorMoneda = new Map<string, number>();
  const filas: Array<Omit<FilaVenta, 'moneda'>> = ventas.map((v) => {
    if (v.moneda === codigoBase) return sinMoneda(v);
    totalesPorMoneda.set(v.moneda, (totalesPorMoneda.get(v.moneda) ?? 0) + v.total);
    return { ...sinMoneda(v), medio_pago: `${v.medio_pago} · ${montoEnTexto(v.total, v.moneda)}`, total: 0 };
  });
  const totales = [...totalesPorMoneda.entries()]
    .sort(([a], [b]) => a.localeCompare(b))
    .map(([moneda, total]) => ({ medio_pago: `TOTAL ${moneda} · ${montoEnTexto(total, moneda)}`, cantidad: null, total: 0 }));

  const linea = `Sesión con documentos en ${listar(mezcla)}: el resumen y el arqueo muestran los acumulados de la caja, sin convertir.`;
  return {
    ventas_por_medio: [...filas, ...totales],
    movimientos: filasMovimiento,
    observaciones: observaciones ? `${linea}\n${observaciones}` : linea,
  };
}
