import { BadRequestException, HttpException } from '@nestjs/common';
import { plainToInstance } from 'class-transformer';
import { validate } from 'class-validator';
import { solicitudInvalida } from 'src/common/utils/error-estructurado';
import { CODIGO_PERIODO_NO_ABIERTO } from 'src/contabilidad/services/asientos.service';
import { AnularOrdenPagoProveedorDto } from './dto/create-orden-pago-proveedor.dto';
import { alcanceSucursalUsuario } from 'src/utils/alcance-sucursal';
import { PagosProveedorService } from './pagos-proveedor.service';

jest.mock('src/utils/alcance-sucursal', () => ({
  ...jest.requireActual('src/utils/alcance-sucursal'),
  alcanceSucursalUsuario: jest.fn(),
}));
const alcanceMock = alcanceSucursalUsuario as jest.MockedFunction<typeof alcanceSucursalUsuario>;
beforeEach(() => {
  alcanceMock.mockReset();
  alcanceMock.mockResolvedValue(null);
});

/**
 * Task 7 (plan 2026-10-28-orden-pago-cxp): anular todo o nada y los reintentos con lock.
 *
 * La base es en memoria y transaccional: cada `$transaction` lee lo confirmado, guarda sus escrituras aparte y
 * las confirma solo si el callback termina bien (si tira, no queda nada). `pg_advisory_xact_lock` espera a que la
 * transacción que tiene la clave termine, así dos acciones simultáneas se serializan como en Postgres.
 */

type Fila = Record<string, any>;

const clonar = <T>(v: T): T => JSON.parse(JSON.stringify(v));

/** Evaluador mínimo del `where` de Prisma que usan anular y los reintentos. */
const cumple = (fila: Fila, where: Fila = {}): boolean =>
  Object.entries(where).every(([k, cond]) => {
    const v = fila[k];
    if (cond && typeof cond === 'object' && !Array.isArray(cond)) {
      if ('in' in cond) return cond.in.includes(v);
      if ('notIn' in cond) return !cond.notIn.includes(v);
      if ('not' in cond) return v !== cond.not;
      return cumple(v ?? {}, cond);
    }
    return v === cond;
  });

const MEDIO_EFECTIVO = { codigo: 1, descripcion: 'Efectivo' };

const cuota = (id: string, over: Fila = {}) => ({
  id,
  empresa_id: 'emp-1',
  proveedor_id: 'prov-1',
  compra_id: `c-${id}`,
  origen_tipo: 'compra',
  origen_id: null,
  moneda_id: 'mon-pyg',
  monto_original: 300,
  monto_pagado: 300,
  saldo_pendiente: 0,
  estado: 'pagada',
  activo: true,
  ...over,
});

const ordenBase = (over: Fila = {}) => ({
  id: 'op-1',
  empresa_id: 'emp-1',
  sucursal_id: 'suc-1',
  proveedor_id: 'prov-1',
  numero_orden_pago: '001-001-0000005',
  origen: 'manual',
  estado: 'PAGADO',
  anulado: false,
  activo: true,
  usuario_id: 'u-creador',
  compra_id: null,
  compra_cab: null,
  motivo_anulacion: null,
  fecha_pago: '2026-10-05T00:00:00.000Z',
  monto_total: 300,
  cotizacion: 1,
  referencia: null,
  moneda: { codigo: 'PYG' },
  orden_pago_proveedor_det: [
    {
      cuenta_pagar_id: 'cxp-a',
      monto: 300,
      medio_pago_id: 'mp-efectivo',
      medio_pago: MEDIO_EFECTIVO,
      cuenta_bancaria_id: 'tes-1',
      numero_cheque: null,
    },
  ],
  ...over,
});

type Opciones = {
  orden?: Fila;
  cuotas?: Fila[];
  pagos?: Fila[];
  cheques?: Fila[];
  movimientos?: Fila[];
  conciliados?: string[];
  conContabilidad?: boolean;
  docContable?: Fila | null;
  /** El UPDATE del saldo de la cuenta de Tesorería falla (un error de la base en medio de la reversa). */
  fallaSaldoCuenta?: boolean;
};

