import { BadRequestException } from '@nestjs/common';
import { RendicionViaticosTesoreriaService } from './rendicion-viaticos-tesoreria.service';
import { RendicionViaticosContabilidadService } from './rendicion-viaticos-contabilidad.service';

/**
 * Reversión de adelantos y devoluciones dentro de la transacción que anula la
 * rendición (C3, I6): el movimiento se toma condicionado a CONFIRMADO y el saldo
 * vuelve una sola vez; un movimiento conciliado frena todo; el asiento se revierte
 * con el mismo tx (un período cerrado deshace la anulación entera).
 */
function txTesoreria(mov: Record<string, unknown> | null, opts: { tomado?: number; conciliado?: boolean } = {}) {
  return {
    tes_movimientos: {
      findFirst: jest.fn().mockResolvedValue(mov),
      updateMany: jest.fn().mockResolvedValue({ count: opts.tomado ?? 1 }),
    },
    tes_extracto_lineas: { findFirst: jest.fn().mockResolvedValue(opts.conciliado ? { id: 'l1' } : null) },
    tes_cuentas: { update: jest.fn().mockResolvedValue({}) },
    tes_cheques: { updateMany: jest.fn().mockResolvedValue({ count: 0 }) },
  } as any;
}

describe('RendicionViaticosTesoreriaService.revertir* con tx', () => {
  const prisma: any = { $transaction: jest.fn(), tes_movimientos: { findFirst: jest.fn() } };
  const service = new RendicionViaticosTesoreriaService(prisma);
  const egreso = { id: 'm1', tipo: 'EGRESO', monto: 300, cuenta_id: 'c1' };

  it('adelanto: lee y escribe en el tx, toma el movimiento condicionado y devuelve el saldo', async () => {
    const tx = txTesoreria(egreso);
    await service.revertirAdelanto(tx, 'ad1', 'emp');
    expect(prisma.$transaction).not.toHaveBeenCalled();
    expect(prisma.tes_movimientos.findFirst).not.toHaveBeenCalled();
    expect(tx.tes_movimientos.updateMany).toHaveBeenCalledWith(
      expect.objectContaining({ where: { id: 'm1', estado: 'CONFIRMADO' } }),
    );
    expect(tx.tes_cuentas.update).toHaveBeenCalledWith({ where: { id: 'c1' }, data: { saldo_actual: { increment: 300 } } });
    // El cheque emitido con el movimiento, si sigue en cartera, se anula con el mismo tx.
    expect(tx.tes_cheques.updateMany).toHaveBeenCalledWith(
      expect.objectContaining({ where: { movimiento_id: 'm1', estado: { in: ['EN_CARTERA', 'DIFERIDO'] } }, data: expect.objectContaining({ estado: 'ANULADO' }) }),
    );
  });

  it('doble anulación: si otro ya tomó el movimiento, el saldo no se suma otra vez', async () => {
    const tx = txTesoreria(egreso, { tomado: 0 });
    await service.revertirAdelanto(tx, 'ad1', 'emp');
    expect(tx.tes_cuentas.update).not.toHaveBeenCalled();
    expect(tx.tes_cheques.updateMany).not.toHaveBeenCalled();
  });

  it('devolución INGRESO: resta el saldo, una sola vez', async () => {
    const tx = txTesoreria({ id: 'm2', tipo: 'INGRESO', monto: 50, cuenta_id: 'c2' });
    await service.revertirDevolucion(tx, 'dev1', 'emp');
    expect(tx.tes_cuentas.update).toHaveBeenCalledWith({ where: { id: 'c2' }, data: { saldo_actual: { decrement: 50 } } });
  });

  it('movimiento conciliado con el extracto: 400 y no lo toca', async () => {
    const tx = txTesoreria(egreso, { conciliado: true });
    await expect(service.revertirAdelanto(tx, 'ad1', 'emp')).rejects.toThrow(BadRequestException);
    expect(tx.tes_movimientos.updateMany).not.toHaveBeenCalled();
  });
});

describe('RendicionViaticosContabilidadService.revertir* con tx', () => {
  const armar = () => {
    const asientos = { revertir: jest.fn().mockResolvedValue({}) };
    const prisma: any = {
      suscripcion_modulos: { findFirst: jest.fn().mockResolvedValue({ id: 'mod' }) },
      cont_documentos: { findFirst: jest.fn() },
    };
    const tx: any = { cont_documentos: { findFirst: jest.fn().mockResolvedValue({ asiento: { id: 'as-1' } }) } };
    const service = Object.create(RendicionViaticosContabilidadService.prototype) as any;
    service.prisma = prisma;
    service.asientos = asientos;
    service.logger = { log: jest.fn() };
    return { service, asientos, tx, prisma };
  };

  it('adelanto: busca el documento y revierte el asiento con el tx y el usuario real', async () => {
    const { service, asientos, tx, prisma } = armar();
    await service.revertirAdelanto(tx, 'ad1', 'emp', 'u1');
    expect(prisma.cont_documentos.findFirst).not.toHaveBeenCalled();
    expect(asientos.revertir).toHaveBeenCalledWith('as-1', 'emp', 'u1', tx);
  });

  it('devolución: el error del asiento (período cerrado) llega al llamador', async () => {
    const { service, asientos, tx } = armar();
    asientos.revertir.mockRejectedValue(new BadRequestException('No se puede revertir: el período 08/2026 del asiento está CERRADO.'));
    await expect(service.revertirDevolucion(tx, 'dev1', 'emp', 'u1')).rejects.toThrow('08/2026');
  });
});
