import { NotaCreditoComprasService } from './nota-credito-compras.service';

/**
 * Alta de NC de compra (plan 2026-10-22-nc-compra, Task 3): origen del mismo proveedor y
 * vigente, líneas de la compra origen, disponible sin carreras, tope del total, moneda y
 * cotización resueltas en el backend.
 */

const PYG = 'pyg';
const USD = 'usd';

type Opts = {
  compra?: Record<string, unknown> | null;
  gasto?: Record<string, unknown> | null;
  lineasCompra?: Array<{ id: string }>;
  duplicado?: boolean;
  filasUpdate?: number;
  totalOrigen?: number;
  ncVigentes?: number[];
  /** Lo que lee el SELECT ... FOR UPDATE del origen (por defecto, igual que el origen). */
  bloqueado?: Record<string, unknown>;
  /** Monedas activas de la empresa (`empresa_monedas`). */
  monedasEmpresa?: string[];
  gastoDet?: Array<Record<string, unknown>>;
  /** Cuotas del proveedor (`cuentas_pagar`); el mock aplica el filtro de moneda, ids y saldo. */
  cuotas?: Array<Record<string, any>>;
  /** Productos con su `maneja_inventario`. */
  productos?: Array<{ id: string; maneja_inventario: boolean }>;
  /** Depósitos activos de la empresa (por defecto, cualquiera que se pida). */
  depositosActivos?: string[];
};

/** Filtro mínimo de `cuentas_pagar.findMany` para el mock: moneda (con OR de null), ids y saldos. */
function filtrarCuotas(cuotas: Array<Record<string, any>>, where: any = {}) {
  const cumple = (c: Record<string, any>, w: any): boolean => {
    if (w.OR && !w.OR.some((o: any) => cumple(c, o))) return false;
    if ('moneda_id' in w && (c.moneda_id ?? null) !== w.moneda_id) return false;
    if (w.id?.in && !w.id.in.includes(c.id)) return false;
    if (w.saldo_pendiente?.gt != null && !(Number(c.saldo_pendiente) > w.saldo_pendiente.gt)) return false;
    if (w.monto_pagado?.gt != null && !(Number(c.monto_pagado) > w.monto_pagado.gt)) return false;
    if (w.compra_id && c.compra_id !== w.compra_id) return false;
    return true;
  };
  return cuotas
    .filter((c) => cumple(c, where))
    .sort((a, b) => String(a.fecha_vencimiento).localeCompare(String(b.fecha_vencimiento)));
}

function armar(opts: Opts = {}) {
  const compraBase = {
    id: 'c1',
    proveedor_id: 'prov',
    deposito_id: null,
    total: 1000,
    moneda_id: USD,
    cotizacion: 7300,
    anulado: false,
    estado: 'pendiente',
  };
  const compra = opts.compra === null ? null : { ...compraBase, ...opts.compra };
  const gastoBase = {
    id: 'g1',
    proveedor_id: 'prov',
    total: 1000,
    moneda_id: PYG,
    cotizacion: 1,
    anulado: false,
    estado: 'registrado',
    deducible: true,
  };
  const gasto = opts.gasto === null ? null : { ...gastoBase, ...opts.gasto };

  let dentro = false;
  const tx: any = {
    $queryRaw: jest.fn().mockResolvedValue([
      {
        total: opts.totalOrigen ?? 1000,
        proveedor_id: 'prov',
        anulado: false,
        estado: 'pendiente',
        ...opts.bloqueado,
      },
    ]),
    $executeRaw: jest.fn().mockResolvedValue(opts.filasUpdate ?? 1),
    nota_credito_compra_cab: {
      findMany: jest.fn().mockResolvedValue((opts.ncVigentes ?? []).map((t) => ({ total: t }))),
      create: jest.fn().mockResolvedValue({ id: 'nc1' }),
    },
    nota_credito_compra_det: { create: jest.fn().mockResolvedValue({}) },
    compra_det: { findUnique: jest.fn().mockResolvedValue({ cantidad: 5, cantidad_acreditada_nc: 5 }) },
    cuentas_pagar: {
      findMany: jest
        .fn()
        .mockImplementation(({ where }: any) => Promise.resolve(filtrarCuotas(opts.cuotas ?? [], where))),
      update: jest.fn(),
    },
    nota_credito_compra_aplicaciones: { createMany: jest.fn().mockResolvedValue({ count: 0 }) },
    compra_cab: { update: jest.fn() },
    // tipoMovimientoInventarioId busca por código exacto (DEV_COMPRA).
    tipo_movimiento_inventario: {
      findFirst: jest.fn().mockResolvedValue({ id: 'tm-salida' }),
      findUnique: jest.fn().mockResolvedValue({ id: 'tm-salida' }),
    },
    productos: {
      findFirst: jest
        .fn()
        .mockImplementation(({ where }: any) =>
          Promise.resolve((opts.productos ?? []).find((p) => p.id === where.id) ?? null),
        ),
    },
    stock_deposito: { findUnique: jest.fn().mockResolvedValue(null), upsert: jest.fn() },
    movimientos_inventario: { create: jest.fn() },
  };
  const prisma: any = {
    proveedores: { findFirst: jest.fn().mockResolvedValue({ id: 'prov' }) },
    nota_credito_compra_cab: {
      findFirst: jest.fn().mockResolvedValue(opts.duplicado ? { id: 'otra' } : null),
      findMany: jest.fn().mockResolvedValue([]),
    },
    compra_cab: { findFirst: jest.fn().mockResolvedValue(compra) },
    gasto_cab: {
      findFirst: jest.fn().mockResolvedValue(
        gasto && {
          ...gasto,
          gasto_det: opts.gastoDet ?? [],
          moneda: { id: PYG, codigo: 'PYG', descripcion: 'Guaraní' },
        },
      ),
    },
    compra_det: { findMany: jest.fn().mockResolvedValue(opts.lineasCompra ?? [{ id: 'cd1' }]) },
    depositos: {
      findFirst: jest
        .fn()
        .mockImplementation(({ where }: any) =>
          Promise.resolve(!opts.depositosActivos || opts.depositosActivos.includes(where.id) ? { id: where.id } : null),
        ),
    },
    productos: {
      findMany: jest
        .fn()
        .mockImplementation(({ where }: any) =>
          Promise.resolve((opts.productos ?? []).filter((p) => where.id.in.includes(p.id))),
        ),
    },
    empresa_monedas: {
      findFirst: jest.fn().mockImplementation(({ where }: any) => {
        if (where.es_principal) return Promise.resolve({ moneda_id: PYG });
        return Promise.resolve(
          (opts.monedasEmpresa ?? [PYG, USD]).includes(where.moneda_id) ? { moneda_id: where.moneda_id } : null,
        );
      }),
    },
    moneda: { findFirst: jest.fn().mockResolvedValue({ id: PYG }) },
    $transaction: jest.fn().mockImplementation(async (fn: any) => {
      dentro = true;
      try {
        return await fn(tx);
      } finally {
        dentro = false;
      }
    }),
  };
  // El tope y la carrera se leen dentro de la transacción.
  for (const k of ['$queryRaw', '$executeRaw']) {
    const f = tx[k];
    tx[k] = jest.fn().mockImplementation((...a: any[]) => {
      if (!dentro) throw new Error(`${k} fuera de la $transaction`);
      return f(...a);
    });
  }
  const audit = { log: jest.fn().mockResolvedValue(undefined) };
  const contabilidad = { integrarNotaCreditoCompra: jest.fn().mockResolvedValue(undefined) };
  // Sin lotes en el depósito: la devolución sale sin lote (los lotes se prueban en nota-credito-compras-lotes.spec.ts).
  const lotes = { usaLotesEnDeposito: jest.fn().mockResolvedValue(false), bloquearStockDe: jest.fn().mockResolvedValue(undefined) };
  const service = new NotaCreditoComprasService(prisma, audit as any, contabilidad as any, lotes as any, {} as any);
  jest.spyOn(service, 'findOne').mockResolvedValue({ id: 'nc1' } as any);
  return { service, prisma, tx };
}

