import { ConflictException } from '@nestjs/common';
import { Prisma } from '@prisma/client';

/**
 * Reglas compartidas de la sesión de caja: qué acumulador toca cada medio de
 * pago, cuándo una sesión puede recibir operaciones y cómo se devuelve la plata
 * de un comprobante anulado. Las usan la venta (facturas), el cobro (recibos),
 * la anulación y la apertura, para que no vuelvan a divergir.
 */

/** Códigos SIFEN de medio de pago. */
export const MEDIO_EFECTIVO = 1;
export const MEDIOS_TARJETA = [3, 4, 8];
export const MEDIO_TRANSFERENCIA = 5;

export type ContadorMedio = 'efectivo' | 'tarjeta' | 'transferencia' | 'otros';

/**
 * A qué acumulador va un medio. Todo lo que no es efectivo, tarjeta ni
 * transferencia (cheque, billetera, QR, vale…) va a «otros», que NO suma al
 * efectivo esperado: antes iba a entradas manuales y el arqueo pedía en billetes
 * la plata de un cheque.
 */
export function contadorDeMedio(codigo: number | null | undefined): ContadorMedio {
  if (codigo === MEDIO_EFECTIVO) return 'efectivo';
  if (codigo != null && MEDIOS_TARJETA.includes(codigo)) return 'tarjeta';
  if (codigo === MEDIO_TRANSFERENCIA) return 'transferencia';
  return 'otros';
}

/** Columna de `sesiones_caja` de cada acumulador de venta. */
export const COLUMNA_VENTA: Record<ContadorMedio, string> = {
  efectivo: 'monto_ventas_efectivo',
  tarjeta: 'monto_ventas_tarjeta',
  transferencia: 'monto_ventas_transferencia',
  otros: 'monto_ventas_otros',
};

type SesionMontos = {
  monto_apertura?: unknown;
  monto_ventas_efectivo?: unknown;
  monto_entradas_manual?: unknown;
  monto_salidas_manual?: unknown;
};

/** Efectivo que tiene que haber en el cajón: apertura + ventas en efectivo + entradas − salidas. */
export function efectivoEsperado(s: SesionMontos): number {
  return (
    (Number(s.monto_apertura) || 0) +
    (Number(s.monto_ventas_efectivo) || 0) +
    (Number(s.monto_entradas_manual) || 0) -
    (Number(s.monto_salidas_manual) || 0)
  );
}

/**
 * Las sesiones donde va a entrar plata tienen que ser de la empresa, estar
 * ABIERTAS y no estar EN CIERRE. Antes la venta sumaba incluso en una sesión
 * CERRADA y «EN CIERRE» era solo una marca: la pantalla decía «caja bloqueada
 * para operaciones» y se seguía vendiendo y cobrando.
 */
export async function asegurarSesionesOperables(
  tx: Pick<Prisma.TransactionClient, 'sesiones_caja'>,
  sesionIds: Array<string | null | undefined>,
  empresa_id: string,
): Promise<void> {
  const ids = [...new Set(sesionIds.filter((id): id is string => !!id))];
  if (!ids.length) return;
  const sesiones = await tx.sesiones_caja.findMany({
    where: { id: { in: ids } },
    select: { id: true, empresa_id: true, estado: true, bloqueado: true, cajas: { select: { descripcion: true } } },
  });
  for (const id of ids) {
    const s = sesiones.find((x) => x.id === id);
    if (!s || s.empresa_id !== empresa_id) {
      throw new ConflictException('La caja indicada no existe en esta empresa. Actualizá la pantalla y volvé a intentar.');
    }
    const nombre = s.cajas?.descripcion ?? 'la caja';
    if (s.estado !== 'ABIERTA') {
      throw new ConflictException(`«${nombre}» ya está cerrada: abrí la caja de nuevo para vender o cobrar.`);
    }
    if (s.bloqueado) {
      throw new ConflictException(
        `«${nombre}» está EN CIERRE: terminá el cierre o cancelalo desde Finanzas › Caja del Día para seguir operando.`,
      );
    }
  }
}