const base = (o: Opciones = {}) => {
  const db = {
    ordenes: new Map<string, Fila>([['op-1', clonar(o.orden ?? ordenBase())]]),
    cuotas: new Map<string, Fila>((o.cuotas ?? [cuota('cxp-a')]).map((c): [string, Fila] => [c.id, clonar(c)])),
    pagos: clonar(
      o.pagos ?? [
        { id: 'pp-1', empresa_id: 'emp-1', cuenta_pagar_id: 'cxp-a', numero_recibo: '001-001-0000005', anulado: false },
      ],
    ),
    cheques: clonar(o.cheques ?? []),
    movimientos: clonar(
      o.movimientos ?? [
        {
          id: 'mov-1',
          empresa_id: 'emp-1',
          origen_tipo: 'ORDEN_PAGO_PROVEEDOR',
          origen_id: 'op-1',
          estado: 'CONFIRMADO',
          cuenta_id: 'tes-1',
          monto: 300,
        },
      ],
    ),
    cuentasTes: new Map<string, Fila>([
      [
        'tes-1',
        { id: 'tes-1', nombre: 'Banco Itaú', moneda: 'PYG', saldo_actual: 1000, activo: true, empresa_id: 'emp-1' },
      ],
    ]),
    conciliados: new Set(o.conciliados ?? []),
    asientoRevertido: false,
    docContable: o.docContable === undefined ? null : o.docContable,
    /** `audit_logs` de falta de mapeo (`CONT_FALTA_MAPEO`), como los escribe `conAvisoDeMapeo`. */
    avisosMapeo: [] as Fila[],
    /** Cada escritura confirmada, en orden (para aseverar que la tx fallida no dejó nada). */
    confirmadas: [] as string[],
  };

  const colas = new Map<string, Promise<void>>();
  const prisma: any = {};
  /** Las tx que se abrieron (para verificar que todo se escribió con la misma). */
  const txs: any[] = [];

  const crearTx = (pendientes: Array<() => void>, liberar: Array<() => void>) => {
    const escribir = (nombre: string, f: () => void) => pendientes.push(() => (f(), db.confirmadas.push(nombre)));
    const tx: any = {
      $executeRaw: jest.fn(async (_s: TemplateStringsArray, clave: string) => {
        const previa = colas.get(clave) ?? Promise.resolve();
        let soltar!: () => void;
        const propia = new Promise<void>((r) => (soltar = r));
        colas.set(
          clave,
          previa.then(() => propia),
        );
        await previa;
        liberar.push(soltar);
        return 1;
      }),
      orden_pago_proveedor_cab: {
        findFirst: jest.fn(async ({ where }: any) => {
          const fila = db.ordenes.get(where.id);
          if (!fila || fila.empresa_id !== where.empresa_id || (where.activo && !fila.activo)) return null;
          // El alcance por sucursal (`whereOpEnAlcance`): una sucursal o `{ in: [...] }`.
          if (where.sucursal_id !== undefined && !cumple(fila, { sucursal_id: where.sucursal_id })) return null;
          await new Promise((r) => setImmediate(r));
          return clonar(fila);
        }),
        findMany: jest.fn(async ({ where }: any) =>
          [...db.ordenes.values()]
            .filter((f) => (where.id ? where.id.in.includes(f.id) : cumple(f, { compra_id: where.compra_id, origen: where.origen })) && f.empresa_id === where.empresa_id)
            .map(clonar),
        ),
        update: jest.fn(async ({ where, data }: any) =>
          escribir('orden', () => Object.assign(db.ordenes.get(where.id)!, data)),
        ),
      },
      cuentas_pagar: {
        findMany: jest.fn(async ({ where }: any) =>
          [...db.cuotas.values()].filter((c) => where.id.in.includes(c.id)).map(clonar),
        ),
        update: jest.fn(async ({ where, data }: any) =>
          escribir('cuota', () => Object.assign(db.cuotas.get(where.id)!, data)),
        ),
      },
      pagos_proveedor: {
        updateMany: jest.fn(async ({ where, data }: any) => {
          const filas = db.pagos.filter((p: Fila) => cumple(p, where));
          escribir('pagos', () => filas.forEach((p: Fila) => Object.assign(p, data)));
          return { count: filas.length };
        }),
      },
      tes_cheques: {
        findMany: jest.fn(async ({ where }: any) => db.cheques.filter((c: Fila) => cumple(c, where)).map(clonar)),
        findFirst: jest.fn(async ({ where }: any) => db.cheques.find((c: Fila) => cumple(c, where)) ?? null),
        updateMany: jest.fn(async ({ where, data }: any) => {
          const filas = db.cheques.filter((c: Fila) => cumple(c, where));
          escribir('cheques', () => filas.forEach((c: Fila) => Object.assign(c, data)));
          return { count: filas.length };
        }),
        create: jest.fn(async ({ data }: any) =>
          escribir('cheque', () => db.cheques.push({ id: `ch-${db.cheques.length + 1}`, ...data })),
        ),
      },
      tes_movimientos: {
        findMany: jest.fn(async ({ where }: any) => db.movimientos.filter((m: Fila) => cumple(m, where)).map(clonar)),
        findFirst: jest.fn(async ({ where }: any) => db.movimientos.find((m: Fila) => cumple(m, where)) ?? null),
        updateMany: jest.fn(async ({ where, data }: any) => {
          const filas = db.movimientos.filter((m: Fila) => cumple(m, where));
          escribir('movimientos', () => filas.forEach((m: Fila) => Object.assign(m, data)));
          return { count: filas.length };
        }),
        create: jest.fn(async ({ data }: any) => {
          const fila = { id: `mov-${db.movimientos.length + 1}`, ...data };
          escribir('movimiento', () => db.movimientos.push(fila));
          return fila;
        }),
      },
      tes_movimiento_det: { create: jest.fn(async () => escribir('movimiento_det', () => undefined)) },
      tes_cuentas: {
        findFirst: jest.fn(async ({ where }: any) => clonar(db.cuentasTes.get(where.id) ?? null)),
        update: jest.fn(async ({ where, data }: any) => {
          if (o.fallaSaldoCuenta) throw new Error('deadlock detected');
          return escribir('saldo_cuenta', () => {
            const c = db.cuentasTes.get(where.id)!;
            c.saldo_actual += data.saldo_actual.increment ?? -data.saldo_actual.decrement;
          });
        }),
      },
      tes_extracto_lineas: {
        findFirst: jest.fn(async ({ where }: any) => {
          const m = db.movimientos.find((mov: Fila) => db.conciliados.has(mov.id) && cumple(mov, where.movimiento));
          return where.conciliado && m ? { id: `ext-${m.id}` } : null;
        }),
      },
      tes_reglas: {},
      tes_categorias: {},
      empresa_medio_pago: { findMany: jest.fn().mockResolvedValue([]), findFirst: jest.fn().mockResolvedValue(null) },
      cont_documentos: {
        findFirst: jest.fn(async () => clonar(db.docContable)),
        findMany: jest.fn(async () => (db.docContable ? [{ id: 'doc-1', origen_id: 'op-1', ...clonar(db.docContable) }] : [])),
      },
      audit_logs: {
        findFirst: jest.fn(async ({ where }: any) => clonar(db.avisosMapeo.filter((a: Fila) => cumple(a, where)).at(-1) ?? null)),
      },
    };
    return tx;
  };

  prisma.$transaction = jest.fn(async (cb: (t: any) => unknown, _opciones?: unknown) => {
    const pendientes: Array<() => void> = [];
    const liberar: Array<() => void> = [];
    const tx = crearTx(pendientes, liberar);
    txs.push(tx);
    try {
      const r = await cb(tx);
      pendientes.forEach((f) => f());
      return r;
    } finally {
      liberar.forEach((f) => f());
    }
  });
  // Lecturas fuera de transacción (solo las que no deciden nada).
  Object.assign(prisma, crearTx([], []));

  const contab = {
    integrarOrdenPago: jest.fn().mockResolvedValue(undefined),
    tieneModuloContabilidad: jest.fn().mockResolvedValue(o.conContabilidad ?? true),
    revertirDocumento: jest.fn(async (_t: string, _id: string, _u: string | null, tx?: any) => {
      // Escribe con la tx que recibe: si la anulación falla después, la reversa tampoco queda.
      if (tx) await tx.orden_pago_proveedor_cab.findFirst({ where: { id: 'op-1', empresa_id: 'emp-1' } });
      return undefined;
    }),
  };
  const audit = { log: jest.fn().mockResolvedValue(undefined) };
  const service = new PagosProveedorService(
    prisma,
    contab as any,
    audit as any,
    { getCotizacionVigente: jest.fn() } as any,
  );
  jest.spyOn(service, 'findOne').mockImplementation(async (id: string) => ({ id, leida: true }) as any);
  for (const m of ['recalculateCompraEstado', 'recalculateAutoOrderEstado', 'recalculateGastoEstado']) {
    jest.spyOn(service as any, m).mockResolvedValue(undefined);
  }
  jest.spyOn(service as any, 'getCategoriaTesoreriaPagoProveedor').mockResolvedValue('cat-1');
  return { service, prisma, db, contab, audit, txs };
};

