import { BadRequestException, ConflictException } from '@nestjs/common';
import { Prisma } from '@prisma/client';
import { RendicionViaticosService } from './rendicion-viaticos.service';

/**
 * Anular una rendición o quitarle un gasto: el motivo es el del usuario, la rendición
 * se identifica con su id ante GastosService y un gasto que no se puede anular frena
 * todo antes de tocar adelantos, devoluciones o el estado de la rendición.
 */

const GASTOS = [
  { id: 'g1', numero_factura: '001-001-0000001', descripcion: null, fecha_emision: new Date('2026-10-05'), proveedores: null },
  { id: 'g2', numero_factura: null, descripcion: 'Almuerzo', fecha_emision: new Date('2026-10-05'), proveedores: null },
];

function armar(opts: { falla?: string; estado?: string; tomada?: number } = {}) {
  const rendicion = {
    id: 'rv-1',
    empresa_id: 'emp',
    numero_rendicion: 'RV-000007',
    estado: opts.estado ?? 'APROBADA',
    adelantos: [{ id: 'ad1', tes_movimiento_id: 'm1', cont_documento_id: 'd1' }],
    devoluciones: [{ id: 'dev1', tes_movimiento_id: 'm2', cont_documento_id: null, cxp_empleado_id: 'cxpe-1' }],
    gastos: GASTOS,
  };
  const orden: string[] = [];
  const paso = (nombre: string, valor?: any) => jest.fn().mockImplementation(async () => (orden.push(nombre), valor));
  const tx: any = {
    rendicion_viatico: {
      updateMany: paso('tomar', { count: opts.tomada ?? 1 }),
      findFirst: jest.fn().mockImplementation(async () => (orden.push('leer'), rendicion)),
    },
    rendicion_devolucion: { updateMany: paso('devoluciones-anuladas', {}) },
    rendicion_adelanto: { updateMany: paso('adelantos-anulados', {}) },
    cuentas_pagar_empleado: { update: paso('cxp-empleado', {}) },
  };
  const prisma: any = {
    rendicion_viatico: {
      findFirst: jest
        .fn()
        .mockImplementation(({ include }) =>
          include
            ? rendicion
            : { id: rendicion.id, estado: rendicion.estado, numero_rendicion: rendicion.numero_rendicion },
        ),
    },
    gasto_cab: { findFirst: jest.fn().mockResolvedValue({ id: 'g2', anulado: false }) },
    // bloqueosDeAnulacion: sin asientos en períodos cerrados, conciliaciones, cheques fuera de
    // cartera, reintegros pagados, recibos ni pagos (cada test que quiere un bloqueo lo pone).
    cont_documentos: { findMany: jest.fn().mockResolvedValue([]) },
    tes_movimientos: { findMany: jest.fn().mockResolvedValue([]) },
    tes_extracto_lineas: { findMany: jest.fn().mockResolvedValue([]) },
    tes_cheques: { findMany: jest.fn().mockResolvedValue([]) },
    cuentas_pagar_empleado: { count: jest.fn().mockResolvedValue(0) },
    rec_multi_gastos: { findMany: jest.fn().mockResolvedValue([]) },
    cuentas_pagar: { findMany: jest.fn().mockResolvedValue([]) },
    pagos_proveedor: { findMany: jest.fn().mockResolvedValue([]) },
    $transaction: jest.fn().mockImplementation((fn: any) => fn(tx)),
  };
  const gastos = {
    verificarAnulable: jest.fn().mockImplementation(async (id: string) => {
      if (id === opts.falla)
        throw new BadRequestException('El gasto tiene la NC N° 12 vigente. Anulá primero la nota de crédito.');
    }),
    anular: jest.fn().mockResolvedValue({}),
    anularEnTx: jest.fn().mockImplementation(async (_tx: any, id: string) => void orden.push(`gasto ${id}`)),
  };
  const tesoreria = { revertirDevolucion: paso('tes-devolucion'), revertirAdelanto: paso('tes-adelanto') };
  const contabilidad = { revertirDevolucion: paso('cont-devolucion'), revertirAdelanto: paso('cont-adelanto') };
  const audit = { log: jest.fn() };
  const service = new RendicionViaticosService(prisma, audit as any, contabilidad as any, tesoreria as any, gastos as any);
  jest.spyOn(service, 'findOne').mockResolvedValue({ id: 'rv-1' } as any);
  jest.spyOn(service as any, 'recalcularTotales').mockResolvedValue(undefined);
  return { service, prisma, tx, gastos, tesoreria, contabilidad, orden, audit };
}

