import { BadRequestException, ConflictException, ForbiddenException } from '@nestjs/common';
import { TesoreriaService } from './tesoreria.service';
import {
  aplicarReversionesPendientes,
  asegurarSesionesOperables,
  contadorDeMedio,
  revertirPagoEnCaja,
  type ResultadoReversionCaja,
} from './caja-sesion';

/**
 * Arreglos de caja narrados como limitaciones en la serie de videos
 * caja-apertura-cierre (C1–C18) y H8 de la serie POS.
 */

const nuevoResultado = (): ResultadoReversionCaja => ({
  revertidosEnSesionOriginal: 0,
  registradosEnSesionActual: 0,
  pendientes: 0,
});

function crearServicio(opts: {
  sesion?: Record<string, unknown> | null;
  config?: Record<string, unknown> | null;
  token?: Record<string, unknown>;
  accesibles?: Array<{ id: string }>;
  superadmin?: boolean;
  privilegio?: boolean;
}) {
  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.posGateway = { notificarCambioSesion: jest.fn() };
  service.contabilidad = { integrarMovimientoTesoreria: jest.fn().mockResolvedValue(undefined) };
  service.cajasAccesibles = jest.fn().mockResolvedValue(opts.accesibles ?? [{ id: 'caja-1' }]);
  service.jwtService = {
    verifyAsync: jest.fn(async (tok: string) => {
      if (tok === 'texto-cualquiera') throw new Error('jwt malformed');
      return { tipo: 'autorizacion_caja', empresa_id: 'emp-1', sub: 'sup-1', operacion: 'cierre_caja', autorizacion_id: 'aut-1', ...opts.token };
    }),
  };
  const tx: any = {
    movimiento_cajas: { create: jest.fn(async ({ data }: any) => ({ id: `mov-${data.descripcion}`, ...data })) },
    sesiones_caja: { update: jest.fn(async ({ data }: any) => data) },
    tes_movimientos: { create: jest.fn(async ({ data }: any) => ({ id: 'tes-mov-1', ...data })) },
    tes_cuentas: { update: jest.fn() },
    autorizaciones_caja: { updateMany: jest.fn().mockResolvedValue({ count: 1 }) },
  };
  service.tx = tx;
  service.prisma = {
    // Ventas por condición de la sesión (informativo): sin facturas ligadas.
    $queryRaw: jest.fn().mockResolvedValue([]),
    sesiones_caja: {
      findFirst: jest.fn().mockResolvedValue(opts.sesion ?? null),
      update: jest.fn(async ({ data }: any) => ({ ...(opts.sesion ?? {}), ...data })),
    },
    pos_config: { findUnique: jest.fn().mockResolvedValue(opts.config ?? null) },
    arqueo_cajas: { create: jest.fn().mockResolvedValue({ id: 'arq-1' }) },
    arqueo_caja_detalle: { createMany: jest.fn() },
    autorizaciones_caja: {
      findFirst: jest.fn().mockResolvedValue(null),
      updateMany: jest.fn().mockResolvedValue({ count: 1 }),
    },
    usuario: { findUnique: jest.fn().mockResolvedValue({ is_superadmin: !!opts.superadmin }) },
    perfiles_privilegios: { findFirst: jest.fn().mockResolvedValue(opts.privilegio ? { id: 'pp' } : null) },
    tipo_movimiento_cajas: { findFirst: jest.fn().mockResolvedValue({ id: 'tipo' }) },
    tes_cuentas: { findFirst: jest.fn() },
    tes_categorias: { findFirst: jest.fn().mockResolvedValue({ id: 'cat-dep' }) },
    $transaction: jest.fn(async (fn: any) => fn(tx)),
  };
  return service;
}

const SESION = {
  id: 'ses-1',
  caja_id: 'caja-1',
  user_id: 'user-1',
  empresa_id: 'emp-1',
  estado: 'ABIERTA',
  bloqueado: false,
  monto_apertura: 100000,
  monto_ventas_efectivo: 50000,
  monto_entradas_manual: 0,
  monto_salidas_manual: 0,
  monto_ventas_otros: 300000,
  cajas: { id: 'caja-1', descripcion: 'Caja 1' },
};

const detalle = [{ tipo: 'efectivo', denominacion: 50000, cantidad: 3, subtotal: 150000 }];