const item = (extra: Record<string, unknown> = {}) => ({
  descripcion: 'Tornillo',
  cantidad: 1,
  precio_unitario: 100,
  porcentaje_iva: 10,
  ...extra,
});
const dtoBase = (extra: Record<string, unknown> = {}): any => ({ proveedor_id: 'prov', items: [item()], ...extra });

async function cuerpoError(p: Promise<unknown>): Promise<{ codigo: string; campo?: string; message: string }> {
  try {
    await p;
  } catch (e: any) {
    return e.getResponse();
  }
  throw new Error('No lanzó');
}

describe('NotaCreditoComprasService.create', () => {
  it('compra de otro proveedor → ORIGEN_DE_OTRO_PROVEEDOR', async () => {
    const { service, prisma } = armar({ compra: { proveedor_id: 'otro' } });
    expect(await cuerpoError(service.create(dtoBase({ compra_id: 'c1' }), 'emp', 'u1'))).toMatchObject({
      codigo: 'ORIGEN_DE_OTRO_PROVEEDOR',
      campo: 'compra_id',
    });
    expect(prisma.$transaction).not.toHaveBeenCalled();
  });

  it('gasto de otro proveedor → ORIGEN_DE_OTRO_PROVEEDOR con campo gasto_id', async () => {
    const { service } = armar({ gasto: { proveedor_id: 'otro' } });
    expect(await cuerpoError(service.create(dtoBase({ gasto_id: 'g1' }), 'emp', 'u1'))).toMatchObject({
      codigo: 'ORIGEN_DE_OTRO_PROVEEDOR',
      campo: 'gasto_id',
    });
  });

  it('compra anulada → ORIGEN_ANULADO', async () => {
    const { service, prisma } = armar({ compra: { anulado: true, estado: 'anulada' } });
    expect(await cuerpoError(service.create(dtoBase({ compra_id: 'c1' }), 'emp', 'u1'))).toMatchObject({
      codigo: 'ORIGEN_ANULADO',
      campo: 'compra_id',
    });
    expect(prisma.$transaction).not.toHaveBeenCalled();
  });

  it('gasto anulado → ORIGEN_ANULADO con campo gasto_id', async () => {
    const { service } = armar({ gasto: { anulado: true } });
    expect(await cuerpoError(service.create(dtoBase({ gasto_id: 'g1' }), 'emp', 'u1'))).toMatchObject({
      codigo: 'ORIGEN_ANULADO',
      campo: 'gasto_id',
    });
  });

  it('gasto no deducible → ORIGEN_NO_DEDUCIBLE con campo gasto_id, sin grabar (el buscador solo lista deducibles)', async () => {
    for (const deducible of [false, null]) {
      const { service, prisma } = armar({ gasto: { deducible } });
      expect(await cuerpoError(service.create(dtoBase({ gasto_id: 'g1' }), 'emp', 'u1'))).toMatchObject({
        codigo: 'ORIGEN_NO_DEDUCIBLE',
        campo: 'gasto_id',
      });
      expect(prisma.$transaction).not.toHaveBeenCalled();
    }
  });

  it('ítem que descuenta stock sin depósito → DEPOSITO_REQUERIDO con campo deposito_id', async () => {
    const { service, prisma } = armar({ productos: [{ id: 'p-stock', maneja_inventario: true }] });
    expect(
      await cuerpoError(service.create(dtoBase({ moneda_id: PYG, items: [item({ producto_id: 'p-stock', afecta_stock: true })] }), 'emp', 'u1')),
    ).toMatchObject({ codigo: 'DEPOSITO_REQUERIDO', campo: 'deposito_id', message: 'Se requiere un depósito para ítems que descuentan stock' });
    expect(prisma.$transaction).not.toHaveBeenCalled();
  });

  it('el depósito de la compra origen está inactivo → DEPOSITO_REQUERIDO que lo dice; con otro depósito activo registra', async () => {
    const productos = [{ id: 'p-stock', maneja_inventario: true }];
    const lineas = [item({ producto_id: 'p-stock', afecta_stock: true, compra_det_id: 'cd1' })];
    const { service, prisma } = armar({ compra: { deposito_id: 'dep-viejo', moneda_id: PYG, cotizacion: 1 }, depositosActivos: ['dep-2'], productos });
    const cuerpo = await cuerpoError(service.create(dtoBase({ compra_id: 'c1', items: lineas }), 'emp', 'u1'));
    expect(cuerpo).toMatchObject({ codigo: 'DEPOSITO_REQUERIDO', campo: 'deposito_id' });
    expect(cuerpo.message).toMatch(/depósito de la compra origen no está activo/);
    expect(prisma.$transaction).not.toHaveBeenCalled();

    const otro = armar({ compra: { deposito_id: 'dep-viejo', moneda_id: PYG, cotizacion: 1 }, depositosActivos: ['dep-2'], productos });
    await otro.service.create(dtoBase({ compra_id: 'c1', deposito_id: 'dep-2', items: lineas }), 'emp', 'u1');
    expect(otro.tx.nota_credito_compra_cab.create.mock.calls[0][0].data.deposito_id).toBe('dep-2');
  });

  it('compra y gasto → ORIGEN_EXCLUYENTE', async () => {
    const { service, prisma } = armar();
    expect(await cuerpoError(service.create(dtoBase({ compra_id: 'c1', gasto_id: 'g1' }), 'emp', 'u1'))).toMatchObject({
      codigo: 'ORIGEN_EXCLUYENTE',
      campo: 'gasto_id',
    });
    expect(prisma.$transaction).not.toHaveBeenCalled();
  });

  it('compra_det_id de otra compra → LINEA_DE_OTRA_COMPRA', async () => {
    const { service, prisma } = armar({ lineasCompra: [] });
    expect(
      await cuerpoError(
        service.create(
          dtoBase({ compra_id: 'c1', cotizacion: 7300, items: [item({ compra_det_id: 'cd-ajena' })] }),
          'emp',
          'u1',
        ),
      ),
    ).toMatchObject({ codigo: 'LINEA_DE_OTRA_COMPRA', campo: 'items' });
    // Se buscan las líneas solo dentro de la compra origen.
    expect(prisma.compra_det.findMany.mock.calls[0][0].where).toMatchObject({
      compra_id: 'c1',
      id: { in: ['cd-ajena'] },
    });
    expect(prisma.$transaction).not.toHaveBeenCalled();
  });

  it('compra_det_id sin compra_id → LINEA_DE_OTRA_COMPRA', async () => {
    const { service, prisma } = armar();
    expect(
      await cuerpoError(
        service.create(dtoBase({ moneda_id: PYG, items: [item({ compra_det_id: 'cd1' })] }), 'emp', 'u1'),
      ),
    ).toMatchObject({
      codigo: 'LINEA_DE_OTRA_COMPRA',
      campo: 'items',
    });
    expect(prisma.$transaction).not.toHaveBeenCalled();
  });

  it('UPDATE condicional con 0 filas → CANTIDAD_SUPERA_DISPONIBLE y la transacción no graba', async () => {
    const { service, tx } = armar({ filasUpdate: 0 });
    const err = await cuerpoError(
      service.create(dtoBase({ compra_id: 'c1', items: [item({ compra_det_id: 'cd1', cantidad: 5 })] }), 'emp', 'u1'),
    );
    expect(err).toMatchObject({ codigo: 'CANTIDAD_SUPERA_DISPONIBLE', campo: 'items' });
    expect(err.message).toContain('Tornillo');
    // El UPDATE lleva la condición de disponible y de la compra origen.
    const [partes, ...valores] = tx.$executeRaw.mock.calls[0];
    const sql = partes.join('?');
    expect(sql).toMatch(/UPDATE compra_det/);
    expect(sql).toMatch(/compra_id = \?::uuid/);
    expect(sql).toMatch(/cantidad - cantidad_acreditada_nc >= \?/);
    expect(valores).toEqual(expect.arrayContaining([5, 'cd1', 'c1']));
    // Nada se grabó: ni la cabecera ni los detalles.
    expect(tx.nota_credito_compra_cab.create).not.toHaveBeenCalled();
    expect(tx.nota_credito_compra_det.create).not.toHaveBeenCalled();
  });

  it('total 600 con acreditable 500 → TOTAL_SUPERA_ORIGEN', async () => {
    const { service, tx } = armar({ totalOrigen: 1000, ncVigentes: [300, 200] });
    expect(
      await cuerpoError(
        service.create(dtoBase({ compra_id: 'c1', items: [item({ cantidad: 1, precio_unitario: 600 })] }), 'emp', 'u1'),
      ),
    ).toMatchObject({ codigo: 'TOTAL_SUPERA_ORIGEN', campo: 'total' });
    // Las NC vigentes del mismo origen, leídas en la transacción.
    expect(tx.nota_credito_compra_cab.findMany.mock.calls[0][0].where).toMatchObject({
      compra_id: 'c1',
      anulado: false,
      estado: { not: 'anulada' },
    });
    expect(tx.nota_credito_compra_cab.create).not.toHaveBeenCalled();
  });

  it('total igual a lo acreditable se acepta', async () => {
    const { service, tx } = armar({ totalOrigen: 1000, ncVigentes: [300, 200] });
    await service.create(
      dtoBase({ compra_id: 'c1', items: [item({ cantidad: 1, precio_unitario: 500 })] }),
      'emp',
      'u1',
    );
    expect(tx.nota_credito_compra_cab.create).toHaveBeenCalled();
  });

  it('duplicado → DOCUMENTO_DUPLICADO campo numero', async () => {
    const { service, prisma } = armar({ duplicado: true });
    expect(
      await cuerpoError(
        service.create(
          dtoBase({
            moneda_id: PYG,
            timbrado: '12345678',
            establecimiento: '001',
            punto_expedicion: '001',
            numero: '0000001',
          }),
          'emp',
          'u1',
        ),
      ),
    ).toMatchObject({ codigo: 'DOCUMENTO_DUPLICADO', campo: 'numero' });
    expect(prisma.$transaction).not.toHaveBeenCalled();
  });

  it('graba moneda_id y cotizacion resueltas', async () => {
    // Con origen USD 7300: el cliente manda 7000 y se graba la del origen.
    const { service, tx } = armar();
    await service.create(dtoBase({ compra_id: 'c1', moneda_id: USD, cotizacion: 7000 }), 'emp', 'u1');
    expect(tx.nota_credito_compra_cab.create.mock.calls[0][0].data).toMatchObject({ moneda_id: USD, cotizacion: 7300 });

    // Sin origen en la moneda base: cotización 1 aunque el cliente mande otra.
    const otro = armar();
    await otro.service.create(dtoBase({ moneda_id: PYG, cotizacion: 5 }), 'emp', 'u1');
    expect(otro.tx.nota_credito_compra_cab.create.mock.calls[0][0].data).toMatchObject({
      moneda_id: PYG,
      cotizacion: 1,
    });
  });

  it('origen USD con cotización 1 y sin cotización del cliente → COTIZACION_REQUERIDA', async () => {
    const { service, prisma } = armar({ compra: { cotizacion: 1 } });
    expect(await cuerpoError(service.create(dtoBase({ compra_id: 'c1' }), 'emp', 'u1'))).toMatchObject({
      codigo: 'COTIZACION_REQUERIDA',
      campo: 'cotizacion',
    });
    expect(prisma.$transaction).not.toHaveBeenCalled();
  });
  it('origen anulado entre la validación y el bloqueo → ORIGEN_ANULADO y no graba', async () => {
    const { service, tx } = armar({ bloqueado: { anulado: true, estado: 'anulada' } });
    expect(await cuerpoError(service.create(dtoBase({ compra_id: 'c1' }), 'emp', 'u1'))).toMatchObject({
      codigo: 'ORIGEN_ANULADO',
      campo: 'compra_id',
    });
    const sql = tx.$queryRaw.mock.calls[0][0].join('?');
    expect(sql).toMatch(/FOR UPDATE/);
    expect(sql).toMatch(/anulado/);
    expect(sql).toMatch(/proveedor_id/);
    expect(tx.$executeRaw).not.toHaveBeenCalled();
    expect(tx.nota_credito_compra_cab.create).not.toHaveBeenCalled();
  });

  it('gasto origen que cambió de proveedor antes del bloqueo → ORIGEN_DE_OTRO_PROVEEDOR', async () => {
    const { service, tx } = armar({ bloqueado: { proveedor_id: 'otro', estado: 'registrado' } });
    expect(await cuerpoError(service.create(dtoBase({ gasto_id: 'g1' }), 'emp', 'u1'))).toMatchObject({
      codigo: 'ORIGEN_DE_OTRO_PROVEEDOR',
      campo: 'gasto_id',
    });
    expect(tx.nota_credito_compra_cab.create).not.toHaveBeenCalled();
  });

  it('sin origen con una moneda que no es de la empresa → MONEDA_REQUERIDA', async () => {
    const { service, prisma } = armar({ monedasEmpresa: [PYG] });
    expect(await cuerpoError(service.create(dtoBase({ moneda_id: USD, cotizacion: 7300 }), 'emp', 'u1'))).toMatchObject(
      {
        codigo: 'MONEDA_REQUERIDA',
        campo: 'moneda_id',
      },
    );
    expect(prisma.empresa_monedas.findFirst).toHaveBeenCalledWith(
      expect.objectContaining({ where: expect.objectContaining({ empresa_id: 'emp', moneda_id: USD, active: true }) }),
    );
    expect(prisma.$transaction).not.toHaveBeenCalled();
  });

  it('sin origen con una moneda activa de la empresa se acepta', async () => {
    const { service, tx } = armar();
    await service.create(dtoBase({ moneda_id: USD, cotizacion: 7300 }), 'emp', 'u1');
    expect(tx.nota_credito_compra_cab.create.mock.calls[0][0].data).toMatchObject({ moneda_id: USD, cotizacion: 7300 });
  });
});