describe('RendicionViaticosService.anular', () => {
  it('todo en una sola transacción: toma la rendición, anula los gastos y revierte con el mismo tx', async () => {
    const { service, gastos, tesoreria, contabilidad, tx, prisma, orden } = armar();

    await service.anular('emp', 'rv-1', '  Viaje cancelado  ', 'u1');

    expect(prisma.$transaction).toHaveBeenCalledTimes(1);
    expect(gastos.anular).not.toHaveBeenCalled();
    expect(gastos.anularEnTx).toHaveBeenCalledWith(tx, 'g1', 'emp', 'u1', 'Rendición RV-000007 anulada: Viaje cancelado', {
      rendicionId: 'rv-1',
    });
    expect(tesoreria.revertirDevolucion).toHaveBeenCalledWith(tx, 'dev1', 'emp');
    expect(contabilidad.revertirDevolucion).toHaveBeenCalledWith(tx, 'dev1', 'emp', 'u1');
    expect(tesoreria.revertirAdelanto).toHaveBeenCalledWith(tx, 'ad1', 'emp');
    expect(contabilidad.revertirAdelanto).toHaveBeenCalledWith(tx, 'ad1', 'emp', 'u1');
    // La toma condicional es lo primero (bloquea la fila) y la rendición se relee en el tx.
    expect(orden.slice(0, 2)).toEqual(['tomar', 'leer']);
    expect(orden.indexOf('tomar')).toBeLessThan(orden.indexOf('gasto g1'));
    expect(orden.indexOf('gasto g2')).toBeLessThan(orden.indexOf('tes-devolucion'));
    expect(tx.cuentas_pagar_empleado.update).toHaveBeenCalledWith(
      expect.objectContaining({ where: { id: 'cxpe-1' }, data: expect.objectContaining({ estado: 'anulada' }) }),
    );
  });

  // I6: la rendición se toma de forma condicional, dentro del tx.
  it('se toma con updateMany condicionado al estado y graba el motivo del usuario', async () => {
    const { service, tx } = armar();
    await service.anular('emp', 'rv-1', 'Viaje cancelado', 'u1');
    const { where, data } = tx.rendicion_viatico.updateMany.mock.calls[0][0];
    expect(where).toEqual({ id: 'rv-1', empresa_id: 'emp', estado: { not: 'ANULADA' } });
    expect(data).toMatchObject({ estado: 'ANULADA', motivo_anulacion: 'Viaje cancelado', anulado_por: 'u1' });
  });

  it('doble anulación: si otro ya la tomó (count 0) → 400 y no se anula ni revierte nada', async () => {
    const { service, gastos, tesoreria } = armar({ tomada: 0 });
    await expect(service.anular('emp', 'rv-1', 'Viaje cancelado', 'u1')).rejects.toThrow('La rendición ya está anulada');
    expect(gastos.anularEnTx).not.toHaveBeenCalled();
    expect(tesoreria.revertirAdelanto).not.toHaveBeenCalled();
  });

  it('si un gasto no se puede anular: 400 claro antes de abrir la transacción', async () => {
    const { service, gastos, prisma } = armar({ falla: 'g2' });
    const p = service.anular('emp', 'rv-1', 'Viaje cancelado', 'u1');
    await expect(p).rejects.toThrow(BadRequestException);
    // El gasto se nombra con la referencia real (fecha y descripción), no con un texto inventado.
    await expect(p).rejects.toThrow(
      'No se pudo anular el gasto GASTO 05/10/2026 · Almuerzo de la rendición: El gasto tiene la NC N° 12 vigente. Anulá primero la nota de crédito.. La rendición no se anuló.',
    );
    expect(prisma.$transaction).not.toHaveBeenCalled();
    expect(gastos.anularEnTx).not.toHaveBeenCalled();
  });

  it('si la anulación de un gasto falla en el tx: el error llega con el gasto y nada queda escrito (rollback)', async () => {
    const { service, gastos, audit } = armar();
    gastos.anularEnTx.mockRejectedValueOnce(new BadRequestException('El gasto ya fue anulado'));
    await expect(service.anular('emp', 'rv-1', 'Viaje cancelado', 'u1')).rejects.toThrow(
      'No se pudo anular el gasto 001-001-0000001 de la rendición: El gasto ya fue anulado. La rendición no se anuló.',
    );
    expect(audit.log).not.toHaveBeenCalled();
  });

  // C3: un período cerrado del adelanto ya no deja los gastos anulados y el adelanto a medias.
  it('período cerrado en el asiento del adelanto: la transacción se deshace y el error llega con su motivo', async () => {
    const { service, contabilidad, audit } = armar();
    contabilidad.revertirAdelanto.mockRejectedValue(
      new BadRequestException('No se puede revertir: el período 08/2026 del asiento está CERRADO.'),
    );
    await expect(service.anular('emp', 'rv-1', 'Viaje cancelado', 'u1')).rejects.toThrow('el período 08/2026 del asiento está CERRADO');
    expect(audit.log).not.toHaveBeenCalled();
    expect(service.findOne).not.toHaveBeenCalled();
  });

  it('una rendición CERRADA no se anula por acá (va por anularCerrada, con su permiso)', async () => {
    const { service, gastos, prisma } = armar({ estado: 'CERRADA' });
    await expect(service.anular('emp', 'rv-1', 'Viaje cancelado', 'u1')).rejects.toThrow('Anular rendición cerrada');
    expect(gastos.verificarAnulable).not.toHaveBeenCalled();
    expect(prisma.$transaction).not.toHaveBeenCalled();
  });

  it('con un bloqueo (movimiento conciliado): 400 con el motivo antes de validar gastos y sin abrir la transacción', async () => {
    const { service, gastos, prisma } = armar();
    prisma.tes_movimientos.findMany.mockResolvedValue([{ id: 'm1', origen_id: 'ad1' }]);
    prisma.tes_extracto_lineas.findMany.mockResolvedValue([{ movimiento_id: 'm1' }]);
    await expect(service.anular('emp', 'rv-1', 'Viaje cancelado', 'u1')).rejects.toThrow(
      'El movimiento de tesorería de un adelanto ya está conciliado',
    );
    expect(gastos.verificarAnulable).not.toHaveBeenCalled();
    expect(prisma.$transaction).not.toHaveBeenCalled();
  });

  it('sin motivo → 400', async () => {
    const { service, gastos } = armar();
    await expect(service.anular('emp', 'rv-1', '   ', 'u1')).rejects.toThrow('El motivo de la anulación es obligatorio');
    expect(gastos.verificarAnulable).not.toHaveBeenCalled();
  });

  // I4
  it('sin usuario → 400 claro, sin tocar nada', async () => {
    const { service, prisma } = armar();
    await expect(service.anular('emp', 'rv-1', 'Viaje cancelado', '')).rejects.toThrow('Falta el usuario que anula la rendición');
    expect(prisma.$transaction).not.toHaveBeenCalled();
  });

  // C2
  it('un motivo que con el prefijo no entra en Tesorería → 400', async () => {
    const { service, prisma } = armar();
    await expect(service.anular('emp', 'rv-1', 'a'.repeat(445), 'u1')).rejects.toThrow('no puede superar 444 caracteres');
    expect(prisma.$transaction).not.toHaveBeenCalled();
  });
});