describe('C1 — caja sin configuración guardada', () => {
  it('usa los valores por defecto únicos: arqueo sí, PIN no, sin tolerancia', async () => {
    const service = crearServicio({});
    const cfg = await service.obtenerPosConfig('caja-1');
    expect(cfg).toMatchObject({
      requiere_arqueo_cierre: true,
      requiere_autorizacion_apertura: false,
      requiere_autorizacion_cierre: false,
      diferencia_arqueo_permitida: null,
      tipo_pos: 'admin',
    });
  });

  it('cerrar sin detalle de arqueo se rechaza y dice cómo resolverlo', async () => {
    const service = crearServicio({ sesion: SESION });
    await expect(service.cerrarCaja('ses-1', { monto_cierre: 150000 }, 'emp-1', 'user-1')).rejects.toThrow(/Caja vacía/);
  });
});

describe('C2 — tolerancia de arqueo', () => {
  it('vacío = sin control; 0 = ninguna diferencia', () => {
    const service = crearServicio({});
    expect(service.toleranciaArqueo({ diferencia_arqueo_permitida: null })).toBeNull();
    expect(service.toleranciaArqueo({ diferencia_arqueo_permitida: 0 })).toBe(0);
    expect(service.toleranciaArqueo({ diferencia_arqueo_permitida: '5000.00' })).toBe(5000);
  });

  it('con tolerancia 0, una diferencia de 1 pide PIN', async () => {
    const service = crearServicio({ sesion: SESION, config: { diferencia_arqueo_permitida: 0, requiere_arqueo_cierre: false } });
    await expect(service.cerrarCaja('ses-1', { monto_cierre: 150001 }, 'emp-1', 'user-1')).rejects.toBeInstanceOf(
      ForbiddenException,
    );
  });

  it('sin tolerancia (null), cualquier diferencia cierra sin PIN', async () => {
    const service = crearServicio({ sesion: SESION, config: { diferencia_arqueo_permitida: null, requiere_arqueo_cierre: false } });
    const r = await service.cerrarCaja('ses-1', { monto_cierre: 10 }, 'emp-1', 'user-1');
    expect(r.reporte.estado_cierre).toBe('normal');
  });
});

describe('C3 — el token de cierre se verifica', () => {
  const config = { diferencia_arqueo_permitida: 1000, requiere_arqueo_cierre: false, requiere_autorizacion_cierre: false };

  it('diferencia excedida sin token: 403 con código propio', async () => {
    const service = crearServicio({ sesion: SESION, config });
    await expect(service.cerrarCaja('ses-1', { monto_cierre: 100000 }, 'emp-1', 'user-1')).rejects.toMatchObject({
      response: expect.objectContaining({ codigo: 'CIERRE_REQUIERE_AUTORIZACION' }),
    });
  });

  it('diferencia excedida con un texto cualquiera: rechazado (antes pasaba)', async () => {
    const service = crearServicio({ sesion: SESION, config });
    await expect(
      service.cerrarCaja('ses-1', { monto_cierre: 100000, token_autorizacion: 'texto-cualquiera' }, 'emp-1', 'user-1'),
    ).rejects.toThrow(/inválido o expirado/);
    expect(service.prisma.sesiones_caja.update).not.toHaveBeenCalled();
  });

  it('con un PIN válido cierra con diferencia y guarda quién autorizó', async () => {
    const service = crearServicio({ sesion: SESION, config });
    await service.cerrarCaja('ses-1', { monto_cierre: 100000, token_autorizacion: 'ok' }, 'emp-1', 'user-1');
    expect(service.prisma.sesiones_caja.update).toHaveBeenCalledWith(
      expect.objectContaining({ data: expect.objectContaining({ autorizado_cierre_por: 'sup-1', estado_cierre: 'con_diferencia' }) }),
    );
  });

  it('el efectivo esperado no incluye los otros medios (C7)', async () => {
    const service = crearServicio({ sesion: SESION, config: { requiere_arqueo_cierre: true } });
    const r = await service.cerrarCaja('ses-1', { monto_cierre: 150000, arqueo_detalle: detalle }, 'emp-1', 'user-1');
    expect(r.reporte.monto_final_sistema).toBe(150000);
    expect(r.reporte.ventas_otros).toBe(300000);
  });
});