describe('NotaCreditoComprasService.gastoOrigenDetalle', () => {
  it('respeta IVA 0 (exenta) y usa 10 solo si falta', async () => {
    const { service } = armar({
      gastoDet: [
        { descripcion: 'Exenta', cantidad: 1, precio_unitario: 100, porcentaje_iva: 0, tipo_gasto: null },
        { descripcion: 'Sin dato', cantidad: 1, precio_unitario: 100, porcentaje_iva: null, tipo_gasto: null },
        { descripcion: 'Cinco', cantidad: 1, precio_unitario: 100, porcentaje_iva: 5, tipo_gasto: null },
      ],
    });
    const r = await service.gastoOrigenDetalle('emp', 'g1', 'prov');
    expect(r.items.map((i) => i.porcentaje_iva)).toEqual([0, 10, 5]);
  });
});

// ─── Task 4: aplicaciones, cuentas por pagar en su moneda, anular exacto, listado y detalle ───

const cuota = (
  id: string,
  moneda_id: string | null,
  saldo: number,
  pagado: number,
  vence: string,
  extra: Record<string, unknown> = {},
) => ({
  id,
  moneda_id,
  saldo_pendiente: saldo,
  monto_pagado: pagado,
  monto_original: saldo + pagado,
  fecha_vencimiento: vence,
  numero_cuota: 1,
  compra_id: null,
  ...extra,
});

