import type { Prisma } from '@prisma/client';
import type { PrismaService } from 'src/prisma/prisma.service';

/**
 * Cuenta de tesorería de la que sale el pago de un gasto de contado.
 *
 * Es el único lugar que decide esa cuenta: lo usan el egreso de Tesorería, la
 * validación al guardar el gasto, el formulario (GET /gastos/cuenta-pago) y el
 * asiento, para que los cuatro miren la misma cuenta (N6). Es una función sobre
 * el cliente de Prisma para que Tesorería y Contabilidad la usen sin depender
 * una del módulo de la otra.
 *
 * Orden: la cuenta elegida en el gasto (si no sirve, ninguna: I13) → la regla "Pago de gasto" del
 * medio de pago y la moneda → la del medio (sin moneda) → la general de la
 * moneda → la general (sin moneda). Solo cuentan las reglas activas con una
 * cuenta activa de la empresa: una regla del medio que no sirve se saltea con
 * un aviso y se cae a la general.
 */

export const TES_REGLA_PAGO_GASTO = 'PAGO_GASTO';

export type OrigenCuentaPagoGasto =
  | 'CUENTA_ELEGIDA'
  | 'REGLA_MEDIO_MONEDA'
  | 'REGLA_MEDIO'
  | 'REGLA_GENERAL_MONEDA'
  | 'REGLA_GENERAL';

export interface CuentaPagoGastoResuelta {
  id: string;
  nombre: string;
  moneda: string;
  cuenta_contable_id: string | null;
}

export interface ResultadoCuentaPagoGasto {
  cuenta: CuentaPagoGastoResuelta | null;
  origen: OrigenCuentaPagoGasto | null;
  avisos: string[];
}

export const AVISO_SIN_REGLA_PAGO_GASTO =
  'No existe una regla de Tesorería para "Pago de gasto". Configurá la cuenta en Configuración > Tesorería > Reglas.';
export const AVISO_REGLA_INACTIVA =
  'La regla de Tesorería para "Pago de gasto" está inactiva. Activala en Configuración > Tesorería > Reglas.';
export const AVISO_REGLA_SIN_CUENTA =
  'La regla de Tesorería para "Pago de gasto" no tiene cuenta asignada. Configurá la cuenta en Configuración > Tesorería > Reglas.';
export const AVISO_CUENTA_REGLA_INACTIVA =
  'La cuenta configurada en Tesorería para "Pago de gasto" está inactiva o no existe. Revisala en Configuración > Tesorería > Reglas.';
export const AVISO_REGLA_MEDIO_INACTIVA =
  'La regla de Tesorería "Pago de gasto" del medio está inactiva; se usó la general.';

type Db = Prisma.TransactionClient | PrismaService;

type ReglaLeida = {
  medio_pago_id: string | null;
  moneda_id: string | null;
  activo: boolean;
  cuenta_id: string | null;
  cuenta: {
    id: string;
    nombre: string;
    moneda: string;
    cuenta_contable_id: string | null;
    activo: boolean;
    empresa_id: string;
  } | null;
};

const SELECT_CUENTA = { id: true, nombre: true, moneda: true, cuenta_contable_id: true } as const;

/** Por qué una regla no sirve (null si sirve). */
function problemaDeRegla(regla: ReglaLeida, empresaId: string): string | null {
  if (!regla.activo) return AVISO_REGLA_INACTIVA;
  if (!regla.cuenta_id) return AVISO_REGLA_SIN_CUENTA;
  if (!regla.cuenta || !regla.cuenta.activo || regla.cuenta.empresa_id !== empresaId)
    return AVISO_CUENTA_REGLA_INACTIVA;
  return null;
}

/** Un gasto sin moneda es de guaraníes: para las reglas por moneda vale la fila PYG. */
async function monedaLocalId(db: Db): Promise<string | null> {
  const pyg = await db.moneda.findFirst({ where: { codigo: 'PYG' }, select: { id: true }, orderBy: { id: 'asc' } });
  return pyg?.id ?? null;
}

/** Qué le pasa a una regla salteada, para el aviso (sin el "La regla de Tesorería…"). */
function motivoSalteo(regla: ReglaLeida, empresaId: string): string {
  if (!regla.activo) return 'está inactiva';
  if (!regla.cuenta_id) return 'no tiene cuenta asignada';
  if (!regla.cuenta) return 'tiene una cuenta que no existe';
  return regla.cuenta.empresa_id === empresaId ? 'tiene la cuenta inactiva' : 'tiene una cuenta de otra empresa';
}