describe('C15 — quién cierra', () => {
  it('otro usuario sin acceso a la caja ni permiso de supervisor: 403', async () => {
    const service = crearServicio({ sesion: SESION, accesibles: [{ id: 'otra' }] });
    await expect(service.iniciarCierre('ses-1', 'emp-1', 'user-2')).rejects.toThrow(/la cierra quien la abrió/);
  });

  it('un supervisor sí puede', async () => {
    const service = crearServicio({ sesion: SESION, accesibles: [{ id: 'otra' }], privilegio: true });
    await expect(service.exigirPuedeCerrar(SESION, 'emp-1', 'user-2')).resolves.toBeUndefined();
  });

  it('el dueño de la sesión siempre', async () => {
    const service = crearServicio({ sesion: SESION, accesibles: [] });
    await expect(service.exigirPuedeCerrar(SESION, 'emp-1', 'user-1')).resolves.toBeUndefined();
  });
});

describe('C13 — cancelar cierre con PIN', () => {
  it('pide el PIN de la operación cancelar_cierre', async () => {
    const service = crearServicio({ sesion: { ...SESION, bloqueado: true }, config: { requiere_autorizacion_cierre: true } });
    await expect(service.cancelarCierre('ses-1', 'emp-1', 'user-1')).rejects.toMatchObject({
      response: expect.objectContaining({ codigo: 'CANCELAR_CIERRE_REQUIERE_AUTORIZACION' }),
    });
    await expect(service.cancelarCierre('ses-1', 'emp-1', 'user-1', 'tok')).rejects.toThrow(/otra operación/);
  });
});

describe('H8 — sesión ajena: solo la de una caja compartida', () => {
  const conAsignadas = (service: any, cajas: string[], extra: { todaLaSucursal?: string; marcadas?: any[] } = {}) => {
    const asignaciones = cajas.map((caja_id) => ({ caja_id, sucursal_id: 'suc-1' }));
    if (extra.todaLaSucursal) asignaciones.push({ caja_id: null as any, sucursal_id: extra.todaLaSucursal });
    service.prisma.asignacion_sucursal_caja_usuario = { findMany: jest.fn().mockResolvedValue(asignaciones) };
    service.prisma.cajas = { ...service.prisma.cajas, findMany: jest.fn().mockResolvedValue(extra.marcadas ?? []) };
    return service;
  };

  it('sin sesión propia, ofrece la de otro solo si la caja está asignada específicamente (es_compartida)', async () => {
    const service = conAsignadas(crearServicio({ accesibles: [{ id: 'caja-1' }, { id: 'caja-2' }] }), ['caja-1']);
    service.prisma.sesiones_caja.findFirst = jest
      .fn()
      .mockResolvedValueOnce(null)
      .mockResolvedValueOnce({ ...SESION, user_id: 'otro' });
    const r = await service.getSesionActiva('emp-1', undefined, 'user-1');
    expect(r.es_ajena).toBe(true);
    expect(r.es_compartida).toBe(true);
    expect(service.prisma.sesiones_caja.findFirst.mock.calls[1][0].where.caja_id).toEqual({ in: ['caja-1'] });
  });

  it('asignado solo a «todas las cajas» de la sucursal: no ofrece la caja de otro cajero', async () => {
    const service = conAsignadas(crearServicio({ accesibles: [{ id: 'caja-1' }, { id: 'caja-2' }] }), []);
    service.prisma.sesiones_caja.findFirst = jest.fn().mockResolvedValue(null);
    expect(await service.getSesionActiva('emp-1', undefined, 'user-1')).toBeNull();
    expect(service.prisma.sesiones_caja.findFirst).toHaveBeenCalledTimes(1);
  });

  it('caja marcada «Caja compartida»: con «todas las cajas» de su sucursal se ofrece la de otro', async () => {
    const service = conAsignadas(crearServicio({ accesibles: [{ id: 'caja-1' }, { id: 'caja-2' }] }), [], {
      todaLaSucursal: 'suc-1',
      marcadas: [{ id: 'caja-2', sucursal_id: 'suc-1' }],
    });
    service.prisma.sesiones_caja.findFirst = jest
      .fn()
      .mockResolvedValueOnce(null)
      .mockResolvedValueOnce({ ...SESION, caja_id: 'caja-2', user_id: 'otro' });
    const r = await service.getSesionActiva('emp-1', undefined, 'user-1');
    expect(r.es_compartida).toBe(true);
    expect(service.prisma.sesiones_caja.findFirst.mock.calls[1][0].where.caja_id).toEqual({ in: ['caja-2'] });
  });

  it('superadmin sin caja propia ni asignación específica: tampoco (sin excepción silenciosa)', async () => {
    const service = conAsignadas(crearServicio({ superadmin: true, accesibles: [{ id: 'caja-1' }] }), []);
    service.prisma.sesiones_caja.findFirst = jest.fn().mockResolvedValue(null);
    expect(await service.getSesionActiva('emp-1', undefined, 'user-1')).toBeNull();
  });
});