describe('NotaCreditoComprasService: cuentas por pagar en la moneda de la NC', () => {
  it('sin origen USD solo baja cuotas USD (con cuotas PYG y USD del proveedor)', async () => {
    const { service, tx } = armar({
      cuotas: [
        cuota('cp-pyg', PYG, 1_000_000, 0, '2026-01-01'),
        cuota('cp-null', null, 500_000, 0, '2026-01-02'),
        cuota('cp-usd', USD, 1000, 0, '2026-02-01'),
      ],
    });
    // 1 × 100 = 100 USD
    await service.create(dtoBase({ moneda_id: USD, cotizacion: 7300 }), 'emp', 'u1');
    const tocadas = tx.cuentas_pagar.update.mock.calls.map((c: any) => c[0].where.id);
    expect(tocadas).toEqual(['cp-usd']);
    expect(tx.cuentas_pagar.update.mock.calls[0][0].data).toMatchObject({
      saldo_pendiente: 900,
      monto_pagado: 100,
      estado: 'parcial',
    });
  });

  it('sin origen en moneda base también baja cuotas con moneda_id null', async () => {
    const { service, tx } = armar({
      cuotas: [
        cuota('cp-null', null, 60, 0, '2026-01-01'),
        cuota('cp-pyg', PYG, 1000, 0, '2026-01-02'),
        cuota('cp-usd', USD, 1000, 0, '2025-12-01'),
      ],
    });
    await service.create(dtoBase({ moneda_id: PYG }), 'emp', 'u1');
    const tocadas = tx.cuentas_pagar.update.mock.calls.map((c: any) => [c[0].where.id, c[0].data.saldo_pendiente]);
    expect(tocadas).toEqual([
      ['cp-null', 0],
      ['cp-pyg', 960],
    ]);
  });

  it('create graba una aplicación por cuota tocada y devuelve sin_descontar', async () => {
    const { service, tx } = armar({
      cuotas: [cuota('cp1', PYG, 30, 0, '2026-01-01'), cuota('cp2', PYG, 40, 0, '2026-01-02')],
    });
    const r: any = await service.create(dtoBase({ moneda_id: PYG }), 'emp', 'u1');
    expect(tx.nota_credito_compra_aplicaciones.createMany).toHaveBeenCalledWith({
      data: [
        { nota_credito_compra_id: 'nc1', cuenta_pagar_id: 'cp1', monto: 30 },
        { nota_credito_compra_id: 'nc1', cuenta_pagar_id: 'cp2', monto: 40 },
      ],
    });
    // total 100, aplicado 70
    expect(r).toMatchObject({ id: 'nc1', sin_descontar: 30 });
  });

  it('producto sin maneja_inventario: la línea queda afecta_stock false', async () => {
    const { service, tx } = armar({
      productos: [
        { id: 'p-serv', maneja_inventario: false },
        { id: 'p-stock', maneja_inventario: true },
      ],
    });
    await service.create(
      dtoBase({
        moneda_id: PYG,
        deposito_id: 'dep',
        items: [
          item({ producto_id: 'p-serv', afecta_stock: true }),
          item({ producto_id: 'p-stock', afecta_stock: true }),
        ],
      }),
      'emp',
      'u1',
    );
    const lineas = tx.nota_credito_compra_det.create.mock.calls.map((c: any) => [
      c[0].data.producto_id,
      c[0].data.afecta_stock,
    ]);
    expect(lineas).toEqual([
      ['p-serv', false],
      ['p-stock', true],
    ]);
    expect(tx.nota_credito_compra_cab.create.mock.calls[0][0].data.afecta_stock).toBe(true);
    expect(tx.movimientos_inventario.create).toHaveBeenCalledTimes(1);

    // Solo servicios (y sin depósito: no hace falta porque no se mueve stock).
    const otro = armar({ productos: [{ id: 'p-serv', maneja_inventario: false }] });
    await otro.service.create(
      dtoBase({ moneda_id: PYG, items: [item({ producto_id: 'p-serv', afecta_stock: true })] }),
      'emp',
      'u1',
    );
    expect(otro.tx.nota_credito_compra_cab.create.mock.calls[0][0].data.afecta_stock).toBe(false);
    expect(otro.tx.nota_credito_compra_det.create.mock.calls[0][0].data.afecta_stock).toBe(false);
  });
});