/** Descuento atómico con piso en 0 sobre un acumulador de la sesión. */
async function restarDeColumna(tx: Prisma.TransactionClient, sesionId: string, columna: string, monto: number) {
  // La columna sale de una lista cerrada (COLUMNA_VENTA o entradas manuales), nunca del usuario.
  await tx.$executeRawUnsafe(
    `UPDATE sesiones_caja SET ${columna} = GREATEST(COALESCE(${columna}, 0) - $1, 0), updated_at = NOW() WHERE id = $2::uuid`,
    monto,
    sesionId,
  );
}

export type PagoARevertir = {
  sesionId: string;
  codigoMedio: number | null;
  descripcionMedio: string;
  monto: number;
};

export type ResultadoReversionCaja = {
  revertidosEnSesionOriginal: number;
  registradosEnSesionActual: number;
  pendientes: number;
};

/**
 * Devuelve en caja un pago de un comprobante anulado.
 *
 * - Sesión original ABIERTA: se descuenta del mismo acumulador que sumó el pago.
 * - Sesión original CERRADA (su arqueo no se toca): si el pago fue en efectivo,
 *   sale del cajón de la sesión abierta de esa caja; los demás medios no salen
 *   del cajón (se devuelven por la procesadora o el banco) y solo queda el
 *   movimiento para la trazabilidad.
 * - La caja no tiene sesión abierta: queda como devolución pendiente y se aplica
 *   sola en la próxima apertura (antes solo se escribía un aviso en el log).
 *
 * `contadorEfectivo` es la columna donde el origen sumó el efectivo: la venta lo
 * pone en ventas en efectivo; el cobro, en entradas manuales.
 */
export async function revertirPagoEnCaja(
  tx: Prisma.TransactionClient,
  args: {
    pago: PagoARevertir;
    empresaId: string;
    referenciaId: string;
    origen: 'FACTURA' | 'RECIBO';
    descripcion: string;
    contadorEfectivo: 'monto_ventas_efectivo' | 'monto_entradas_manual';
    usuarioId?: string | null;
    tipoMovSalidaId: string | null;
    resultado: ResultadoReversionCaja;
  },
): Promise<void> {
  const { pago, empresaId, referenciaId, origen, descripcion, contadorEfectivo, usuarioId, tipoMovSalidaId, resultado } =
    args;
  if (!(pago.monto > 0)) return;
  const contador = contadorDeMedio(pago.codigoMedio);
  const sesionOriginal = await tx.sesiones_caja.findUnique({
    where: { id: pago.sesionId },
    select: { id: true, caja_id: true, estado: true },
  });
  if (!sesionOriginal) return;

  const movimiento = (sesionId: string, texto: string) =>
    tx.movimiento_cajas.create({
      data: {
        sesion_id: sesionId,
        empresa_id: empresaId,
        tipo_movimiento_caja_id: tipoMovSalidaId,
        monto: pago.monto,
        descripcion: texto,
        referencia: referenciaId,
        usuario_id: usuarioId ?? null,
        fecha_mov: new Date().toISOString(),
      },
    });

  if (sesionOriginal.estado === 'ABIERTA') {
    const columna = contador === 'efectivo' ? contadorEfectivo : COLUMNA_VENTA[contador];
    await restarDeColumna(tx, sesionOriginal.id, columna, pago.monto);
    await movimiento(sesionOriginal.id, descripcion);
    resultado.revertidosEnSesionOriginal += 1;
    return;
  }

  const sesionActual = sesionOriginal.caja_id
    ? await tx.sesiones_caja.findFirst({
        where: { caja_id: sesionOriginal.caja_id, empresa_id: empresaId, estado: 'ABIERTA' },
        orderBy: { fecha_apertura: 'desc' },
        select: { id: true },
      })
    : null;

  if (!sesionActual) {
    if (!sesionOriginal.caja_id) return;
    await tx.caja_reversiones_pendientes.create({
      data: {
        empresa_id: empresaId,
        caja_id: sesionOriginal.caja_id,
        referencia_id: referenciaId,
        origen,
        medio_pago_codigo: pago.codigoMedio,
        monto: pago.monto,
        descripcion: `${descripcion} (cobrada en una sesión ya cerrada)`,
        sesion_original_id: sesionOriginal.id,
      },
    });
    resultado.pendientes += 1;
    return;
  }

  if (contador === 'efectivo') {
    await tx.sesiones_caja.update({
      where: { id: sesionActual.id },
      data: { monto_salidas_manual: { increment: pago.monto }, updated_at: new Date() },
    });
  }
  await movimiento(sesionActual.id, `${descripcion} (cobrada en una sesión ya cerrada)`);
  resultado.registradosEnSesionActual += 1;
}