describe('Una autorización se usa una sola vez (PIN presencial o remota)', () => {
  const config = { diferencia_arqueo_permitida: 1000, requiere_arqueo_cierre: false, requiere_autorizacion_cierre: true };

  it('el cierre marca la autorización como utilizada antes de cerrar', async () => {
    const service = crearServicio({ sesion: SESION, config });
    await service.cerrarCaja('ses-1', { monto_cierre: 100000, token_autorizacion: 'ok' }, 'emp-1', 'user-1');
    expect(service.prisma.autorizaciones_caja.updateMany).toHaveBeenCalledWith({
      where: { id: 'aut-1', empresa_id: 'emp-1', estado: 'aprobada' },
      data: { estado: 'utilizada' },
    });
  });

  it('un token ya usado da 403 «esta autorización ya se usó» y no cierra', async () => {
    const service = crearServicio({ sesion: SESION, config });
    service.prisma.autorizaciones_caja.updateMany.mockResolvedValue({ count: 0 });
    await expect(
      service.cerrarCaja('ses-1', { monto_cierre: 100000, token_autorizacion: 'ok' }, 'emp-1', 'user-1'),
    ).rejects.toThrow(/Esta autorización ya se usó/);
    expect(service.prisma.sesiones_caja.update).not.toHaveBeenCalled();
  });

  it('un token sin autorización registrada no sirve', async () => {
    const service = crearServicio({ sesion: SESION, config, token: { autorizacion_id: undefined } });
    await expect(
      service.cerrarCaja('ses-1', { monto_cierre: 100000, token_autorizacion: 'ok' }, 'emp-1', 'user-1'),
    ).rejects.toThrow(ForbiddenException);
    expect(service.prisma.sesiones_caja.update).not.toHaveBeenCalled();
  });

  it('corregir apertura con un token ya usado: 403 y no corrige', async () => {
    const service = crearServicio({
      sesion: SESION,
      token: { operacion: 'corregir_apertura', contexto: { sesion_id: 'ses-1', monto_apertura: 120000 } },
    });
    service.tx.autorizaciones_caja.updateMany.mockResolvedValue({ count: 0 });
    await expect(
      service.corregirApertura('ses-1', { monto_apertura: 120000, motivo: 'x', token_autorizacion: 't' }, 'emp-1', 'user-1'),
    ).rejects.toThrow(/ya se usó/);
    expect(service.tx.sesiones_caja.update).not.toHaveBeenCalled();
  });
});

describe('C6 — corregir apertura', () => {
  it('exige PIN de corregir_apertura para ese monto y esa sesión, y audita', async () => {
    const service = crearServicio({
      sesion: SESION,
      token: { operacion: 'corregir_apertura', contexto: { sesion_id: 'ses-1', monto_apertura: 120000 } },
    });
    await service.corregirApertura('ses-1', { monto_apertura: 120000, motivo: 'faltó', token_autorizacion: 't' }, 'emp-1', 'user-1');
    // La autorización se consume en la misma transacción que la corrección.
    expect(service.tx.autorizaciones_caja.updateMany).toHaveBeenCalledWith({
      where: { id: 'aut-1', empresa_id: 'emp-1', estado: 'aprobada' },
      data: { estado: 'utilizada' },
    });
    expect(service.tx.sesiones_caja.update).toHaveBeenCalledWith(
      expect.objectContaining({ data: expect.objectContaining({ monto_apertura: 120000 }) }),
    );
    expect(service.auditService.log).toHaveBeenCalledWith(
      expect.objectContaining({ old_value: { monto_apertura: 100000 } }),
    );
  });

  it('un PIN para otro monto no sirve', async () => {
    const service = crearServicio({
      sesion: SESION,
      token: { operacion: 'corregir_apertura', contexto: { sesion_id: 'ses-1', monto_apertura: 999 } },
    });
    await expect(
      service.corregirApertura('ses-1', { monto_apertura: 120000, motivo: 'x', token_autorizacion: 't' }, 'emp-1', 'user-1'),
    ).rejects.toThrow(/otro monto/);
  });
});