const errorDe = (p: Promise<unknown>) =>
  p.then(
    () => {
      throw new Error('se esperaba un error');
    },
    (e: HttpException) => e,
  );
const cuerpo = (e: HttpException) => (typeof e?.getResponse === 'function' ? (e.getResponse() as Fila) : ({} as Fila));
const codigoDe = (r: PromiseSettledResult<unknown>) =>
  r.status === 'fulfilled' ? 'OK' : (cuerpo(r.reason as HttpException).codigo ?? String((r.reason as Error).message));

const MOTIVO = { motivo: 'El proveedor devolvió la transferencia' };

describe('anular: validaciones', () => {
  it.each([[''], ['   '], [undefined]])('anular sin motivo o con espacios (%p) → MOTIVO_REQUERIDO', async (motivo) => {
    const { service, db } = base();
    const e = await errorDe(service.anular('op-1', { motivo } as any, 'emp-1', 'u-1'));
    expect(e).toBeInstanceOf(BadRequestException);
    expect(cuerpo(e)).toMatchObject({ codigo: 'MOTIVO_REQUERIDO', campo: 'motivo' });
    expect(db.confirmadas).toEqual([]);
  });

  it('el DTO exige el motivo como texto de hasta 500 (sin IsNotEmpty: el blanco lo responde el servicio con código)', async () => {
    expect(await validate(plainToInstance(AnularOrdenPagoProveedorDto, {}))).not.toHaveLength(0);
    expect(await validate(plainToInstance(AnularOrdenPagoProveedorDto, { motivo: 'x'.repeat(501) }))).not.toHaveLength(
      0,
    );
    expect(await validate(plainToInstance(AnularOrdenPagoProveedorDto, { motivo: 'x'.repeat(500) }))).toHaveLength(0);
    expect(await validate(plainToInstance(AnularOrdenPagoProveedorDto, { motivo: '  ' }))).toHaveLength(0);
  });

  it('anular una automática → OP_AUTOMATICA con el número de la factura', async () => {
    const { service, db } = base({
      orden: ordenBase({
        origen: 'compra_auto',
        compra_id: 'c-9',
        compra_cab: { id: 'c-9', establecimiento: '1', punto_expedicion: '2', numero_factura: '345' },
      }),
    });
    const e = await errorDe(service.anular('op-1', MOTIVO, 'emp-1', 'u-1'));
    expect(e).toBeInstanceOf(BadRequestException);
    expect(cuerpo(e)).toMatchObject({
      codigo: 'OP_AUTOMATICA',
      factura: { id: 'c-9', numero: '001-002-0000345' },
      message: 'Este pago es parte de la factura 001-002-0000345: se anula anulando la factura',
    });
    expect(db.confirmadas).toEqual([]);
  });

  it('anular con egreso conciliado → OP_CONCILIADA y no anula nada', async () => {
    const { service, db } = base({ conciliados: ['mov-1'] });
    const e = await errorDe(service.anular('op-1', MOTIVO, 'emp-1', 'u-1'));
    expect(cuerpo(e).codigo).toBe('OP_CONCILIADA');
    expect(db.confirmadas).toEqual([]);
    expect(db.ordenes.get('op-1')!.anulado).toBe(false);
  });

  it('anular con cheque DEBITADO → OP_CHEQUE_FUERA_DE_CARTERA con el mensaje de hoy', async () => {
    const { service, db } = base({
      movimientos: [],
      cheques: [
        {
          id: 'ch-1',
          empresa_id: 'emp-1',
          origen_tipo: 'ORDEN_PAGO_PROVEEDOR',
          origen_id: 'op-1',
          estado: 'DEBITADO',
          numero_cheque: '123',
        },
      ],
    });
    const e = await errorDe(service.anular('op-1', MOTIVO, 'emp-1', 'u-1'));
    expect(cuerpo(e)).toMatchObject({
      codigo: 'OP_CHEQUE_FUERA_DE_CARTERA',
      message:
        'No se puede anular: hay cheques fuera de cartera. Revertilos primero desde Tesorería: Nº 123 (DEBITADO)',
    });
    expect(db.confirmadas).toEqual([]);
  });

  it('anular pagada con período cerrado: revertirDocumento lanza dentro de la tx → OP_PERIODO_CERRADO y la tx no escribe nada', async () => {
    const { service, db, contab, txs } = base();
    const mensaje =
      'No se puede revertir: el período 09/2026 del asiento está CERRADO. Reabra ese período para revertirlo o registre un ajuste en el período actual.';
    contab.revertirDocumento.mockRejectedValueOnce(
      solicitudInvalida({ message: mensaje, codigo: CODIGO_PERIODO_NO_ABIERTO }),
    );

    const e = await errorDe(service.anular('op-1', MOTIVO, 'emp-1', 'u-1'));

    expect(e).toBeInstanceOf(BadRequestException);
    expect(cuerpo(e)).toMatchObject({ codigo: 'OP_PERIODO_CERRADO', message: mensaje });
    // Se llamó dentro de la tx de la anulación, después de escribir saldos y Tesorería…
    expect(contab.revertirDocumento).toHaveBeenCalledWith('orden_pago_proveedor_cab', 'op-1', 'u-1', txs[0]);
    expect(txs[0].cuentas_pagar.update).toHaveBeenCalled();
    // …y nada quedó confirmado: ni la cuota, ni la OP, ni el egreso, ni el saldo del banco.
    expect(db.confirmadas).toEqual([]);
    expect(db.cuotas.get('cxp-a')).toMatchObject({ saldo_pendiente: 0, monto_pagado: 300 });
    expect(db.movimientos[0].estado).toBe('CONFIRMADO');
    expect(db.cuentasTes.get('tes-1')!.saldo_actual).toBe(1000);
  });

  it('un error de la reversa de Tesorería ya no se traga: aborta la anulación', async () => {
    const { service, db, contab } = base({ fallaSaldoCuenta: true });
    const e = await errorDe(service.anular('op-1', MOTIVO, 'emp-1', 'u-1'));
    expect((e as unknown as Error).message).toBe('deadlock detected');
    expect(db.confirmadas).toEqual([]);
    expect(db.ordenes.get('op-1')!.anulado).toBe(false);
    expect(contab.revertirDocumento).not.toHaveBeenCalled();
  });
});

