import { BadRequestException, ForbiddenException, NotFoundException } from '@nestjs/common';
import { TesoreriaService } from './tesoreria.service';

/**
 * Las Entradas y Salidas manuales de Caja del Día se guardaban en la PRIMERA sesión
 * abierta de la empresa (`findFirst({ empresa_id, estado: 'ABIERTA' })`), no en la
 * caja cuya tarjeta se tocó. Con dos cajas abiertas, la plata quedaba en la otra:
 * su arqueo no cerraba y la caja correcta mostraba faltante.
 *
 * Ahora la pantalla manda la sesión de la tarjeta y el servidor la valida; sin
 * sesión, se usa la caja abierta del propio usuario y nunca una cualquiera.
 */
describe('TesoreriaService.registrarMovimiento — va a la caja correcta', () => {
  const sesiones = [
    { id: 'ses-otra', caja_id: 'caja-otra', empresa_id: 'emp-1', user_id: 'user-2', estado: 'ABIERTA' },
    { id: 'ses-mia', caja_id: 'caja-mia', empresa_id: 'emp-1', user_id: 'user-1', estado: 'ABIERTA' },
    { id: 'ses-cerrada', caja_id: 'caja-mia', empresa_id: 'emp-1', user_id: 'user-1', estado: 'CERRADA' },
    { id: 'ses-ajena', caja_id: 'caja-x', empresa_id: 'emp-2', user_id: 'user-9', estado: 'ABIERTA' },
  ];

  // `asignadas`: cajas asignadas al usuario UNA POR UNA (caja compartida).
  const crear = (accesibles = ['caja-otra', 'caja-mia'], asignadas: string[] = []) => {
    const service = Object.create(TesoreriaService.prototype) as any;
    service.logger = { log: jest.fn(), warn: jest.fn(), error: jest.fn() };
    service.auditService = { log: jest.fn().mockResolvedValue(undefined) };
    service.cajasAccesibles = jest.fn().mockResolvedValue(accesibles.map((id) => ({ id })));
    service.prisma = {
      sesiones_caja: {
        findFirst: jest.fn(async ({ where }: any) =>
          sesiones.find(
            (s) =>
              (where.id === undefined || s.id === where.id) &&
              s.empresa_id === where.empresa_id &&
              (where.user_id === undefined || s.user_id === where.user_id) &&
              (where.estado === undefined || s.estado === where.estado),
          ) ?? null,
        ),
        update: jest.fn().mockResolvedValue({}),
      },
      tipo_movimiento_cajas: { findFirst: jest.fn().mockResolvedValue({ id: 'tipo-1' }) },
      movimiento_cajas: { create: jest.fn(async ({ data }: any) => ({ id: 'mov-1', ...data })) },
      asignacion_sucursal_caja_usuario: {
        findFirst: jest.fn(async ({ where }: any) => (asignadas.includes(where.caja_id) ? { id: 'asig' } : null)),
      },
      audit_logs: { create: jest.fn().mockResolvedValue({}) },
    };
    service.prisma.$transaction = jest.fn(async (fn: any) => fn(service.prisma));
    return service;
  };

  const dto = (extra: object = {}) => ({ tipo: 'ENTRADA' as const, monto: 100000, concepto: 'Cambio', ...extra });

  it('con sesion_id, el movimiento va a esa sesión aunque haya otra abierta antes', async () => {
    const service = crear();

    await service.registrarMovimiento(dto({ sesion_id: 'ses-mia' }), 'emp-1', 'user-1');

    expect(service.prisma.movimiento_cajas.create).toHaveBeenCalledWith(
      expect.objectContaining({ data: expect.objectContaining({ sesion_id: 'ses-mia' }) }),
    );
    expect(service.prisma.sesiones_caja.update).toHaveBeenCalledWith(expect.objectContaining({ where: { id: 'ses-mia' } }));
  });

  it('sin sesion_id usa la caja abierta del propio usuario, no la primera de la empresa', async () => {
    const service = crear();

    await service.registrarMovimiento(dto(), 'emp-1', 'user-1');

    expect(service.prisma.movimiento_cajas.create).toHaveBeenCalledWith(
      expect.objectContaining({ data: expect.objectContaining({ sesion_id: 'ses-mia' }) }),
    );
  });

  it('sin sesion_id y sin caja propia abierta, avisa en vez de elegir una cualquiera', async () => {
    const service = crear();

    await expect(service.registrarMovimiento(dto(), 'emp-1', 'user-3')).rejects.toBeInstanceOf(BadRequestException);
    expect(service.prisma.movimiento_cajas.create).not.toHaveBeenCalled();
  });

  it('rechaza una sesión cerrada', async () => {
    const service = crear();

    await expect(service.registrarMovimiento(dto({ sesion_id: 'ses-cerrada' }), 'emp-1', 'user-1')).rejects.toBeInstanceOf(
      BadRequestException,
    );
  });

  it('rechaza una sesión de otra empresa', async () => {
    const service = crear();

    await expect(service.registrarMovimiento(dto({ sesion_id: 'ses-ajena' }), 'emp-1', 'user-1')).rejects.toBeInstanceOf(
      NotFoundException,
    );
  });

  it('rechaza la caja que abrió otro usuario aunque tenga acceso a toda la sucursal (403)', async () => {
    const service = crear(['caja-otra', 'caja-mia']);

    const err = await service.registrarMovimiento(dto({ sesion_id: 'ses-otra' }), 'emp-1', 'user-1').catch((e: any) => e);
    expect(err).toBeInstanceOf(ForbiddenException);
    expect(err.message).toMatch(/Abrí tu propia caja/);
    expect(service.prisma.movimiento_cajas.create).not.toHaveBeenCalled();
  });

  it('caja compartida (asignada específicamente): registra y deja auditoría', async () => {
    const service = crear(['caja-otra', 'caja-mia'], ['caja-otra']);

    await service.registrarMovimiento(dto({ sesion_id: 'ses-otra' }), 'emp-1', 'user-1');

    expect(service.prisma.movimiento_cajas.create).toHaveBeenCalled();
    expect(service.prisma.audit_logs.create).toHaveBeenCalledWith(
      expect.objectContaining({
        data: expect.objectContaining({ entity_type: 'uso_caja_compartida', sesion_caja_id: 'ses-otra', user_id: 'user-1' }),
      }),
    );
  });

  it('en su propia caja no deja registro de caja compartida', async () => {
    const service = crear();

    await service.registrarMovimiento(dto({ sesion_id: 'ses-mia' }), 'emp-1', 'user-1');

    expect(service.prisma.audit_logs.create).not.toHaveBeenCalled();
  });
});