describe('C10 — transferencia entre cajas', () => {
  it('salida en origen y entrada en destino en una transacción', async () => {
    const service = crearServicio({});
    service.prisma.sesiones_caja.findFirst = jest.fn(async ({ where }: any) => (where.id === 'ses-1' ? SESION : { ...SESION, id: 'ses-2', caja_id: 'caja-2', cajas: { descripcion: 'Caja 2' } }));
    await service.transferirEntreCajas({ sesion_origen_id: 'ses-1', sesion_destino_id: 'ses-2', monto: 50000 }, 'emp-1', 'user-1');
    expect(service.tx.movimiento_cajas.create).toHaveBeenCalledTimes(2);
    expect(service.tx.sesiones_caja.update).toHaveBeenCalledWith({
      where: { id: 'ses-1' },
      data: expect.objectContaining({ monto_salidas_manual: { increment: 50000 } }),
    });
    expect(service.tx.sesiones_caja.update).toHaveBeenCalledWith({
      where: { id: 'ses-2' },
      data: expect.objectContaining({ monto_entradas_manual: { increment: 50000 } }),
    });
  });

  it('no transfiere más que el efectivo esperado', async () => {
    const service = crearServicio({});
    service.prisma.sesiones_caja.findFirst = jest.fn(async ({ where }: any) => (where.id === 'ses-1' ? SESION : { ...SESION, id: 'ses-2' }));
    await expect(
      service.transferirEntreCajas({ sesion_origen_id: 'ses-1', sesion_destino_id: 'ses-2', monto: 999999 }, 'emp-1', 'user-1'),
    ).rejects.toBeInstanceOf(BadRequestException);
  });

  it('destino EN CIERRE: 409', async () => {
    const service = crearServicio({});
    service.prisma.sesiones_caja.findFirst = jest.fn(async ({ where }: any) => (where.id === 'ses-1' ? SESION : { ...SESION, id: 'ses-2', bloqueado: true }));
    await expect(
      service.transferirEntreCajas({ sesion_origen_id: 'ses-1', sesion_destino_id: 'ses-2', monto: 10 }, 'emp-1', 'user-1'),
    ).rejects.toBeInstanceOf(ConflictException);
  });
});

describe('Mover plata del arqueo: solo caja propia o compartida (uso-sesion-caja.ts)', () => {
  const ajena = { ...SESION, user_id: 'otro', usuario: { nombres: 'Nico', apellidos: null, username: 'nico' } };
  const conAsignada = (service: any, cajas: string[]) => {
    service.prisma.asignacion_sucursal_caja_usuario = {
      findFirst: jest.fn(async ({ where }: any) => (cajas.includes(where.caja_id) ? { id: 'asig' } : null)),
    };
    service.tx.audit_logs = { create: jest.fn().mockResolvedValue({}) };
    return service;
  };

  it('depósito desde la caja de otro con solo acceso por sucursal: 403', async () => {
    const service = conAsignada(crearServicio({ sesion: ajena, accesibles: [{ id: 'caja-1' }] }), []);
    await expect(
      service.depositarEnBanco({ sesion_id: 'ses-1', cuenta_id: 'cta-1', monto: 1 }, 'emp-1', 'user-1'),
    ).rejects.toThrow(/«Caja 1» la abrió Nico: no podés mover plata/);
  });

  it('superadmin tampoco tiene excepción', async () => {
    const service = conAsignada(crearServicio({ sesion: ajena, superadmin: true }), []);
    await expect(
      service.depositarEnBanco({ sesion_id: 'ses-1', cuenta_id: 'cta-1', monto: 1 }, 'emp-1', 'user-1'),
    ).rejects.toBeInstanceOf(ForbiddenException);
  });

  it('corregir apertura en la caja de otro: 403 aunque traiga PIN de supervisor', async () => {
    const service = conAsignada(crearServicio({ sesion: ajena }), []);
    await expect(
      service.corregirApertura('ses-1', { monto_apertura: 120000, motivo: 'x', token_autorizacion: 't' }, 'emp-1', 'user-1'),
    ).rejects.toThrow(/no podés corregir la apertura/);
    expect(service.jwtService.verifyAsync).not.toHaveBeenCalled();
  });

  it('transferencia desde una caja compartida: auditada con el dueño de origen y el de destino', async () => {
    const service = conAsignada(crearServicio({}), ['caja-1']);
    service.prisma.sesiones_caja.findFirst = jest.fn(async ({ where }: any) =>
      where.id === 'ses-1'
        ? ajena
        : { ...SESION, id: 'ses-2', caja_id: 'caja-2', user_id: 'dest', cajas: { descripcion: 'Caja 2' }, usuario: { nombres: 'Ana', apellidos: 'Gómez' } },
    );
    await service.transferirEntreCajas({ sesion_origen_id: 'ses-1', sesion_destino_id: 'ses-2', monto: 1000 }, 'emp-1', 'user-1');
    expect(service.tx.audit_logs.create).toHaveBeenCalledWith(
      expect.objectContaining({
        data: expect.objectContaining({
          entity_type: 'uso_caja_compartida',
          sesion_caja_id: 'ses-1',
          new_value: expect.objectContaining({ duenio_sesion_id: 'otro', duenio_destino_id: 'dest', duenio_destino: 'Ana Gómez' }),
        }),
      }),
    );
    expect(service.auditService.log).toHaveBeenCalledWith(
      expect.objectContaining({
        entity_type: 'transferencia_caja',
        new_value: expect.objectContaining({ duenio_origen_id: 'otro', duenio_destino_id: 'dest', origen_caja_compartida: true }),
      }),
    );
  });
});