describe('anular: lo que escribe', () => {
  it('anular pagada revierte saldos, cheques EN_CARTERA/DIFERIDO, movimientos y saldo de la cuenta en la misma tx', async () => {
    const { service, db, contab, audit, prisma, txs } = base({
      orden: ordenBase({
        monto_total: 500,
        orden_pago_proveedor_det: [
          { cuenta_pagar_id: 'cxp-b', monto: 200, medio_pago_id: 'mp-efectivo', medio_pago: MEDIO_EFECTIVO },
          { cuenta_pagar_id: 'cxp-a', monto: 300, medio_pago_id: 'mp-efectivo', medio_pago: MEDIO_EFECTIVO },
        ],
      }),
      cuotas: [
        cuota('cxp-a'),
        cuota('cxp-b', { monto_original: 500, monto_pagado: 200, saldo_pendiente: 300, estado: 'parcial' }),
      ],
      cheques: [
        {
          id: 'ch-1',
          empresa_id: 'emp-1',
          origen_tipo: 'ORDEN_PAGO_PROVEEDOR',
          origen_id: 'op-1',
          estado: 'EN_CARTERA',
        },
        { id: 'ch-2', empresa_id: 'emp-1', origen_tipo: 'ORDEN_PAGO_PROVEEDOR', origen_id: 'op-1', estado: 'DIFERIDO' },
      ],
    });

    const r = await service.anular('op-1', MOTIVO, 'emp-1', 'u-1');

    expect(r).toMatchObject({ id: 'op-1', leida: true });
    expect(prisma.$transaction).toHaveBeenCalledTimes(1);
    expect(prisma.$transaction.mock.calls[0][1]).toEqual({ timeout: 60_000 });
    const [tx] = txs;
    // Locks: op: y después cxp: ascendentes; la relectura de las cuotas va después del último lock.
    const claves = tx.$executeRaw.mock.calls.map((c: any[]) => c[1]);
    expect(claves).toEqual(['op:op-1', 'cxp:cxp-a', 'cxp:cxp-b']);
    const ultimoLock = tx.$executeRaw.mock.invocationCallOrder[2];
    expect(tx.cuentas_pagar.findMany.mock.invocationCallOrder[0]).toBeGreaterThan(ultimoLock);
    expect(tx.orden_pago_proveedor_cab.findFirst.mock.invocationCallOrder[0]).toBeGreaterThan(
      tx.$executeRaw.mock.invocationCallOrder[0],
    );

    expect(db.cuotas.get('cxp-a')).toMatchObject({ monto_pagado: 0, saldo_pendiente: 300, estado: 'pendiente' });
    expect(db.cuotas.get('cxp-b')).toMatchObject({ monto_pagado: 0, saldo_pendiente: 500, estado: 'pendiente' });
    expect(db.pagos[0]).toMatchObject({ anulado: true, estado: 'anulado', motivo_anulacion: MOTIVO.motivo });
    expect(db.cheques.map((c: Fila) => [c.estado, c.motivo])).toEqual([
      ['ANULADO', MOTIVO.motivo],
      ['ANULADO', MOTIVO.motivo],
    ]);
    expect(db.movimientos[0]).toMatchObject({ estado: 'ANULADO', motivo_anulacion: MOTIVO.motivo, anulado_por: 'u-1' });
    expect(db.cuentasTes.get('tes-1')!.saldo_actual).toBe(1300);
    expect(contab.revertirDocumento).toHaveBeenCalledWith('orden_pago_proveedor_cab', 'op-1', 'u-1', tx);
    for (const delegado of ['cuentas_pagar', 'tes_cheques', 'tes_movimientos', 'tes_cuentas']) {
      // Nada se escribió fuera de la transacción.
      expect((prisma as any)[delegado].update?.mock?.calls?.length ?? 0).toBe(0);
      expect((prisma as any)[delegado].updateMany?.mock?.calls?.length ?? 0).toBe(0);
    }
    // La auditoría va después del commit, con el motivo.
    expect(audit.log).toHaveBeenCalledWith(
      expect.objectContaining({
        action: 'CANCEL',
        entity_type: 'orden_pago_proveedor',
        entity_id: 'op-1',
        descripcion: MOTIVO.motivo,
      }),
    );
    expect(audit.log.mock.invocationCallOrder[0]).toBeGreaterThan(prisma.$transaction.mock.invocationCallOrder[0]);
  });

  it('graba el motivo real (con trim), nunca «Anulación manual», y no pisa usuario_id', async () => {
    const { service, db } = base();
    await service.anular('op-1', { motivo: '  Pago duplicado  ' }, 'emp-1', 'u-1');
    const orden = db.ordenes.get('op-1')!;
    expect(orden).toMatchObject({
      anulado: true,
      estado: 'ANULADA',
      motivo_anulacion: 'Pago duplicado',
      usuario_id: 'u-creador',
    });
    expect(JSON.stringify(db)).not.toContain('Anulación manual');
    expect(JSON.stringify(db)).not.toContain('Anulación de orden de pago');
  });

  it('anular un borrador solo libera las cuotas: no toca saldos, pagos, Tesorería ni el asiento', async () => {
    const { service, db, contab, txs } = base({
      orden: ordenBase({ estado: 'BORRADOR' }),
      cuotas: [cuota('cxp-a', { monto_pagado: 0, saldo_pendiente: 300, estado: 'pendiente' })],
      movimientos: [],
    });
    await service.anular('op-1', MOTIVO, 'emp-1', 'u-1');
    expect(db.confirmadas).toEqual(['orden']);
    expect(db.ordenes.get('op-1')).toMatchObject({ anulado: true, estado: 'ANULADA' });
    expect(txs[0].$executeRaw.mock.calls.map((c: any[]) => c[1])).toEqual(['op:op-1']);
    expect(contab.revertirDocumento).not.toHaveBeenCalled();
  });

  it('dos anular simultáneos: el segundo → OP_ESTADO_CAMBIADO y los saldos se devuelven una sola vez', async () => {
    const { service, db } = base();
    const r = await Promise.allSettled([
      service.anular('op-1', MOTIVO, 'emp-1', 'u-1'),
      service.anular('op-1', MOTIVO, 'emp-1', 'u-2'),
    ]);
    expect(r.map(codigoDe).sort()).toEqual(['OK', 'OP_ESTADO_CAMBIADO']);
    const rechazado = r.find((x) => x.status === 'rejected') as PromiseRejectedResult;
    expect(cuerpo(rechazado.reason)).toMatchObject({ estado_actual: 'anulada' });
    expect(db.cuotas.get('cxp-a')).toMatchObject({ monto_pagado: 0, saldo_pendiente: 300 });
    expect(db.cuentasTes.get('tes-1')!.saldo_actual).toBe(1300);
  });
});