type OptsAnular = {
  nc?: Record<string, unknown>;
  aplicaciones?: Array<{ cuenta_pagar_id: string; monto: number }>;
  cuotas?: Array<Record<string, any>>;
  filasAnuladas?: number;
};

function armarAnular(opts: OptsAnular = {}) {
  const nc = {
    id: 'nc1',
    empresa_id: 'emp',
    proveedor_id: 'prov',
    compra_id: null,
    gasto_id: null,
    deposito_id: null,
    moneda_id: PYG,
    total: 300,
    afecta_stock: false,
    estado: 'registrada',
    anulado: false,
    numero: '0000001',
    detalles: [],
    // NULL = NC anterior a la columna (restauración FIFO).
    aplicado_cxp: null,
    ...opts.nc,
  };
  const tx: any = {
    $executeRaw: jest.fn().mockResolvedValue(1),
    nota_credito_compra_cab: { updateMany: jest.fn().mockResolvedValue({ count: opts.filasAnuladas ?? 1 }) },
    nota_credito_compra_aplicaciones: { findMany: jest.fn().mockResolvedValue(opts.aplicaciones ?? []) },
    cuentas_pagar: {
      findMany: jest
        .fn()
        .mockImplementation(({ where }: any) => Promise.resolve(filtrarCuotas(opts.cuotas ?? [], where))),
      update: jest.fn(),
    },
    compra_cab: { update: jest.fn() },
  };
  const prisma: any = {
    nota_credito_compra_cab: { findFirst: jest.fn().mockResolvedValue(nc) },
    $transaction: jest.fn().mockImplementation((fn: any) => fn(tx)),
  };
  const audit = { log: jest.fn().mockResolvedValue(undefined) };
  const contabilidad = { revertirDocumento: jest.fn().mockResolvedValue(undefined) };
  const service = new NotaCreditoComprasService(prisma, audit as any, contabilidad as any, {} as any, {} as any);
  jest.spyOn(service, 'findOne').mockResolvedValue({ id: 'nc1' } as any);
  return { service, prisma, tx, audit };
}