describe('C17 — depósito a banco', () => {
  it('salida en la caja + ingreso confirmado en Tesorería con contrapartida CAJA_GENERAL', async () => {
    const service = crearServicio({ sesion: SESION });
    service.prisma.tes_cuentas.findFirst.mockResolvedValue({ id: 'cta-1', nombre: 'Banco X', moneda: 'PYG', cuenta_contable_id: 'cc-1' });
    const r = await service.depositarEnBanco({ sesion_id: 'ses-1', cuenta_id: 'cta-1', monto: 100000, referencia: '123' }, 'emp-1', 'user-1');
    expect(service.tx.tes_movimientos.create).toHaveBeenCalledWith({
      data: expect.objectContaining({
        tipo: 'INGRESO',
        estado: 'CONFIRMADO',
        origen_tipo: 'CAJA_DEPOSITO',
        detalles: { create: [expect.objectContaining({ concepto_contable: 'CAJA_GENERAL', categoria_id: 'cat-dep' })] },
      }),
    });
    expect(service.tx.tes_cuentas.update).toHaveBeenCalledWith({ where: { id: 'cta-1' }, data: { saldo_actual: { increment: 100000 } } });
    expect(service.contabilidad.integrarMovimientoTesoreria).toHaveBeenCalledWith('tes-mov-1');
    expect(r.aviso_contable).toBeNull();
  });

  it('si el asiento falla, el depósito queda y se avisa al usuario', async () => {
    const service = crearServicio({ sesion: SESION });
    service.prisma.tes_cuentas.findFirst.mockResolvedValue({ id: 'cta-1', nombre: 'Banco X', moneda: 'PYG' });
    service.contabilidad.integrarMovimientoTesoreria.mockRejectedValue(new Error('sin período'));
    const r = await service.depositarEnBanco({ sesion_id: 'ses-1', cuenta_id: 'cta-1', monto: 1 }, 'emp-1', 'user-1');
    expect(r.aviso_contable).toMatch(/sin período/);
  });

  it('cuenta sin cuenta contable en una empresa con contabilidad: avisa que no hubo asiento', async () => {
    const service = crearServicio({ sesion: SESION });
    service.prisma.tes_cuentas.findFirst.mockResolvedValue({ id: 'cta-1', nombre: 'Banco X', moneda: 'PYG', cuenta_contable_id: null });
    service.prisma.cont_plan_cuentas = { findFirst: jest.fn().mockResolvedValue({ id: 'pc-1' }) };
    const r = await service.depositarEnBanco({ sesion_id: 'ses-1', cuenta_id: 'cta-1', monto: 1 }, 'emp-1', 'user-1');
    expect(r.aviso_contable).toMatch(/no tiene cuenta contable/);
  });

  it('cuenta sin cuenta contable en una empresa sin contabilidad: sin aviso', async () => {
    const service = crearServicio({ sesion: SESION });
    service.prisma.tes_cuentas.findFirst.mockResolvedValue({ id: 'cta-1', nombre: 'Banco X', moneda: 'PYG', cuenta_contable_id: null });
    service.prisma.cont_plan_cuentas = { findFirst: jest.fn().mockResolvedValue(null) };
    const r = await service.depositarEnBanco({ sesion_id: 'ses-1', cuenta_id: 'cta-1', monto: 1 }, 'emp-1', 'user-1');
    expect(r.aviso_contable).toBeNull();
  });

  it('cuenta en otra moneda: rechazado', async () => {
    const service = crearServicio({ sesion: SESION });
    service.prisma.tes_cuentas.findFirst.mockResolvedValue({ id: 'cta-1', nombre: 'USD', moneda: 'USD' });
    await expect(
      service.depositarEnBanco({ sesion_id: 'ses-1', cuenta_id: 'cta-1', monto: 1 }, 'emp-1', 'user-1'),
    ).rejects.toThrow(/guaraníes/);
  });
});