describe('reintentarTesoreria', () => {
  it('con el egreso ya registrado → OP_ESTADO_CAMBIADO (lock op: y relectura)', async () => {
    const { service, txs, audit } = base();
    const e = await errorDe(service.reintentarTesoreria('op-1', 'emp-1', 'u-1'));
    expect(cuerpo(e)).toMatchObject({ codigo: 'OP_ESTADO_CAMBIADO', estado_actual: 'pagada' });
    expect(txs[0].$executeRaw.mock.calls.map((c: any[]) => c[1])).toEqual(['op:op-1']);
    expect(audit.log).not.toHaveBeenCalled();
  });

  it('una orden no pagada → OP_ESTADO_CAMBIADO', async () => {
    const { service } = base({ orden: ordenBase({ estado: 'BORRADOR' }), movimientos: [] });
    const e = await errorDe(service.reintentarTesoreria('op-1', 'emp-1', 'u-1'));
    expect(cuerpo(e)).toMatchObject({ codigo: 'OP_ESTADO_CAMBIADO', estado_actual: 'borrador' });
  });

  it('sin egreso → lo registra dentro de la tx del lock, audita RETRY_TESORERIA y devuelve findOne + avisos', async () => {
    const { service, db, txs, audit } = base({ movimientos: [] });
    const r = await service.reintentarTesoreria('op-1', 'emp-1', 'u-1');

    expect(r).toEqual({ id: 'op-1', leida: true, avisos: {} });
    expect(db.movimientos).toHaveLength(1);
    expect(db.movimientos[0]).toMatchObject({
      tipo: 'EGRESO',
      origen_tipo: 'ORDEN_PAGO_PROVEEDOR',
      origen_id: 'op-1',
      cuenta_id: 'tes-1',
      monto: 300,
    });
    expect(db.cuentasTes.get('tes-1')!.saldo_actual).toBe(700);
    expect(txs).toHaveLength(1);
    expect(txs[0].tes_movimientos.create).toHaveBeenCalled();
    expect(audit.log).toHaveBeenCalledWith(expect.objectContaining({ action: 'RETRY_TESORERIA', entity_id: 'op-1' }));
  });

  it('sin el puente de Tesorería → 400 con codigo TESORERIA_NO_DISPONIBLE', async () => {
    const { service, prisma } = base({ movimientos: [] });
    delete prisma.tes_reglas;
    const e = await errorDe(service.reintentarTesoreria('op-1', 'emp-1', 'u-1'));
    expect(e).toBeInstanceOf(BadRequestException);
    expect(cuerpo(e)).toMatchObject({
      codigo: 'TESORERIA_NO_DISPONIBLE',
      message: 'El puente OP->Tesorería no está disponible en este entorno.',
    });
  });

  it('dos reintentarTesoreria simultáneos: [OK, OP_ESTADO_CAMBIADO] y un solo egreso', async () => {
    const { service, db } = base({ movimientos: [] });
    const r = await Promise.allSettled([
      service.reintentarTesoreria('op-1', 'emp-1', 'u-1'),
      service.reintentarTesoreria('op-1', 'emp-1', 'u-2'),
    ]);
    expect(r.map(codigoDe)).toEqual(['OK', 'OP_ESTADO_CAMBIADO']);
    expect(db.movimientos.filter((m: Fila) => m.tipo === 'EGRESO')).toHaveLength(1);
    expect(db.cuentasTes.get('tes-1')!.saldo_actual).toBe(700);
  });

  it('si el registro falla, no queda nada escrito, la respuesta trae avisos.tesoreria y la auditoría lo dice', async () => {
    const { service, db, audit } = base({
      movimientos: [],
      orden: ordenBase({
        orden_pago_proveedor_det: [
          {
            cuenta_pagar_id: 'cxp-a',
            monto: 300,
            medio_pago_id: 'mp-efectivo',
            medio_pago: MEDIO_EFECTIVO,
            cuenta_bancaria_id: null,
          },
        ],
      }),
    });
    jest
      .spyOn(service as any, 'getCuentaTesoreriaPagoProveedor')
      .mockResolvedValue({ id: null, warning: 'Falta la regla PAGO_PROVEEDOR' });
    const r: any = await service.reintentarTesoreria('op-1', 'emp-1', 'u-1');
    expect(r.avisos.tesoreria).toContain('Falta la regla PAGO_PROVEEDOR');
    expect(db.confirmadas).toEqual([]);
    expect(audit.log).toHaveBeenCalledWith(
      expect.objectContaining({
        action: 'RETRY_TESORERIA',
        descripcion: expect.stringContaining('Falta la regla PAGO_PROVEEDOR'),
      }),
    );
  });
});

