import { BadRequestException } from '@nestjs/common';
import { GastosService } from './gastos.service';

/** Anular un gasto (plan 2026-10-19-gastos, Task 7): motivo obligatorio y bloqueos dentro de la transacción. */

function armar(
  opts: {
    nc?: { numero: string } | null;
    ordenes?: string[];
    pagos?: number;
    yaAnulado?: boolean;
    gasto?: Record<string, unknown>;
    conciliado?: boolean;
    cheque?: { numero_cheque: string; estado: string } | null;
  } = {},
) {
  const orden: string[] = [];
  const traza = (nombre: string, valor: any) =>
    jest.fn().mockImplementation(async () => (orden.push(nombre), typeof valor === 'function' ? valor() : valor));
  let dentro = false;
  const gastoBase = {
    id: 'g1',
    empresa_id: 'emp',
    anulado: false,
    activo: true,
    estado: 'registrado',
    rendicion_viatico_id: null,
    requisicion_id: null,
    embarque_id: null,
    fecha_emision: new Date('2026-10-05'),
    ...opts.gasto,
  };
  const tx: any = {
    $queryRaw: traza('lock', []),
    rec_multi_gastos: { findMany: traza('recibos', []) },
    nota_credito_compra_cab: { findFirst: traza('nc', opts.nc ?? null) },
    cuentas_pagar: {
      findMany: traza('cxp', [{ id: 'cxp-1' }]),
      updateMany: traza('cxp-anular', {}),
    },
    orden_pago_proveedor_det: {
      findMany: traza(
        'ops',
        (opts.ordenes ?? []).map((n) => ({ orden_pago_proveedor_cab: { numero_orden_pago: n } })),
      ),
    },
    pagos_proveedor: { count: traza('pagos', opts.pagos ?? 0) },
    gasto_det: { findMany: traza('det', []) },
    gasto_cab: { findFirst: traza('leer', gastoBase), updateMany: traza('update', { count: opts.yaAnulado ? 0 : 1 }) },
  };
  const prisma: any = {
    ...tx,
    gasto_cab: { findFirst: jest.fn().mockResolvedValue(gastoBase), updateMany: tx.gasto_cab.updateMany },
    $transaction: jest.fn().mockImplementation(async (fn: any) => {
      dentro = true;
      try {
        return await fn(tx);
      } finally {
        dentro = false;
      }
    }),
  };
  // Lo que se llama por fuera de la transacción no debe tocar los bloqueos.
  for (const k of ['nota_credito_compra_cab', 'orden_pago_proveedor_det', 'cuentas_pagar']) {
    for (const m of Object.keys(prisma[k])) {
      const f = prisma[k][m];
      prisma[k][m] = jest.fn().mockImplementation((...a: any[]) => {
        if (!dentro) throw new Error(`${k}.${m} fuera de la $transaction`);
        return f(...a);
      });
    }
  }
  const contabilidad = { revertirDocumento: traza('revertir-asiento', undefined) };
  const tesoreria = {
    revertirGasto: traza('revertir-tesoreria', undefined),
    tieneMovimientoConciliado: traza('conciliado', opts.conciliado ?? false),
    chequeNoRevertible: traza('cheque', opts.cheque ?? null),
  };
  const service = new GastosService(
    prisma,
    contabilidad as any,
    tesoreria as any,
    { recalcular: jest.fn() } as any,
    {} as any,
  );
  jest.spyOn(service, 'findOne').mockResolvedValue({ id: 'g1' } as any);
  return { service, prisma, tx, orden, tesoreria, contabilidad };
}