describe('caja-sesion — reglas compartidas', () => {
  it('C7: cheque, billetera y QR van a «otros»', () => {
    expect(contadorDeMedio(1)).toBe('efectivo');
    expect(contadorDeMedio(3)).toBe('tarjeta');
    expect(contadorDeMedio(5)).toBe('transferencia');
    expect(contadorDeMedio(2)).toBe('otros');
    expect(contadorDeMedio(7)).toBe('otros');
  });

  it('C12: sesión cerrada o EN CIERRE no recibe operaciones (409)', async () => {
    const tx: any = { sesiones_caja: { findMany: jest.fn() } };
    tx.sesiones_caja.findMany.mockResolvedValue([{ id: 's', empresa_id: 'e', estado: 'CERRADA', bloqueado: false, cajas: null }]);
    await expect(asegurarSesionesOperables(tx, ['s'], 'e')).rejects.toThrow(/ya está cerrada/);
    tx.sesiones_caja.findMany.mockResolvedValue([{ id: 's', empresa_id: 'e', estado: 'ABIERTA', bloqueado: true, cajas: null }]);
    await expect(asegurarSesionesOperables(tx, ['s'], 'e')).rejects.toThrow(/EN CIERRE/);
    tx.sesiones_caja.findMany.mockResolvedValue([{ id: 's', empresa_id: 'otra', estado: 'ABIERTA', bloqueado: false, cajas: null }]);
    await expect(asegurarSesionesOperables(tx, ['s'], 'e')).rejects.toBeInstanceOf(ConflictException);
    tx.sesiones_caja.findMany.mockResolvedValue([{ id: 's', empresa_id: 'e', estado: 'ABIERTA', bloqueado: false, cajas: null }]);
    await expect(asegurarSesionesOperables(tx, ['s', null], 'e')).resolves.toBeUndefined();
  });

  const txReversion = (original: any, actual: any) => ({
    sesiones_caja: {
      findUnique: jest.fn().mockResolvedValue(original),
      findFirst: jest.fn().mockResolvedValue(actual),
      update: jest.fn(),
    },
    movimiento_cajas: { create: jest.fn() },
    caja_reversiones_pendientes: { create: jest.fn() },
    $executeRawUnsafe: jest.fn(),
  });
  const args = (tx: any, codigo: number, resultado: ResultadoReversionCaja) => ({
    pago: { sesionId: 's-orig', codigoMedio: codigo, descripcionMedio: 'X', monto: 1000 },
    empresaId: 'e',
    referenciaId: 'ref',
    origen: 'RECIBO' as const,
    descripcion: 'Anulación Recibo 1',
    contadorEfectivo: 'monto_entradas_manual' as const,
    tipoMovSalidaId: 't',
    resultado,
  });

  it('C9: sesión original abierta → se descuenta del acumulador correcto', async () => {
    const tx = txReversion({ id: 's-orig', caja_id: 'c', estado: 'ABIERTA' }, null);
    const r = nuevoResultado();
    await revertirPagoEnCaja(tx as any, args(tx, 1, r));
    expect(tx.$executeRawUnsafe.mock.calls[0][0]).toContain('monto_entradas_manual');
    await revertirPagoEnCaja(tx as any, args(tx, 2, r));
    expect(tx.$executeRawUnsafe.mock.calls[1][0]).toContain('monto_ventas_otros');
    expect(r.revertidosEnSesionOriginal).toBe(2);
  });

  it('C9: sesión original cerrada → no toca su arqueo; el efectivo sale de la sesión abierta', async () => {
    const tx = txReversion({ id: 's-orig', caja_id: 'c', estado: 'CERRADA' }, { id: 's-hoy' });
    const r = nuevoResultado();
    await revertirPagoEnCaja(tx as any, args(tx, 1, r));
    expect(tx.$executeRawUnsafe).not.toHaveBeenCalled();
    expect(tx.sesiones_caja.update).toHaveBeenCalledWith(
      expect.objectContaining({ where: { id: 's-hoy' }, data: expect.objectContaining({ monto_salidas_manual: { increment: 1000 } }) }),
    );
    // Tarjeta de una sesión cerrada: no sale del cajón, solo queda el movimiento.
    await revertirPagoEnCaja(tx as any, args(tx, 3, r));
    expect(tx.sesiones_caja.update).toHaveBeenCalledTimes(1);
    expect(r.registradosEnSesionActual).toBe(2);
  });

  it('C8: sin sesión abierta queda pendiente (antes solo un log)', async () => {
    const tx = txReversion({ id: 's-orig', caja_id: 'c', estado: 'CERRADA' }, null);
    const r = nuevoResultado();
    await revertirPagoEnCaja(tx as any, args(tx, 1, r));
    expect(tx.caja_reversiones_pendientes.create).toHaveBeenCalledWith({
      data: expect.objectContaining({ caja_id: 'c', referencia_id: 'ref', origen: 'RECIBO', monto: 1000 }),
    });
    expect(r.pendientes).toBe(1);
  });

  it('C8: la próxima apertura aplica las pendientes (el efectivo sale del cajón)', async () => {
    const tx: any = {
      caja_reversiones_pendientes: {
        findMany: jest.fn().mockResolvedValue([
          { id: 'p1', monto: 1000, medio_pago_codigo: 1, descripcion: 'Anulación Fact. 1', referencia_id: 'f1' },
          { id: 'p2', monto: 500, medio_pago_codigo: 3, descripcion: 'Anulación Fact. 2', referencia_id: 'f2' },
        ]),
        update: jest.fn(),
      },
      tipo_movimiento_cajas: { findFirst: jest.fn().mockResolvedValue({ id: 't' }) },
      sesiones_caja: { update: jest.fn() },
      movimiento_cajas: { create: jest.fn() },
    };
    const aplicadas = await aplicarReversionesPendientes(tx, { cajaId: 'c', sesionId: 'nueva', empresaId: 'e', usuarioId: 'u' });
    expect(aplicadas).toHaveLength(2);
    expect(tx.sesiones_caja.update).toHaveBeenCalledTimes(1);
    expect(tx.caja_reversiones_pendientes.update).toHaveBeenCalledWith(
      expect.objectContaining({ where: { id: 'p1' }, data: expect.objectContaining({ sesion_aplicada_id: 'nueva' }) }),
    );
  });
});