describe('reintentarContabilidad', () => {
  it('sin módulo Contabilidad → OP_ESTADO_CAMBIADO', async () => {
    const { service, contab, txs } = base({ conContabilidad: false });
    const e = await errorDe(service.reintentarContabilidad('op-1', 'emp-1', 'u-1'));
    expect(cuerpo(e)).toMatchObject({ codigo: 'OP_ESTADO_CAMBIADO' });
    expect(txs[0].$executeRaw.mock.calls.map((c: any[]) => c[1])).toEqual(['op:op-1']);
    expect(contab.integrarOrdenPago).not.toHaveBeenCalled();
  });

  it('ya asentada → OP_ESTADO_CAMBIADO', async () => {
    const { service, contab } = base({ docContable: { estado: 'CONFIRMADO' } });
    const e = await errorDe(service.reintentarContabilidad('op-1', 'emp-1', 'u-1'));
    expect(cuerpo(e).codigo).toBe('OP_ESTADO_CAMBIADO');
    expect(contab.integrarOrdenPago).not.toHaveBeenCalled();
  });

  it.each([[null], [{ estado: 'BORRADOR' }]])(
    'pagada con documento %p → integra con el lock tomado, audita RETRY_CONTABILIDAD',
    async (doc) => {
      const { service, contab, audit, prisma } = base({ docContable: doc });
      const r = await service.reintentarContabilidad('op-1', 'emp-1', 'u-1');
      expect(contab.integrarOrdenPago).toHaveBeenCalledWith('op-1');
      expect(r).toMatchObject({ id: 'op-1', leida: true, avisos: expect.any(Object) });
      expect(audit.log).toHaveBeenCalledWith(
        expect.objectContaining({ action: 'RETRY_CONTABILIDAD', entity_id: 'op-1' }),
      );
      expect(audit.log.mock.invocationCallOrder[0]).toBeGreaterThan(prisma.$transaction.mock.invocationCallOrder[0]);
    },
  );

  it('falta de mapeo (conAvisoDeMapeo la absorbe y no deja documento) → el aviso dice el motivo, como en BORRADOR', async () => {
    const { service, contab, db } = base();
    db.avisosMapeo.push({
      id: 'aviso-viejo',
      empresa_id: 'emp-1',
      action: 'CONT_FALTA_MAPEO',
      entity_type: 'orden_pago_proveedor_cab',
      entity_id: 'op-1',
      descripcion: 'Falta que el contador mapee: CAJA.',
    });
    contab.integrarOrdenPago.mockImplementationOnce(async () => {
      db.avisosMapeo.push({
        id: 'aviso-nuevo',
        empresa_id: 'emp-1',
        action: 'CONT_FALTA_MAPEO',
        entity_type: 'orden_pago_proveedor_cab',
        entity_id: 'op-1',
        descripcion: 'Falta que el contador mapee: PROVEEDORES.',
      });
    });
    const r: any = await service.reintentarContabilidad('op-1', 'emp-1', 'u-1');
    expect(r.avisos.contabilidad).toBe(
      'La orden sigue sin asiento: falta el mapeo de cuentas. Falta que el contador mapee: PROVEEDORES.',
    );
  });

  it('sigue sin asiento sin aviso de mapeo nuevo (el viejo no cuenta) → «sigue sin asiento contable»', async () => {
    const { service, db } = base();
    db.avisosMapeo.push({
      id: 'aviso-viejo',
      empresa_id: 'emp-1',
      action: 'CONT_FALTA_MAPEO',
      entity_type: 'orden_pago_proveedor_cab',
      entity_id: 'op-1',
      descripcion: 'Falta que el contador mapee: CAJA.',
    });
    const r: any = await service.reintentarContabilidad('op-1', 'emp-1', 'u-1');
    expect(r.avisos.contabilidad).toBe('La orden sigue sin asiento contable.');
  });

  it('si integrar falla, la respuesta trae avisos.contabilidad con el motivo (no un catch que solo loguea)', async () => {
    const { service, contab } = base();
    contab.integrarOrdenPago.mockRejectedValueOnce(new Error('El período 10/2026 está cerrado'));
    const r: any = await service.reintentarContabilidad('op-1', 'emp-1', 'u-1');
    expect(r.avisos.contabilidad).toContain('El período 10/2026 está cerrado');
  });
});

