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

/**
 * Quién puede hacer entrar (o salir) plata de una sesión de caja.
 *
 * Comercial Kety, 23/10/2026: Yordi cobró sin tener su caja abierta y los
 * recibos entraron en la Caja Nico y en su cierre. Yordi estaba asignado a
 * «todas las cajas de la sucursal», y eso alcanzaba para operar en la caja que
 * había abierto otro cajero. La regla, igual para cobros, ventas y movimientos
 * manuales:
 *
 *   1. Se opera en una sesión abierta por el MISMO usuario.
 *   2. Caja compartida: en la sesión que abrió otro usuario solo si esa caja
 *      está asignada ESPECÍFICAMENTE al que opera (asignación con caja_id = esa
 *      caja). La asignación a toda la sucursal (caja_id null) no alcanza: sirve
 *      para elegir qué caja abrir, no para usar la abierta de otro.
 *   3. Caja marcada «Caja compartida» en su configuración POS
 *      (`pos_config.caja_compartida`, 27/10/2026, oficinas donde todos los
 *      administrativos venden en un mismo punto): alcanza con tener la caja
 *      asignada, puntual o por «Todas las cajas» de su sucursal. Sin ninguna
 *      asignación no se comparte, aunque al abrir `cajasAccesibles` lo deje
 *      elegir cualquier caja: usar la sesión de otro exige una asignación
 *      explícita. Lo decide quien configura la caja (ADM_POSCFG_EDITAR), no el
 *      que vende.
 *   4. Cualquier otra sesión ajena se rechaza (403) diciendo de quién es.
 *
 * Superadmin, holding y reseller no tienen excepción: si la tuvieran, una venta
 * de soporte entraría sin aviso en el arqueo de un cajero (el mismo problema).
 * Pueden abrir su propia caja o hacerse asignar la caja puntual.
 *
 * Cada uso de una caja compartida queda en audit_logs (entity_type
 * `uso_caja_compartida`) para rastrearlo.
 */

export const ENTIDAD_USO_CAJA_COMPARTIDA = 'uso_caja_compartida';

type Db = Pick<Prisma.TransactionClient, 'sesiones_caja' | 'asignacion_sucursal_caja_usuario'>;

type Asignacion = { caja_id: string | null; sucursal_id: string | null };

/** ¿Tiene la caja asignada? La caja misma o toda su sucursal («Todas las cajas»). */
function tieneCajaAsignada(asignaciones: Asignacion[], caja: { id: string; sucursal_id: string | null }): boolean {
  return asignaciones.some((a) => a.caja_id === caja.id || (!a.caja_id && !!a.sucursal_id && a.sucursal_id === caja.sucursal_id));
}

export type SesionUsable = {
  sesion_id: string;
  caja_id: string | null;
  caja: string;
  duenio_id: string | null;
  duenio: string;
  /** true: la abrió otro usuario y se usa por asignación específica de la caja. */
  compartida: boolean;
};

export type AccionCaja = 'cobrar' | 'vender' | 'registrar movimientos' | 'mover plata' | 'corregir la apertura';

const nombreUsuario = (u?: { nombres?: string | null; apellidos?: string | null; username?: string | null } | null) =>
  [u?.nombres, u?.apellidos].filter(Boolean).join(' ').trim() || u?.username || 'otro usuario';

/**
 * Cajas cuya sesión ajena el usuario puede usar: las asignadas una por una y
 * las marcadas «Caja compartida» que tiene asignadas (puntual o por sucursal).
 */
export async function cajasCompartidasConUsuario(
  db: Pick<Prisma.TransactionClient, 'asignacion_sucursal_caja_usuario' | 'cajas'>,
  usuarioId: string,
  empresaId: string,
): Promise<string[]> {
  const asignaciones = await db.asignacion_sucursal_caja_usuario.findMany({
    where: { usuario_id: usuarioId, sucursal: { empresa_id: empresaId } },
    select: { caja_id: true, sucursal_id: true },
  });
  const marcadas = await db.cajas.findMany({
    where: { empresas_sucursales: { empresa_id: empresaId }, pos_config: { caja_compartida: true } },
    select: { id: true, sucursal_id: true },
  });
  const ids = [
    ...asignaciones.map((a) => a.caja_id),
    ...marcadas.filter((c) => tieneCajaAsignada(asignaciones, c)).map((c) => c.id),
  ];
  return [...new Set(ids.filter((id): id is string => !!id))];
}

/**
 * Devuelve la sesión si el usuario puede operar en ella (propia o compartida
 * por asignación específica); si no, 403 con el nombre de la caja y de quien
 * la abrió. No valida el estado (ABIERTA / EN CIERRE): eso es
 * `asegurarSesionesOperables`.
 */