/**
 * Aplica, en la sesión que se acaba de abrir, las devoluciones que quedaron
 * pendientes porque la caja estaba cerrada. Devuelve lo aplicado para avisarle
 * al cajero.
 */
export async function aplicarReversionesPendientes(
  tx: Prisma.TransactionClient,
  args: { cajaId: string; sesionId: string; empresaId: string; usuarioId: string },
): Promise<Array<{ descripcion: string; monto: number; sale_del_cajon: boolean; entra_al_cajon?: boolean }>> {
  const pendientes = await tx.caja_reversiones_pendientes.findMany({
    where: { caja_id: args.cajaId, empresa_id: args.empresaId, aplicada_at: null },
    orderBy: { created_at: 'asc' },
  });
  if (!pendientes.length) return [];
  const tipoMovSalida = await tx.tipo_movimiento_cajas.findFirst({
    where: { descripcion: { contains: 'Salida', mode: 'insensitive' } },
    select: { id: true },
  });
  const aplicadas: Array<{ descripcion: string; monto: number; sale_del_cajon: boolean; entra_al_cajon?: boolean }> = [];
  for (const p of pendientes) {
    const monto = Number(p.monto) || 0;
    // Un depósito a banco anulado con la caja cerrada es plata que VUELVE al cajón.
    if (p.origen === 'DEPOSITO_BANCO') {
      await registrarEntradaDeDeposito(tx, {
        sesionId: args.sesionId,
        empresaId: args.empresaId,
        depositoId: p.referencia_id,
        monto,
        descripcion: `${p.descripcion} | Pendiente aplicado al abrir`,
        usuarioId: args.usuarioId,
      });
      await tx.caja_reversiones_pendientes.update({
        where: { id: p.id },
        data: { aplicada_at: new Date(), sesion_aplicada_id: args.sesionId },
      });
      aplicadas.push({ descripcion: p.descripcion, monto, sale_del_cajon: false, entra_al_cajon: true });
      continue;
    }
    const saleDelCajon = contadorDeMedio(p.medio_pago_codigo) === 'efectivo';
    if (saleDelCajon && monto > 0) {
      await tx.sesiones_caja.update({
        where: { id: args.sesionId },
        data: { monto_salidas_manual: { increment: monto }, updated_at: new Date() },
      });
    }
    await tx.movimiento_cajas.create({
      data: {
        sesion_id: args.sesionId,
        empresa_id: args.empresaId,
        tipo_movimiento_caja_id: tipoMovSalida?.id ?? null,
        monto,
        descripcion: `${p.descripcion} | Devolución pendiente aplicada al abrir`,
        referencia: p.referencia_id,
        usuario_id: args.usuarioId,
        fecha_mov: new Date().toISOString(),
      },
    });
    await tx.caja_reversiones_pendientes.update({
      where: { id: p.id },
      data: { aplicada_at: new Date(), sesion_aplicada_id: args.sesionId },
    });
    aplicadas.push({ descripcion: p.descripcion, monto, sale_del_cajon: saleDelCajon });
  }
  return aplicadas;
}

// ==================== DEPÓSITO A BANCO ANULADO ====================

/** Categoría del movimiento de caja que genera «Depositar en banco» (C17). */
export const CATEGORIA_DEPOSITO_BANCO = 'DEPOSITO_BANCO';
/** Categoría de la entrada que devuelve al cajón un depósito anulado. */
export const CATEGORIA_DEPOSITO_ANULADO = 'DEPOSITO_ANULADO';

export type EfectoAnulacionDeposito = 'MISMA_SESION' | 'SESION_ACTUAL' | 'PENDIENTE_APERTURA';