describe('estadosTesoreriaOps (F7: un solo cálculo para reintentos, listado y detalle)', () => {
  it('resuelve en lote: vigente, PENDIENTE, sin caja, anulada y automática', async () => {
    const { service, prisma, db } = base();
    db.ordenes.set('op-2', { ...ordenBase({ id: 'op-2' }) });
    db.ordenes.set('op-3', {
      ...ordenBase({
        id: 'op-3',
        orden_pago_proveedor_det: [
          { medio_pago_id: 'mp-anticipo', medio_pago: { codigo: 11, descripcion: 'Pago por anticipo' } },
        ],
      }),
    });
    db.ordenes.set('op-4', { ...ordenBase({ id: 'op-4', anulado: true, estado: 'ANULADA' }) });
    db.ordenes.set('op-5', { ...ordenBase({ id: 'op-5', origen: 'compra_auto' }) });
    db.movimientos.push({
      id: 'mov-2',
      empresa_id: 'emp-1',
      origen_tipo: 'ORDEN_PAGO_PROVEEDOR',
      origen_id: 'op-2',
      estado: 'ANULADO',
    });
    db.cheques.push({
      id: 'ch-9',
      empresa_id: 'emp-1',
      origen_tipo: 'ORDEN_PAGO_PROVEEDOR',
      origen_id: 'op-5',
      estado: 'EN_CARTERA',
    });

    const m = await service.estadosTesoreriaOps(prisma, 'emp-1', ['op-1', 'op-2', 'op-3', 'op-4', 'op-5']);

    expect(Object.fromEntries(m)).toEqual({
      'op-1': 'CONFIRMADO',
      'op-2': 'PENDIENTE',
      'op-3': null,
      'op-4': null,
      'op-5': null,
    });
    // Dos lecturas de Tesorería para todas las órdenes, no una por orden.
    expect(prisma.tes_movimientos.findMany).toHaveBeenCalledTimes(1);
    expect(prisma.tes_cheques.findMany).toHaveBeenCalledTimes(1);
  });

  it('sin ids no consulta nada', async () => {
    const { service, prisma } = base();
    expect((await service.estadosTesoreriaOps(prisma, 'emp-1', [])).size).toBe(0);
    expect(prisma.orden_pago_proveedor_cab.findMany).not.toHaveBeenCalled();
  });
});