describe('GastosService.anular', () => {
  it('sin motivo → 400 y no toca nada', async () => {
    const { service, prisma } = armar();
    await expect(service.anular('g1', 'emp', 'u1', '  ')).rejects.toThrow('El motivo de la anulación es obligatorio');
    expect(prisma.$transaction).not.toHaveBeenCalled();
  });

  it('con NC de compra vigente → 400 con el número', async () => {
    const { service, tx } = armar({ nc: { numero: '0000012' } });
    await expect(service.anular('g1', 'emp', 'u1', 'Error')).rejects.toThrow(
      new BadRequestException('El gasto tiene la NC N° 0000012 vigente. Anulá primero la nota de crédito.'),
    );
    expect(tx.nota_credito_compra_cab.findFirst.mock.calls[0][0].where).toMatchObject({
      gasto_id: 'g1',
      anulado: false,
    });
    expect(tx.gasto_cab.updateMany).not.toHaveBeenCalled();
  });

  it('con la CxP en una OP no anulada (aunque sea borrador) → 400 con el número; mismo join que la edición', async () => {
    const { service, tx } = armar({ ordenes: ['OP-0031'] });
    await expect(service.anular('g1', 'emp', 'u1', 'Error')).rejects.toThrow(
      new BadRequestException('El gasto está en la orden de pago N° OP-0031. Sacalo de la orden o anulala primero.'),
    );
    // No filtra por estado BORRADOR: solo excluye las anuladas.
    expect(tx.orden_pago_proveedor_det.findMany.mock.calls[0][0].where.orden_pago_proveedor_cab).toEqual({
      anulado: { not: true },
      estado: { not: 'ANULADA' },
    });
    expect(tx.gasto_cab.updateMany).not.toHaveBeenCalled();
  });

  it('los bloqueos corren dentro de la misma $transaction (y antes de anular)', async () => {
    const { service, prisma, orden } = armar();
    await service.anular('g1', 'emp', 'u1', 'Error');
    expect(prisma.$transaction).toHaveBeenCalledTimes(1);
    expect(orden.indexOf('nc')).toBeGreaterThan(-1);
    expect(orden.indexOf('ops')).toBeGreaterThan(-1);
    expect(orden.indexOf('nc')).toBeLessThan(orden.indexOf('update'));
    expect(orden.indexOf('ops')).toBeLessThan(orden.indexOf('update'));
  });

  it('anula con el motivo recortado y deja activo = true (no lo toca)', async () => {
    const { service, tx, tesoreria } = armar();
    await service.anular('g1', 'emp', 'u1', '  Cargado dos veces ');
    const data = tx.gasto_cab.updateMany.mock.calls[0][0].data;
    expect(data).toMatchObject({ anulado: true, estado: 'anulado', motivo_anulacion: 'Cargado dos veces' });
    expect(data).not.toHaveProperty('activo');
    expect(tesoreria.revertirGasto).toHaveBeenCalledWith(tx, 'g1', 'emp', 'Cargado dos veces');
  });

  it('doble anulación: el updateMany condicional (anulado: false) sin filas → 400 y no se revierte nada', async () => {
    const { service, tx, tesoreria } = armar({ yaAnulado: true });
    await expect(service.anular('g1', 'emp', 'u1', 'Error')).rejects.toThrow('El gasto ya fue anulado');
    expect(tx.gasto_cab.updateMany.mock.calls[0][0].where).toMatchObject({ id: 'g1', anulado: false });
    expect(tesoreria.revertirGasto).not.toHaveBeenCalled();
  });

  it('consulta las CxP y los pagos una sola vez', async () => {
    const { service, tx } = armar();
    await service.anular('g1', 'emp', 'u1', 'Error');
    expect(tx.cuentas_pagar.findMany).toHaveBeenCalledTimes(1);
    expect(tx.pagos_proveedor.count).toHaveBeenCalledTimes(1);
    expect(tx.cuentas_pagar.updateMany).toHaveBeenCalledTimes(1);
  });

  it('un gasto de viáticos sigue dando 400 salvo desde su propia rendición', async () => {
    const { service } = armar({ gasto: { rendicion_viatico_id: 'rv-1' } });
    (service as any).prisma.rendicion_viatico = {
      findUnique: jest.fn().mockResolvedValue({ numero_rendicion: 'RV-1' }),
    };
    await expect(service.anular('g1', 'emp', 'u1', 'x')).rejects.toThrow('se anula desde ahí');
    await expect(service.anular('g1', 'emp', 'u1', 'x', { rendicionId: 'rv-otra' })).rejects.toThrow('se anula desde ahí');
    await expect(service.anular('g1', 'emp', 'u1', 'x', { rendicionId: 'rv-1' })).resolves.toBeDefined();
  });

  // C1: la reversión del asiento y la de Tesorería van en la misma transacción.
  it('revierte el asiento y Tesorería con el tx de la anulación, después de marcar el gasto', async () => {
    const { service, tx, orden, tesoreria, contabilidad } = armar();
    await service.anular('g1', 'emp', 'u1', 'Cargado dos veces');
    expect(contabilidad.revertirDocumento).toHaveBeenCalledWith('gasto_cab', 'g1', 'u1', tx);
    expect(tesoreria.revertirGasto).toHaveBeenCalledWith(tx, 'g1', 'emp', 'Cargado dos veces');
    expect(orden.indexOf('update')).toBeLessThan(orden.indexOf('revertir-asiento'));
  });

  it('período cerrado: la reversión del asiento falla y anular rechaza con el motivo real (no 200)', async () => {
    const { service, contabilidad, tesoreria } = armar();
    contabilidad.revertirDocumento.mockRejectedValue(
      new BadRequestException('No se puede revertir: el período 09/2026 del asiento está CERRADO.'),
    );
    await expect(service.anular('g1', 'emp', 'u1', 'Error')).rejects.toThrow('el período 09/2026 del asiento está CERRADO');
    expect(tesoreria.revertirGasto).not.toHaveBeenCalled();
    expect(service.findOne).not.toHaveBeenCalled();
  });

  it('si la reversión de Tesorería falla, anular rechaza (la transacción entera se deshace)', async () => {
    const { service, tesoreria } = armar();
    tesoreria.revertirGasto.mockRejectedValue(new Error('value too long for type character varying(500)'));
    await expect(service.anular('g1', 'emp', 'u1', 'Error')).rejects.toThrow('value too long');
    expect(service.findOne).not.toHaveBeenCalled();
  });

  // I5: la fila del gasto se bloquea y se vuelve a leer dentro de la transacción.
  it('M6: bloquea también la CxP del gasto (FOR UPDATE) antes de leer OP y pagos', async () => {
    const { service, tx, orden } = armar();
    await service.anular('g1', 'emp', 'u1', 'Error');
    const sqls = tx.$queryRaw.mock.calls.map((c: any[]) => String(c[0].join('?')));
    const iCxp = sqls.findIndex((q: string) => q.includes('FROM cuentas_pagar') && q.includes('FOR UPDATE'));
    expect(iCxp).toBeGreaterThan(-1);
    // El segundo lock (el de la CxP) va antes de la primera lectura de bloqueos.
    const locks = orden.reduce((a: number[], n, i) => (n === 'lock' ? [...a, i] : a), []);
    expect(locks[iCxp]).toBeLessThan(orden.indexOf('ops'));
    expect(locks[iCxp]).toBeLessThan(orden.indexOf('pagos'));
  });

  it('con requisición: lock del gasto → req: → lock de la CxP, y recién después lee los bloqueos', async () => {
    const { service, tx, orden } = armar({ gasto: { requisicion_id: 'req-1' } });
    tx.$executeRaw = jest.fn().mockImplementation(async (_s: TemplateStringsArray, ...v: unknown[]) => (orden.push(`req ${v[0]}`), 1));
    await service.anular('g1', 'emp', 'u1', 'Error');
    const sqls = tx.$queryRaw.mock.calls.map((c: any[]) => String(c[0].join('?')));
    expect(sqls[0]).toContain('FOR UPDATE');
    expect(sqls[1]).toContain('FROM cuentas_pagar');
    // Trazas: lock (gasto), leer, req req:req-1, lock (CxP), ... lecturas de bloqueos.
    const marcas = orden.filter((n) => n === 'lock' || n.startsWith('req ') || n === 'cxp' || n === 'ops' || n === 'pagos');
    expect(marcas.slice(0, 3)).toEqual(['lock', 'req req:req-1', 'lock']);
    expect(orden.indexOf('leer')).toBeLessThan(orden.indexOf('req req:req-1'));
    expect(orden.indexOf('req req:req-1')).toBeLessThan(orden.indexOf('ops'));
  });

  it('bloquea la fila del gasto (FOR UPDATE) y la vuelve a leer en el tx antes de validar', async () => {
    const { service, tx, orden } = armar();
    await service.anular('g1', 'emp', 'u1', 'Error');
    expect(String(tx.$queryRaw.mock.calls[0][0].join('?'))).toContain('FOR UPDATE');
    expect(orden.indexOf('lock')).toBeLessThan(orden.indexOf('leer'));
    expect(orden.indexOf('leer')).toBeLessThan(orden.indexOf('nc'));
  });

  it('si otra pestaña la anuló mientras tanto (relectura en el tx), 400 sin revertir nada', async () => {
    const { service, tx, tesoreria } = armar();
    tx.gasto_cab.findFirst.mockResolvedValue({ id: 'g1', empresa_id: 'emp', anulado: true });
    await expect(service.anular('g1', 'emp', 'u1', 'Error')).rejects.toThrow('Gasto ya anulado');
    expect(tesoreria.revertirGasto).not.toHaveBeenCalled();
  });

  // I8
  it('con el egreso conciliado con el extracto → 400 y no anula', async () => {
    const { service, tx } = armar({ conciliado: true });
    await expect(service.anular('g1', 'emp', 'u1', 'Error')).rejects.toThrow(
      new BadRequestException(
        'Este gasto tiene un movimiento de Tesorería ya conciliado con el extracto bancario. Deshacé la conciliación de ese movimiento antes de anular el gasto.',
      ),
    );
    expect(tx.gasto_cab.updateMany).not.toHaveBeenCalled();
  });

  // I9
  it('con el cheque del gasto ya debitado → 400 que pide revertir el cheque primero', async () => {
    const { service, tx } = armar({ cheque: { numero_cheque: '000123', estado: 'DEBITADO' } });
    await expect(service.anular('g1', 'emp', 'u1', 'Error')).rejects.toThrow(
      new BadRequestException('El gasto se pagó con el cheque 000123, que ya está DEBITADO. Revertí primero el cheque en Tesorería.'),
    );
    expect(tx.gasto_cab.updateMany).not.toHaveBeenCalled();
  });

  // I4
  it('sin usuario → 400 claro (nunca la empresa ni un texto vacío como usuario)', async () => {
    const { service, prisma } = armar();
    await expect(service.anular('g1', 'emp', '', 'Error')).rejects.toThrow('Falta el usuario que anula el gasto');
    expect(prisma.$transaction).not.toHaveBeenCalled();
  });

  // C2: un llamador interno tampoco puede pasar un motivo que no entra en Tesorería.
  it('motivo de más de 500 caracteres → 400 antes de escribir', async () => {
    const { service, prisma } = armar();
    await expect(service.anular('g1', 'emp', 'u1', 'a'.repeat(501))).rejects.toThrow(
      'El motivo de la anulación no puede superar 500 caracteres',
    );
    expect(prisma.$transaction).not.toHaveBeenCalled();
  });
});