describe('NotaCreditoComprasService.anular', () => {
  it('anular con aplicaciones devuelve a esas cuotas exactas aunque otra cuota más vieja tenga monto_pagado', async () => {
    const { service, tx } = armarAnular({
      nc: { aplicado_cxp: 300 },
      aplicaciones: [{ cuenta_pagar_id: 'cp-nueva', monto: 300 }],
      cuotas: [
        // Más vieja, con pagos de una orden de pago: la FIFO de hoy le devolvería todo a esta.
        cuota('cp-vieja', PYG, 0, 500, '2026-01-01'),
        // La que descontó la NC; después se terminó de pagar con una OP.
        cuota('cp-nueva', PYG, 0, 1000, '2026-03-01'),
      ],
    });
    await service.anular('nc1', 'emp', 'error de carga', 'u9');
    expect(tx.nota_credito_compra_aplicaciones.findMany.mock.calls[0][0].where).toMatchObject({
      nota_credito_compra_id: 'nc1',
    });
    const tocadas = tx.cuentas_pagar.update.mock.calls.map((c: any) => [c[0].where.id, c[0].data]);
    expect(tocadas).toHaveLength(1);
    expect(tocadas[0][0]).toBe('cp-nueva');
    expect(tocadas[0][1]).toMatchObject({ saldo_pendiente: 300, monto_pagado: 700, estado: 'parcial' });
    // Graba quién la anuló, con la condición de que siga vigente.
    expect(tx.nota_credito_compra_cab.updateMany.mock.calls[0][0]).toMatchObject({
      where: { id: 'nc1', empresa_id: 'emp', anulado: false, estado: { not: 'anulada' } },
      data: { estado: 'anulada', anulado: true, motivo_anulacion: 'error de carga', anulado_por: 'u9' },
    });
  });

  it('anular sin aplicaciones usa la restauración FIFO de hoy', async () => {
    const { service, tx } = armarAnular({
      aplicaciones: [],
      cuotas: [cuota('cp-vieja', PYG, 0, 200, '2026-01-01'), cuota('cp-nueva', PYG, 0, 1000, '2026-03-01')],
    });
    await service.anular('nc1', 'emp', 'error de carga', 'u9');
    const tocadas = tx.cuentas_pagar.update.mock.calls.map((c: any) => [c[0].where.id, c[0].data.saldo_pendiente]);
    expect(tocadas).toEqual([
      ['cp-vieja', 200],
      ['cp-nueva', 100],
    ]);
  });

  it('anular ya anulada → 409 ESTADO_CAMBIADO', async () => {
    const { service, prisma } = armarAnular({ nc: { anulado: true, estado: 'anulada' } });
    let err: any;
    try {
      await service.anular('nc1', 'emp', 'otra vez', 'u9');
    } catch (e) {
      err = e;
    }
    expect(err?.getStatus?.()).toBe(409);
    expect(err.getResponse()).toMatchObject({ codigo: 'ESTADO_CAMBIADO' });
    expect(prisma.$transaction).not.toHaveBeenCalled();

    // Carrera: otra pestaña la anuló entre la lectura y la transacción.
    const carrera = armarAnular({ filasAnuladas: 0, cuotas: [cuota('cp1', PYG, 0, 500, '2026-01-01')] });
    let err2: any;
    try {
      await carrera.service.anular('nc1', 'emp', 'otra vez', 'u9');
    } catch (e) {
      err2 = e;
    }
    expect(err2?.getStatus?.()).toBe(409);
    expect(err2.getResponse()).toMatchObject({ codigo: 'ESTADO_CAMBIADO' });
    expect(carrera.tx.cuentas_pagar.update).not.toHaveBeenCalled();
  });
});