export async function exigirSesionUsablePorUsuario(
  db: Db,
  args: { sesionId: string; usuarioId: string | null | undefined; empresaId: string; accion: AccionCaja },
): Promise<SesionUsable> {
  const sesion = await db.sesiones_caja.findFirst({
    where: { id: args.sesionId, empresa_id: args.empresaId },
    select: {
      id: true,
      caja_id: true,
      user_id: true,
      cajas: { select: { descripcion: true, sucursal_id: true, pos_config: { select: { caja_compartida: true } } } },
      usuario: { select: { nombres: true, apellidos: true, username: true } },
    },
  });
  if (!sesion) {
    throw new ConflictException('La caja indicada no existe en esta empresa. Actualizá la pantalla y volvé a intentar.');
  }
  const uso: SesionUsable = {
    sesion_id: sesion.id,
    caja_id: sesion.caja_id,
    caja: sesion.cajas?.descripcion ?? 'la caja',
    duenio_id: sesion.user_id,
    duenio: nombreUsuario(sesion.usuario),
    compartida: false,
  };
  if (args.usuarioId && sesion.user_id === args.usuarioId) return uso;

  const asignada =
    !!args.usuarioId &&
    !!sesion.caja_id &&
    (await db.asignacion_sucursal_caja_usuario.findFirst({
      where: { usuario_id: args.usuarioId, caja_id: sesion.caja_id, sucursal: { empresa_id: args.empresaId } },
      select: { id: true },
    })) !== null;
  if (asignada) return { ...uso, compartida: true };

  if (args.usuarioId && sesion.caja_id && sesion.cajas?.pos_config?.caja_compartida) {
    const asignaciones = await db.asignacion_sucursal_caja_usuario.findMany({
      where: { usuario_id: args.usuarioId, sucursal: { empresa_id: args.empresaId } },
      select: { caja_id: true, sucursal_id: true },
    });
    if (tieneCajaAsignada(asignaciones, { id: sesion.caja_id, sucursal_id: sesion.cajas.sucursal_id })) {
      return { ...uso, compartida: true };
    }
  }

  throw new ForbiddenException(
    `«${uso.caja}» la abrió ${uso.duenio}: no podés ${args.accion} en la caja de otro usuario. ` +
      'Abrí tu propia caja (desde el Punto de Venta o en Finanzas › Caja del Día). Si esa caja se comparte entre varios, ' +
      'pedí que te la asignen a vos (Configuración › Usuarios › Asignaciones, eligiendo esa caja) o que la marquen ' +
      '«Caja compartida» en Configuración › Puntos de Venta › Configuración POS › Seguridad de Caja.',
  );
}

export type TipoDocumentoCaja =
  | 'recibo_cobro'
  | 'factura'
  | 'movimiento_caja'
  | 'deposito_banco'
  | 'anulacion_deposito'
  | 'transferencia_caja'
  | 'correccion_apertura';

const ETIQUETA_DOCUMENTO: Record<TipoDocumentoCaja, string> = {
  recibo_cobro: 'Recibo',
  factura: 'Factura',
  movimiento_caja: 'Movimiento',
  deposito_banco: 'Depósito a banco',
  anulacion_deposito: 'Anulación de depósito',
  transferencia_caja: 'Transferencia',
  correccion_apertura: 'Corrección de apertura',
};

/**
 * Deja en audit_logs el uso de una caja compartida. Va dentro de la misma
 * transacción que el documento: si no se puede auditar, no se opera.
 */
export async function registrarUsoCajaCompartida(
  tx: Pick<Prisma.TransactionClient, 'audit_logs'>,
  uso: SesionUsable,
  doc: {
    empresaId: string;
    usuarioId: string | null | undefined;
    tipo: TipoDocumentoCaja;
    id: string;
    numero?: string | null;
    monto: number;
    moneda?: string | null;
    /** Datos propios de la operación (p. ej. la caja destino de una transferencia). */
    extra?: Record<string, unknown>;
  },
): Promise<void> {
  if (!uso.compartida) return;
  const etiqueta = ETIQUETA_DOCUMENTO[doc.tipo];
  await tx.audit_logs.create({
    data: {
      empresa_id: doc.empresaId,
      user_id: doc.usuarioId ?? null,
      action: 'CREATE',
      entity_type: ENTIDAD_USO_CAJA_COMPARTIDA,
      entity_id: doc.id,
      caja_id: uso.caja_id,
      sesion_caja_id: uso.sesion_id,
      descripcion: `${etiqueta} ${doc.numero ?? ''} en «${uso.caja}», abierta por ${uso.duenio} | Monto: ${doc.monto}`
        .replace(/\s+/g, ' ')
        .slice(0, 255),
      new_value: {
        documento_tipo: doc.tipo,
        documento_id: doc.id,
        documento_numero: doc.numero ?? null,
        monto: doc.monto,
        moneda: doc.moneda ?? null,
        usuario_id: doc.usuarioId ?? null,
        duenio_sesion_id: uso.duenio_id,
        duenio_sesion: uso.duenio,
        caja_id: uso.caja_id,
        caja: uso.caja,
        sesion_caja_id: uso.sesion_id,
        ...(doc.extra ?? {}),
      },
    },
  });
}