const NOMBRE_PASO: Record<OrigenCuentaPagoGasto, string> = {
  CUENTA_ELEGIDA: 'la cuenta elegida',
  REGLA_MEDIO_MONEDA: 'del medio y la moneda',
  REGLA_MEDIO: 'del medio',
  REGLA_GENERAL_MONEDA: 'general de la moneda',
  REGLA_GENERAL: 'general',
};
const USADA: Record<OrigenCuentaPagoGasto, string> = {
  CUENTA_ELEGIDA: 'la cuenta elegida',
  REGLA_MEDIO_MONEDA: 'la del medio y la moneda',
  REGLA_MEDIO: 'la del medio',
  REGLA_GENERAL_MONEDA: 'la general',
  REGLA_GENERAL: 'la general',
};

/** Aviso de una regla salteada. Ej.: 'La regla de Tesorería "Pago de gasto" del medio está inactiva; se usó la general.' */
export const avisoReglaSalteada = (salteada: OrigenCuentaPagoGasto, motivo: string, usada: OrigenCuentaPagoGasto) =>
  `La regla de Tesorería "Pago de gasto" ${NOMBRE_PASO[salteada]} ${motivo}; se usó ${USADA[usada]}.`;

export const AVISO_CUENTA_ELEGIDA_INVALIDA = 'La cuenta elegida en el gasto no está activa o no es de la empresa';
/** Al registrar el pago (egreso o asiento) con una cuenta elegida que dejó de servir. */
export const AVISO_CUENTA_ELEGIDA_NO_SIRVE = `${AVISO_CUENTA_ELEGIDA_INVALIDA}. Elegí otra cuenta en el gasto para registrar el pago.`;

export async function resolverCuentaPagoGasto(
  db: Db,
  empresaId: string,
  o: { cuentaTesoreriaId?: string | null; medioPagoId?: string | null; monedaId?: string | null },
): Promise<ResultadoCuentaPagoGasto> {
  // La cuenta elegida manda (I13): si dejó de servir no se cae a la regla, porque el
  // código no decide de dónde sale la plata. Al guardar, GastosService la rechaza con 400.
  if (o.cuentaTesoreriaId) {
    const elegida = await db.tes_cuentas.findFirst({
      where: { id: o.cuentaTesoreriaId, empresa_id: empresaId, activo: true },
      select: SELECT_CUENTA,
    });
    if (elegida) return { cuenta: elegida, origen: 'CUENTA_ELEGIDA', avisos: [] };
    return { cuenta: null, origen: null, avisos: [AVISO_CUENTA_ELEGIDA_NO_SIRVE] };
  }

  const avisos: string[] = [];

  const medioId = o.medioPagoId ?? null;
  const monedaId = o.monedaId ?? (await monedaLocalId(db));
  const reglas = (await db.tes_reglas.findMany({
    where: { empresa_id: empresaId, tipo_operacion: TES_REGLA_PAGO_GASTO },
    select: {
      medio_pago_id: true,
      moneda_id: true,
      activo: true,
      cuenta_id: true,
      cuenta: { select: { ...SELECT_CUENTA, activo: true, empresa_id: true } },
    },
  })) as ReglaLeida[];

  const pasos: { origen: OrigenCuentaPagoGasto; medio: string | null; moneda: string | null }[] = [];
  if (medioId && monedaId) pasos.push({ origen: 'REGLA_MEDIO_MONEDA', medio: medioId, moneda: monedaId });
  if (medioId) pasos.push({ origen: 'REGLA_MEDIO', medio: medioId, moneda: null });
  if (monedaId) pasos.push({ origen: 'REGLA_GENERAL_MONEDA', medio: null, moneda: monedaId });
  pasos.push({ origen: 'REGLA_GENERAL', medio: null, moneda: null });

  // Toda regla salteada (no solo la del medio) deja su aviso con el motivo real.
  const salteadas: { origen: OrigenCuentaPagoGasto; motivo: string }[] = [];
  let primerProblema: string | null = null;
  for (const paso of pasos) {
    const regla = reglas.find((r) => (r.medio_pago_id ?? null) === paso.medio && (r.moneda_id ?? null) === paso.moneda);
    if (!regla) continue;
    const problema = problemaDeRegla(regla, empresaId);
    if (problema) {
      salteadas.push({ origen: paso.origen, motivo: motivoSalteo(regla, empresaId) });
      primerProblema ??= problema;
      continue;
    }
    const { id, nombre, moneda, cuenta_contable_id } = regla.cuenta!;
    for (const s of salteadas) avisos.push(avisoReglaSalteada(s.origen, s.motivo, paso.origen));
    return { cuenta: { id, nombre, moneda, cuenta_contable_id }, origen: paso.origen, avisos };
  }

  avisos.push(primerProblema ?? AVISO_SIN_REGLA_PAGO_GASTO);
  return { cuenta: null, origen: null, avisos };
}