function armarListado() {
  const prisma: any = {
    nota_credito_compra_cab: {
      findMany: jest.fn().mockResolvedValue([]),
      count: jest.fn().mockImplementation(({ where }: any) => {
        const w = JSON.stringify(where);
        if (w.includes('"afecta_stock":true')) return Promise.resolve(2);
        if (w.includes('"anulado":true')) return Promise.resolve(1);
        if (w.includes('"anulado":false')) return Promise.resolve(5);
        return Promise.resolve(6);
      }),
      groupBy: jest.fn().mockResolvedValue([
        { moneda_id: USD, _sum: { total: 150.5 } },
        { moneda_id: PYG, _sum: { total: 1000 } },
      ]),
    },
    moneda: {
      findMany: jest.fn().mockResolvedValue([
        { id: USD, codigo: 'USD' },
        { id: PYG, codigo: 'PYG' },
      ]),
      findFirst: jest.fn().mockResolvedValue({ id: PYG, codigo: 'PYG', descripcion: 'Guaraní' }),
    },
    $transaction: jest.fn().mockImplementation((arg: any) => Promise.all(arg)),
  };
  const service = new NotaCreditoComprasService(prisma, {} as any, {} as any, {} as any, {} as any);
  return { service, prisma };
}

describe('NotaCreditoComprasService.findAll', () => {
  it('findAll resumen: montos por moneda sin anuladas', async () => {
    const { service, prisma } = armarListado();
    const r: any = await service.findAll('emp', 1, 20, { proveedorId: 'prov' });
    expect(r.resumen).toEqual({
      registradas: 5,
      anuladas: 1,
      con_stock: 2,
      montos_por_moneda: { USD: 150.5, PYG: 1000 },
    });
    // Los montos con los mismos filtros y sin anuladas.
    const where = JSON.stringify(prisma.nota_credito_compra_cab.groupBy.mock.calls[0][0].where);
    expect(where).toContain('"proveedor_id":"prov"');
    expect(where).toContain('"anulado":false');
    expect(where).toContain('"not":"anulada"');
  });

  it("search '001-001-45' filtra por los tres campos", async () => {
    const { service, prisma } = armarListado();
    await service.findAll('emp', 1, 20, { search: '001-001-45' });
    const where = prisma.nota_credito_compra_cab.findMany.mock.calls[0][0].where;
    expect(where).toMatchObject({ establecimiento: '001', punto_expedicion: '001', numero: '0000045' });
    expect(where.OR).toBeUndefined();
  });
});

// ─── Task 4, fix 1: aplicado_cxp en la cabecera y estado de las compras tocadas ───

