import { ConflictException, ForbiddenException } from '@nestjs/common';
import { asegurarSesionesOperables } from './caja-sesion';
import {
  cajasCompartidasConUsuario,
  ENTIDAD_USO_CAJA_COMPARTIDA,
  exigirSesionUsablePorUsuario,
  registrarUsoCajaCompartida,
} from './uso-sesion-caja';

/**
 * Regla única de cobros, ventas y movimientos manuales: la sesión propia, o la
 * de otro usuario solo en una caja asignada específicamente (caja compartida),
 * auditada. Ver uso-sesion-caja.ts.
 */
describe('uso-sesion-caja', () => {
  const sesionNico = {
    id: 'ses-nico',
    caja_id: 'caja-nico',
    user_id: 'nico',
    empresa_id: 'emp',
    estado: 'ABIERTA',
    bloqueado: false,
    cajas: { descripcion: 'Caja Nico' },
    usuario: { nombres: 'Nico', apellidos: 'Pérez', username: 'nico' },
  };
  const db = (opts: { sesion?: any; asignada?: boolean; asignaciones?: any[]; marcadas?: any[] } = {}) => ({
    sesiones_caja: {
      findFirst: jest.fn().mockResolvedValue('sesion' in opts ? opts.sesion : sesionNico),
      findMany: jest.fn().mockResolvedValue('sesion' in opts ? [opts.sesion].filter(Boolean) : [sesionNico]),
    },
    asignacion_sucursal_caja_usuario: {
      findFirst: jest.fn().mockResolvedValue(opts.asignada ? { id: 'asig' } : null),
      findMany: jest
        .fn()
        .mockResolvedValue(opts.asignaciones ?? [{ caja_id: 'caja-nico', sucursal_id: 'suc' }, { caja_id: 'caja-nico', sucursal_id: 'suc' }]),
    },
    cajas: { findMany: jest.fn().mockResolvedValue(opts.marcadas ?? []) },
    audit_logs: { create: jest.fn().mockResolvedValue({}) },
  });
  const args = (usuarioId: string | undefined, accion: any = 'vender') => ({
    sesionId: 'ses-nico',
    usuarioId,
    empresaId: 'emp',
    accion,
  });

  it('la sesión propia se usa sin más (no es compartida)', async () => {
    const d = db();
    await expect(exigirSesionUsablePorUsuario(d as any, args('nico'))).resolves.toMatchObject({ compartida: false });
    expect(d.asignacion_sucursal_caja_usuario.findFirst).not.toHaveBeenCalled();
  });

  it('venta en la caja de otro con solo «todas las cajas»: 403 accionable', async () => {
    const err = await exigirSesionUsablePorUsuario(db() as any, args('yordi')).catch((e) => e);
    expect(err).toBeInstanceOf(ForbiddenException);
    expect(err.message).toBe(
      '«Caja Nico» la abrió Nico Pérez: no podés vender 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.',
    );
  });

  it('superadmin (y holding/reseller) sin asignación específica: también 403, sin excepción', async () => {
    // Decisión del usuario (26/10/2026): el superadmin queda sujeto a la misma regla.
    const d: any = { ...db(), usuario: { findUnique: jest.fn().mockResolvedValue({ is_superadmin: true }) } };
    const err = await exigirSesionUsablePorUsuario(d, args('superadmin', 'cobrar')).catch((e) => e);
    expect(err).toBeInstanceOf(ForbiddenException);
    expect(err.message).toContain('no podés cobrar en la caja de otro usuario');
    expect(d.usuario.findUnique).not.toHaveBeenCalled();
  });

  it('superadmin (o holding/reseller) sin asignación específica: también 403, sin excepción', async () => {
    // La regla no mira is_superadmin ni el tipo de empresa: decisión del usuario 26/10/2026.
    const d: any = db();
    d.usuario = { findUnique: jest.fn().mockResolvedValue({ is_superadmin: true }) };
    await expect(exigirSesionUsablePorUsuario(d, args('soporte', 'cobrar'))).rejects.toBeInstanceOf(ForbiddenException);
    expect(d.usuario.findUnique).not.toHaveBeenCalled();
  });

  it('la asignación que habilita es la de ESA caja (caja_id), no la de la sucursal', async () => {
    const d = db({ asignada: true });
    await expect(exigirSesionUsablePorUsuario(d as any, args('yordi'))).resolves.toMatchObject({
      compartida: true,
      duenio_id: 'nico',
      caja: 'Caja Nico',
    });
    expect(d.asignacion_sucursal_caja_usuario.findFirst).toHaveBeenCalledWith(
      expect.objectContaining({ where: { usuario_id: 'yordi', caja_id: 'caja-nico', sucursal: { empresa_id: 'emp' } } }),
    );
  });

  it('sin usuario identificado no se usa la sesión de nadie', async () => {
    await expect(exigirSesionUsablePorUsuario(db({ asignada: true }) as any, args(undefined))).rejects.toBeInstanceOf(
      ForbiddenException,
    );
  });

  it('sesión de otra empresa: 409', async () => {
    await expect(exigirSesionUsablePorUsuario(db({ sesion: null }) as any, args('nico'))).rejects.toBeInstanceOf(
      ConflictException,
    );
  });

  it('factura cobrada en una caja ya cerrada: error que dice abrir la caja', async () => {
    const d = db({ sesion: { ...sesionNico, estado: 'CERRADA' } });
    await expect(asegurarSesionesOperables(d as any, ['ses-nico'], 'emp')).rejects.toThrow(
      '«Caja Nico» ya está cerrada: abrí la caja de nuevo para vender o cobrar.',
    );
  });

  it('cajas compartidas sin marcar: solo las asignadas una por una, sin repetir', async () => {
    const d = db({ asignaciones: [{ caja_id: 'caja-nico', sucursal_id: 'suc' }, { caja_id: 'caja-nico', sucursal_id: 'suc' }, { caja_id: null, sucursal_id: 'suc' }] });
    await expect(cajasCompartidasConUsuario(d as any, 'yordi', 'emp')).resolves.toEqual(['caja-nico']);
  });

  it('cajas compartidas: suma las marcadas «Caja compartida» de su sucursal, no las de otra', async () => {
    const d = db({
      asignaciones: [{ caja_id: null, sucursal_id: 'suc' }],
      marcadas: [
        { id: 'caja-oficina', sucursal_id: 'suc' },
        { id: 'caja-otra-suc', sucursal_id: 'suc-2' },
      ],
    });
    await expect(cajasCompartidasConUsuario(d as any, 'yordi', 'emp')).resolves.toEqual(['caja-oficina']);
    expect(d.cajas.findMany).toHaveBeenCalledWith(
      expect.objectContaining({ where: { empresas_sucursales: { empresa_id: 'emp' }, pos_config: { caja_compartida: true } } }),
    );
  });

  describe('caja marcada «Caja compartida»', () => {
    const marcada = { ...sesionNico, cajas: { descripcion: 'Caja Nico', sucursal_id: 'suc', pos_config: { caja_compartida: true } } };

    it('con «todas las cajas» de su sucursal se usa, como compartida (se audita)', async () => {
      const d = db({ sesion: marcada, asignaciones: [{ caja_id: null, sucursal_id: 'suc' }] });
      await expect(exigirSesionUsablePorUsuario(d as any, args('adelaida'))).resolves.toMatchObject({ compartida: true, duenio_id: 'nico' });
    });

    it('sin ninguna asignación no se comparte (aunque pueda abrir cualquier caja): 403', async () => {
      const d = db({ sesion: marcada, asignaciones: [] });
      await expect(exigirSesionUsablePorUsuario(d as any, args('adelaida'))).rejects.toBeInstanceOf(ForbiddenException);
    });

    it('asignado solo a otra sucursal u otra caja: 403', async () => {
      const d = db({ sesion: marcada, asignaciones: [{ caja_id: null, sucursal_id: 'suc-2' }, { caja_id: 'caja-x', sucursal_id: 'suc' }] });
      await expect(exigirSesionUsablePorUsuario(d as any, args('adelaida'))).rejects.toBeInstanceOf(ForbiddenException);
    });

    it('sin marcar, «todas las cajas» de la sucursal sigue sin alcanzar', async () => {
      const d = db({ asignaciones: [{ caja_id: null, sucursal_id: 'suc' }] });
      await expect(exigirSesionUsablePorUsuario(d as any, args('adelaida'))).rejects.toBeInstanceOf(ForbiddenException);
      expect(d.asignacion_sucursal_caja_usuario.findMany).not.toHaveBeenCalled();
    });
  });

  it('el uso de una caja compartida queda en audit_logs con quién, de quién, caja, sesión, documento y monto', async () => {
    const d = db({ asignada: true });
    const uso = await exigirSesionUsablePorUsuario(d as any, args('yordi', 'cobrar'));
    await registrarUsoCajaCompartida(d as any, uso, {
      empresaId: 'emp',
      usuarioId: 'yordi',
      tipo: 'recibo_cobro',
      id: 'rec-1',
      numero: '001-001-0009452',
      monto: 150000,
    });
    expect(d.audit_logs.create).toHaveBeenCalledWith({
      data: expect.objectContaining({
        entity_type: ENTIDAD_USO_CAJA_COMPARTIDA,
        entity_id: 'rec-1',
        user_id: 'yordi',
        caja_id: 'caja-nico',
        sesion_caja_id: 'ses-nico',
        descripcion: 'Recibo 001-001-0009452 en «Caja Nico», abierta por Nico Pérez | Monto: 150000',
        new_value: expect.objectContaining({
          documento_tipo: 'recibo_cobro',
          documento_numero: '001-001-0009452',
          monto: 150000,
          usuario_id: 'yordi',
          duenio_sesion_id: 'nico',
          caja: 'Caja Nico',
        }),
      }),
    });
  });

  it('en la caja propia no se audita nada', async () => {
    const d = db();
    const uso = await exigirSesionUsablePorUsuario(d as any, args('nico'));
    await registrarUsoCajaCompartida(d as any, uso, { empresaId: 'emp', usuarioId: 'nico', tipo: 'factura', id: 'f', monto: 1 });
    expect(d.audit_logs.create).not.toHaveBeenCalled();
  });
});
