import type { Logger } from '@nestjs/common';
import { codigoDeError } from '../common/utils/error-estructurado';

/**
 * Qué pasó con el asiento de un movimiento de Tesorería al confirmarlo (A6). El integrador devuelve su resultado y el
 * servicio lo traduce a lo que ve la pantalla; el script de revisión usa `motivoSinAsiento` con los datos que lee.
 */
export type MotivoAsiento =
  | 'SIN_MODULO'
  | 'POR_ORIGEN'
  | 'CUENTA_SIN_CUENTA_CONTABLE'
  | 'CATEGORIA_SIN_CUENTA'
  | 'FALTA_MAPEO'
  | 'SIN_PERIODO_ABIERTO'
  | 'ERROR';

export interface AsientoMovimiento {
  generado: boolean;
  motivo: MotivoAsiento | null;
  conceptos?: string[];
  categoria?: string;
  /** Nombre de la cuenta de tesorería sin cuenta contable (transferencias, S3). */
  cuenta?: string;
  /** Con `motivo: 'ERROR'` (transferencias, S3): el código del error, o `ERROR_INESPERADO` (sin `mensaje`: el detalle va al log). */
  codigo?: string;
  mensaje?: string;
}

/** El asiento falló por algo que no es un error conocido: el detalle queda en el log del servidor. */
export const CODIGO_ASIENTO_ERROR_INESPERADO = 'ERROR_INESPERADO';

/** Lo que devuelve `integrarMovimientoTesoreria`; `undefined` = falta de mapeo atrapada por `conAvisoDeMapeo`. */
export type ResultadoIntegracionMovimiento =
  | { generado: true }
  | { generado: false; motivo: Exclude<MotivoAsiento, 'FALTA_MAPEO' | 'ERROR'>; categoria?: string };

/**
 * Lo que devuelve `integrarTransferenciaTes` (S3); `undefined` = falta de mapeo atrapada por `conAvisoDeMapeo`. `cuenta` es la
 * primera de las dos cuentas de tesorería (origen antes que destino) que no tiene cuenta contable.
 */
export type ResultadoIntegracionTransferencia =
  | { generado: true }
  | { generado: false; motivo: 'SIN_MODULO' | 'CUENTA_SIN_CUENTA_CONTABLE' | 'SIN_PERIODO_ABIERTO'; cuenta?: string };

/**
 * El asiento falló con una excepción (movimientos y transferencias, mismo criterio). Un error con `codigo` es nuestro (su
 * `message` está escrito para el usuario) y va tal cual. Lo inesperado (Prisma, la base) puede nombrar tablas o columnas:
 * queda en el log con su contexto y al cliente le llega solo `ERROR_INESPERADO`, sin `mensaje`.
 */
export function asientoDeError(e: unknown, logger: Logger, contexto: string): AsientoMovimiento {
  const codigo = codigoDeError(e);
  if (codigo) return { generado: false, motivo: 'ERROR', codigo, mensaje: (e as Error).message };
  logger.error(`No se pudo generar el asiento ${contexto}: ${e instanceof Error ? e.message : String(e)}`, e instanceof Error ? e.stack : undefined);
  return { generado: false, motivo: 'ERROR', codigo: CODIGO_ASIENTO_ERROR_INESPERADO };
}

export function asientoDeResultado(
  r: ResultadoIntegracionMovimiento | ResultadoIntegracionTransferencia | undefined,
  conceptos: string[],
): AsientoMovimiento {
  if (r === undefined) return { generado: false, motivo: 'FALTA_MAPEO', conceptos };
  if (!('motivo' in r)) return { generado: true, motivo: null };
  const categoria = 'categoria' in r ? r.categoria : undefined;
  const cuenta = 'cuenta' in r ? r.cuenta : undefined;
  return { generado: false, motivo: r.motivo, ...(categoria !== undefined && { categoria }), ...(cuenta !== undefined && { cuenta }) };
}

export interface DatosAsiento {
  se_contabiliza_por_origen: boolean;
  tiene_modulo: boolean;
  tiene_documento: boolean;
  cuenta_contable_id: string | null;
  falta_mapeo: string[];
  categoria_sin_cuenta: string | null;
  periodo_abierto: boolean;
}

/** Los datos de un movimiento al que no le falta nada: con ellos `motivoSinAsiento` da `null`. */
export const DATOS_ASIENTO_COMPLETOS: DatosAsiento = {
  se_contabiliza_por_origen: false,
  tiene_modulo: true,
  tiene_documento: false,
  cuenta_contable_id: 'completa',
  falta_mapeo: [],
  categoria_sin_cuenta: null,
  periodo_abierto: true,
};

/**
 * Por qué un movimiento no tiene asiento, en el orden en que el integrador lo chequea. `null` = se generaría o ya existe.
 * Una sola función para el integrador y el script de revisión (F13): la secuencia no se copia.
 */
export function motivoSinAsiento(d: DatosAsiento): { motivo: Exclude<MotivoAsiento, 'ERROR'>; categoria?: string; conceptos?: string[] } | null {
  if (d.se_contabiliza_por_origen) return { motivo: 'POR_ORIGEN' };
  if (!d.tiene_modulo) return { motivo: 'SIN_MODULO' };
  if (d.tiene_documento) return null;
  if (!d.cuenta_contable_id) return { motivo: 'CUENTA_SIN_CUENTA_CONTABLE' };
  if (d.falta_mapeo.length > 0) return { motivo: 'FALTA_MAPEO', conceptos: d.falta_mapeo };
  if (d.categoria_sin_cuenta) return { motivo: 'CATEGORIA_SIN_CUENTA', categoria: d.categoria_sin_cuenta };
  if (!d.periodo_abierto) return { motivo: 'SIN_PERIODO_ABIERTO' };
  return null;
}

/**
 * El resultado del integrador cuando se detiene en un chequeo: pasa por `motivoSinAsiento` con todo lo demás en orden, así
 * el motivo sale de la misma función que usa el script (F13). El faltante de mapeo no entra acá: el integrador lo lanza.
 */
export function resultadoSinAsiento(
  parcial: Partial<Omit<DatosAsiento, 'falta_mapeo'>>,
): ResultadoIntegracionMovimiento {
  const r = motivoSinAsiento({ ...DATOS_ASIENTO_COMPLETOS, ...parcial });
  if (!r) return { generado: true };
  return { generado: false, motivo: r.motivo as Exclude<MotivoAsiento, 'FALTA_MAPEO' | 'ERROR'>, ...(r.categoria !== undefined && { categoria: r.categoria }) };
}