/** Entrada al cajón por un depósito anulado (suma a entradas manuales: vuelve al efectivo esperado). */
async function registrarEntradaDeDeposito(
  tx: Prisma.TransactionClient,
  args: { sesionId: string; empresaId: string; depositoId: string; monto: number; descripcion: string; usuarioId: string | null },
) {
  const tipoEntrada = await tx.tipo_movimiento_cajas.findFirst({
    where: { descripcion: { contains: 'Entrada', mode: 'insensitive' } },
    select: { id: true },
  });
  await tx.sesiones_caja.update({
    where: { id: args.sesionId },
    data: { monto_entradas_manual: { increment: args.monto }, updated_at: new Date() },
  });
  return tx.movimiento_cajas.create({
    data: {
      sesion_id: args.sesionId,
      empresa_id: args.empresaId,
      tipo_movimiento_caja_id: tipoEntrada?.id ?? null,
      monto: args.monto,
      descripcion: args.descripcion,
      categoria: CATEGORIA_DEPOSITO_ANULADO,
      // El id del movimiento del depósito: une la entrada con la salida que anula.
      referencia: args.depositoId,
      usuario_id: args.usuarioId,
      fecha_mov: new Date().toISOString(),
    },
  });
}

/**
 * Devuelve al cajón el efectivo de un depósito a banco anulado. Es la inversa
 * de `revertirPagoEnCaja` (acá la plata ENTRA) con la misma regla:
 *
 * - Sesión del depósito ABIERTA: entrada en esa misma sesión.
 * - Sesión del depósito CERRADA (su arqueo no se toca): entrada en la sesión
 *   abierta de esa caja.
 * - La caja no tiene sesión abierta: queda pendiente y entra en la próxima
 *   apertura (`aplicarReversionesPendientes`).
 *
 * Una sesión EN CIERRE no recibe la entrada: el arqueo que se está contando no
 * la incluiría.
 */
export async function devolverDepositoACaja(
  tx: Prisma.TransactionClient,
  args: {
    depositoId: string;
    sesionDepositoId: string;
    empresaId: string;
    monto: number;
    descripcion: string;
    usuarioId: string | null;
  },
): Promise<EfectoAnulacionDeposito> {
  const original = await tx.sesiones_caja.findUnique({
    where: { id: args.sesionDepositoId },
    select: { id: true, caja_id: true, estado: true, bloqueado: true, cajas: { select: { descripcion: true } } },
  });
  if (!original) {
    throw new ConflictException('La sesión de caja del depósito ya no existe: no se puede devolver el efectivo.');
  }
  const nombre = original.cajas?.descripcion ?? 'la caja';
  const enCierre = () =>
    new ConflictException(
      `«${nombre}» está EN CIERRE: terminá o cancelá el cierre en Finanzas › Caja del Día y después anulá el depósito.`,
    );

  if (original.estado === 'ABIERTA') {
    if (original.bloqueado) throw enCierre();
    await registrarEntradaDeDeposito(tx, { ...args, sesionId: original.id });
    return 'MISMA_SESION';
  }

  const actual = original.caja_id
    ? await tx.sesiones_caja.findFirst({
        where: { caja_id: original.caja_id, empresa_id: args.empresaId, estado: 'ABIERTA' },
        orderBy: { fecha_apertura: 'desc' },
        select: { id: true, bloqueado: true },
      })
    : null;
  if (actual) {
    if (actual.bloqueado) throw enCierre();
    await registrarEntradaDeDeposito(tx, {
      ...args,
      sesionId: actual.id,
      descripcion: `${args.descripcion} (depositado en una sesión ya cerrada)`,
    });
    return 'SESION_ACTUAL';
  }

  if (!original.caja_id) {
    throw new ConflictException(`La sesión del depósito no tiene caja: no se puede devolver el efectivo.`);
  }
  await tx.caja_reversiones_pendientes.create({
    data: {
      empresa_id: args.empresaId,
      caja_id: original.caja_id,
      referencia_id: args.depositoId,
      origen: 'DEPOSITO_BANCO',
      medio_pago_codigo: MEDIO_EFECTIVO,
      monto: args.monto,
      descripcion: `${args.descripcion} (depositado en una sesión ya cerrada)`,
      sesion_original_id: original.id,
    },
  });
  return 'PENDIENTE_APERTURA';
}