describe('C17 — asiento de la diferencia al cerrar', () => {
  const config = { requiere_arqueo_cierre: false, diferencia_arqueo_permitida: null };

  it('sin el concepto mapeado la caja se cierra igual y se avisa qué mapear', async () => {
    const service = crearServicio({ sesion: SESION, config });
    service.contabilidad.integrarDiferenciaArqueo = jest.fn().mockResolvedValue({ conceptos_faltantes: ['CAJA_FALTANTE'] });
    const r = await service.cerrarCaja('ses-1', { monto_cierre: 140000 }, 'emp-1', 'user-1');
    expect(service.prisma.sesiones_caja.update).toHaveBeenCalled();
    expect(service.contabilidad.integrarDiferenciaArqueo).toHaveBeenCalledWith('arq-1');
    expect(r.aviso_contable).toMatch(/mapeá el concepto CAJA_FALTANTE en Contabilidad › Mapeo de cuentas/);
  });

  it('mapeado: sin aviso; sin diferencia: ni se intenta', async () => {
    const service = crearServicio({ sesion: SESION, config });
    service.contabilidad.integrarDiferenciaArqueo = jest.fn().mockResolvedValue({ conceptos_faltantes: [] });
    expect((await service.cerrarCaja('ses-1', { monto_cierre: 140000 }, 'emp-1', 'user-1')).aviso_contable).toBeNull();
    service.contabilidad.integrarDiferenciaArqueo.mockClear();
    await service.cerrarCaja('ses-1', { monto_cierre: 150000 }, 'emp-1', 'user-1');
    expect(service.contabilidad.integrarDiferenciaArqueo).not.toHaveBeenCalled();
  });

  it('si el asiento falla por otra causa, se avisa y el cierre queda', async () => {
    const service = crearServicio({ sesion: SESION, config });
    service.contabilidad.integrarDiferenciaArqueo = jest.fn().mockRejectedValue(new Error('sin período abierto'));
    const r = await service.cerrarCaja('ses-1', { monto_cierre: 1 }, 'emp-1', 'user-1');
    expect(r.aviso_contable).toMatch(/sin período abierto/);
  });
});