describe('revisión final: alcance por sucursal en anular y los reintentos (404 fuera)', () => {
  const ALCANCE_A = { sucursalIds: ['suc-1'], puntosEstablecimiento: [], depositoIds: [] };
  const ACCIONES: Array<[string, (s: PagosProveedorService) => Promise<unknown>, Opciones]> = [
    ['anular', (s) => s.anular('op-1', MOTIVO, 'emp-1', 'u-1'), {}],
    ['reintentarTesoreria', (s) => s.reintentarTesoreria('op-1', 'emp-1', 'u-1'), { movimientos: [] }],
    ['reintentarContabilidad', (s) => s.reintentarContabilidad('op-1', 'emp-1', 'u-1'), {}],
  ];

  it.each(ACCIONES)('%s sobre una OP de otra sucursal → 404 y no escribe nada', async (_n, accion, o) => {
    alcanceMock.mockResolvedValue(ALCANCE_A);
    const { service, db, audit, contab } = base({ ...o, orden: ordenBase({ sucursal_id: 'suc-2' }) });

    const e = await errorDe(accion(service));

    expect(e.getStatus()).toBe(404);
    expect(db.confirmadas).toEqual([]);
    expect(db.ordenes.get('op-1')).toMatchObject({ estado: 'PAGADO', anulado: false });
    expect(db.cuotas.get('cxp-a')).toMatchObject({ saldo_pendiente: 0, monto_pagado: 300 });
    expect(contab.integrarOrdenPago).not.toHaveBeenCalled();
    expect(contab.revertirDocumento).not.toHaveBeenCalled();
    expect(audit.log).not.toHaveBeenCalled();
  });

  it('control: con la OP en su sucursal, anular la anula y devuelve el saldo', async () => {
    alcanceMock.mockResolvedValue(ALCANCE_A);
    const { service, db } = base();
    await service.anular('op-1', MOTIVO, 'emp-1', 'u-1');
    expect(db.ordenes.get('op-1')).toMatchObject({ estado: 'ANULADA', anulado: true });
    expect(db.cuotas.get('cxp-a')).toMatchObject({ saldo_pendiente: 300, monto_pagado: 0 });
  });

  it('control: con la OP en su sucursal y sin egreso, reintentarTesoreria lo registra', async () => {
    alcanceMock.mockResolvedValue(ALCANCE_A);
    const { service, db } = base({ movimientos: [] });
    await service.reintentarTesoreria('op-1', 'emp-1', 'u-1');
    expect(db.movimientos).toHaveLength(1);
  });
});

describe('anularAutomaticasDeCompraEnTx: la factura de contado anula su orden automática (U6)', () => {
  const AUTO = { origen: 'compra_auto', compra_id: 'c-9' };
  const correr = (h: ReturnType<typeof base>, compraId = 'c-9', empresa = 'emp-1') =>
    h.prisma.$transaction((tx: any) =>
      h.service.anularAutomaticasDeCompraEnTx(tx, empresa, compraId, 'Anulada por la anulación de la factura', 'u-1'),
    );

  it('anula la orden PAGADA y revierte cuota, pago, Tesorería (saldo) y asiento en la misma transacción', async () => {
    const h = base({ orden: ordenBase(AUTO) });
    expect(await correr(h)).toEqual([expect.objectContaining({ id: 'op-1', numero: '001-001-0000005', pagada: true })]);
    expect(db(h).ordenes.get('op-1')).toMatchObject({ anulado: true, estado: 'ANULADA', motivo_anulacion: 'Anulada por la anulación de la factura' });
    expect(db(h).cuotas.get('cxp-a')).toMatchObject({ monto_pagado: 0, saldo_pendiente: 300, estado: 'pendiente' });
    expect(db(h).pagos[0].anulado).toBe(true);
    expect(db(h).cuentasTes.get('tes-1')!.saldo_actual).toBe(1300);
    expect(h.contab.revertirDocumento).toHaveBeenCalledWith('orden_pago_proveedor_cab', 'op-1', 'u-1', expect.anything());
    expect(h.txs).toHaveLength(1);
  });

  it('es idempotente: una orden ya anulada se salta sin tocar nada', async () => {
    const h = base({ orden: ordenBase({ ...AUTO, anulado: true, estado: 'ANULADA' }) });
    expect(await correr(h)).toEqual([]);
    expect(db(h).confirmadas).toEqual([]);
  });

  it('no toca las órdenes manuales ni las de otra compra o empresa', async () => {
    const h = base({ orden: ordenBase({ origen: 'manual', compra_id: 'c-9' }) });
    expect(await correr(h)).toEqual([]);
    const h2 = base({ orden: ordenBase(AUTO) });
    expect(await correr(h2, 'c-otra')).toEqual([]);
    expect(await correr(h2, 'c-9', 'emp-2')).toEqual([]);
    expect(db(h2).ordenes.get('op-1')!.anulado).toBe(false);
  });

  it('registrarHistorialAnulacionAutomaticas deja el CANCEL de cada orden con el usuario y el motivo', async () => {
    const h = base({ orden: ordenBase(AUTO) });
    const anuladas = await correr(h);
    await h.service.registrarHistorialAnulacionAutomaticas('emp-1', 'u-1', anuladas);
    expect(h.audit.log).toHaveBeenCalledWith(
      expect.objectContaining({ empresa_id: 'emp-1', user_id: 'u-1', action: 'CANCEL', entity_id: 'op-1', descripcion: 'Anulada por la anulación de la factura' }),
    );
  });

  it('toma el lock op: antes de escribir', async () => {
    const h = base({ orden: ordenBase(AUTO) });
    await correr(h);
    const claves = h.txs[0].$executeRaw.mock.calls.flatMap((c: any[]) => c.slice(1).filter((v: unknown) => typeof v === 'string'));
    expect(claves[0]).toBe('op:op-1');
  });

  it('con un cheque fuera de cartera o un egreso conciliado falla con su código y no deja nada', async () => {
    const h = base({ orden: ordenBase(AUTO), conciliados: ['mov-1'] });
    expect(cuerpo(await errorDe(correr(h))).codigo).toBe('OP_CONCILIADA');
    expect(db(h).confirmadas).toEqual([]);
    const h2 = base({
      orden: ordenBase(AUTO),
      cheques: [{ id: 'ch-1', empresa_id: 'emp-1', origen_tipo: 'ORDEN_PAGO_PROVEEDOR', origen_id: 'op-1', estado: 'COBRADO', numero_cheque: '77' }],
    });
    expect(cuerpo(await errorDe(correr(h2))).codigo).toBe('OP_CHEQUE_FUERA_DE_CARTERA');
    expect(db(h2).confirmadas).toEqual([]);
  });
});
const db = (h: { db: any }) => h.db;