describe('RendicionViaticosService.anular — choque con otra operación (N4)', () => {
  const p2034 = () => new Prisma.PrismaClientKnownRequestError('Transaction failed due to a write conflict or a deadlock', { code: 'P2034', clientVersion: 'x' });
  const deadlock = () => new Prisma.PrismaClientKnownRequestError('deadlock detected', { code: 'P2010', clientVersion: 'x', meta: { code: '40P01' } });

  it.each([
    ['P2034', p2034],
    ['40P01 (deadlock)', deadlock],
  ])('%s → 409 "La anulación chocó con otra operación. Reintentá."', async (_c, error) => {
    const { service, prisma } = armar();
    prisma.$transaction.mockRejectedValue(error());
    const p = service.anular('emp', 'rv-1', 'Viaje cancelado', 'u1');
    await expect(p).rejects.toThrow(ConflictException);
    await expect(p).rejects.toThrow('La anulación chocó con otra operación. Reintentá.');
  });

  it('otros errores pasan tal cual', async () => {
    const { service, prisma } = armar();
    prisma.$transaction.mockRejectedValue(new BadRequestException('La rendición ya está anulada'));
    await expect(service.anular('emp', 'rv-1', 'Viaje cancelado', 'u1')).rejects.toThrow('La rendición ya está anulada');
  });
});

describe('RendicionViaticosService.quitarGasto', () => {
  it('pasa el motivo del usuario con contexto y el rendicionId', async () => {
    const { service, gastos } = armar();
    await service.quitarGasto('emp', 'rv-1', 'g2', ' Factura duplicada ', 'u1');
    expect(gastos.anular).toHaveBeenCalledWith(
      'g2',
      'emp',
      'u1',
      'Quitado de la rendición RV-000007: Factura duplicada',
      {
        rendicionId: 'rv-1',
      },
    );
  });

  it('sin motivo → 400', async () => {
    const { service, gastos } = armar();
    await expect(service.quitarGasto('emp', 'rv-1', 'g2', '', 'u1')).rejects.toThrow(
      'El motivo de la anulación es obligatorio',
    );
    expect(gastos.anular).not.toHaveBeenCalled();
  });

  it('sin usuario → 400 claro (nunca un texto vacío como usuario)', async () => {
    const { service, gastos } = armar();
    await expect(service.quitarGasto('emp', 'rv-1', 'g2', 'Duplicada', '')).rejects.toThrow(
      'Falta el usuario que quita el gasto de la rendición',
    );
    expect(gastos.anular).not.toHaveBeenCalled();
  });
});