describe('NotaCreditoComprasService: aplicado_cxp y compras tocadas', () => {
  it('create graba aplicado_cxp también cuando no descuenta nada', async () => {
    const { service, tx } = armar({ cuotas: [cuota('cp-pyg', PYG, 1000, 0, '2026-01-01')] });
    const r: any = await service.create(dtoBase({ moneda_id: USD, cotizacion: 7300 }), 'emp', 'u1');
    expect(tx.nota_credito_compra_cab.create.mock.calls[0][0].data.aplicado_cxp).toBe(0);
    expect(tx.nota_credito_compra_aplicaciones.createMany).not.toHaveBeenCalled();
    expect(r.sin_descontar).toBe(100);
  });

  it('anular NC nueva con aplicado 0 no toca ninguna cuota', async () => {
    const { service, tx, audit } = armarAnular({
      nc: { aplicado_cxp: 0 },
      aplicaciones: [],
      cuotas: [cuota('cp-pagada', PYG, 0, 1000, '2026-01-01'), cuota('cp-usd', USD, 0, 500, '2026-01-02')],
    });
    await service.anular('nc1', 'emp', 'error de carga', 'u9');
    expect(tx.cuentas_pagar.update).not.toHaveBeenCalled();
    expect(audit.log.mock.calls[0][0].new_value).toMatchObject({ cxp_restaurada: 0, cxp_no_restaurada: 0 });
  });

  it('anular NC vieja (aplicado_cxp null) usa FIFO', async () => {
    const { service, tx, audit } = armarAnular({
      nc: { aplicado_cxp: null, total: 300 },
      cuotas: [cuota('cp-vieja', PYG, 0, 200, '2026-01-01'), cuota('cp-nueva', PYG, 0, 50, '2026-03-01')],
    });
    await service.anular('nc1', 'emp', 'error de carga', 'u9');
    expect(tx.nota_credito_compra_aplicaciones.findMany).not.toHaveBeenCalled();
    const tocadas = tx.cuentas_pagar.update.mock.calls.map((c: any) => [c[0].where.id, c[0].data.saldo_pendiente]);
    expect(tocadas).toEqual([
      ['cp-vieja', 200],
      ['cp-nueva', 50],
    ]);
    // Había 250 pagado: quedan 50 sin restaurar.
    expect(audit.log.mock.calls[0][0].new_value).toMatchObject({ cxp_restaurada: 250, cxp_no_restaurada: 50 });
  });

  it('NC sin origen que baja cuotas de dos compras recalcula el estado de ambas (crear y anular)', async () => {
    const cuotas = [
      cuota('cp-a', PYG, 60, 0, '2026-01-01', { compra_id: 'compra-a' }),
      cuota('cp-b', PYG, 1000, 0, '2026-01-02', { compra_id: 'compra-b' }),
    ];
    const { service, tx } = armar({ cuotas });
    await service.create(dtoBase({ moneda_id: PYG }), 'emp', 'u1');
    const recalculadas = tx.compra_cab.update.mock.calls.map((c: any) => c[0].where.id).sort();
    expect(recalculadas).toEqual(['compra-a', 'compra-b']);

    const anul = armarAnular({
      nc: { aplicado_cxp: 100 },
      aplicaciones: [
        { cuenta_pagar_id: 'cp-a', monto: 60 },
        { cuenta_pagar_id: 'cp-b', monto: 40 },
      ],
      cuotas: [
        cuota('cp-a', PYG, 0, 60, '2026-01-01', { compra_id: 'compra-a' }),
        cuota('cp-b', PYG, 960, 40, '2026-01-02', { compra_id: 'compra-b' }),
      ],
    });
    await anul.service.anular('nc1', 'emp', 'error de carga', 'u9');
    const recalculadasAnular = anul.tx.compra_cab.update.mock.calls.map((c: any) => c[0].where.id).sort();
    expect(recalculadasAnular).toEqual(['compra-a', 'compra-b']);
  });

  it('findOne devuelve aplicado_cxp 0 para nueva sin descuento', async () => {
    const fila = (aplicado_cxp: unknown) => ({ id: 'nc1', usuario_id: 'u1', anulado_por: null, aplicado_cxp });
    const prisma: any = {
      nota_credito_compra_cab: { findFirst: jest.fn().mockResolvedValue(fila('0')) },
      usuario: {
        findMany: jest.fn().mockResolvedValue([{ id: 'u1', nombres: 'Ana', apellidos: 'Pérez', username: 'ana' }]),
      },
    };
    const service = new NotaCreditoComprasService(prisma, {} as any, {} as any, {} as any, {} as any);
    const r: any = await service.findOne('nc1', 'emp');
    expect(r).toMatchObject({ aplicado_cxp: 0, usuario_registro: { nombre: 'Ana Pérez' }, usuario_anulacion: null });

    prisma.nota_credito_compra_cab.findFirst.mockResolvedValue(fila(null));
    expect(((await service.findOne('nc1', 'emp')) as any).aplicado_cxp).toBeNull();
  });
});

describe('NotaCreditoComprasService.comprasOrigen: búsqueda', () => {
  const armarOrigen = () => {
    const { service, prisma } = armar();
    (prisma as any).compra_cab.findMany = jest.fn().mockResolvedValue([]);
    return { service, prisma: prisma as any };
  };
  const whereDe = (prisma: any) => JSON.stringify(prisma.compra_cab.findMany.mock.calls[0][0].where);

  it('busca también por la descripción de una línea de la compra', async () => {
    const { service, prisma } = armarOrigen();
    await service.comprasOrigen('emp', 'prov', 'jamonada');
    const w = whereDe(prisma);
    expect(w).toContain('"numero_factura":{"contains":"jamonada"');
    expect(w).toContain('"timbrado_proveedor"');
    expect(w).toContain('"compra_det":{"some":{"descripcion":{"contains":"jamonada","mode":"insensitive"}}}');
  });

  it('con prefijo conserva la búsqueda por número y suma la descripción', async () => {
    const { service, prisma } = armarOrigen();
    await service.comprasOrigen('emp', 'prov', '001-002-0000123');
    const w = whereDe(prisma);
    expect(w).toContain('"establecimiento":"001"');
    expect(w).toContain('"punto_expedicion":"002"');
    expect(w).toContain('"numero_factura":"0000123"');
    expect(w).toContain('"descripcion"');
  });
});

describe('NotaCreditoComprasService.compraOrigenDetalle: depósito de la compra', () => {
  const detalle = (compra: Record<string, unknown>) =>
    armar({ compra: { compra_det: [], timbrado_proveedor: null, establecimiento: null, punto_expedicion: null, numero_factura: '1', fecha_emision: null, moneda: { id: PYG, codigo: 'PYG' }, ...compra } })
      .service.compraOrigenDetalle('emp', 'c1', 'prov');

  it('dice si el depósito de la compra sigue activo (inactivo: la pantalla deja elegir otro)', async () => {
    expect(await detalle({ deposito_id: 'dep', deposito: { active: true } })).toMatchObject({ deposito_id: 'dep', deposito_activo: true });
    expect(await detalle({ deposito_id: 'dep', deposito: { active: false } })).toMatchObject({ deposito_id: 'dep', deposito_activo: false });
    expect(await detalle({ deposito_id: null, deposito: null })).toMatchObject({ deposito_id: null, deposito_activo: null });
  });
});
