import { ComprasService } from './compras.service';

// D12 (spec 2026-11-01 configuración de compras): la compra guarda al registrarse
// si su contado va a orden de pago (`compra_cab.contado_en_orden_pago`, con el valor
// de la config en ese momento, en contado y en crédito). La edición usa el valor de
// la compra, no la config vigente, y no lo cambia.

jest.mock('src/ordenes-compra/bloqueos-oc', () => ({
  bloquearOrdenCompra: jest.fn().mockResolvedValue(undefined),
  bloquearOrdenesCompra: jest.fn().mockResolvedValue(undefined),
  bloquearRequisiciones: jest.fn().mockResolvedValue(undefined),
}));
jest.mock('src/requisiciones/ejecucion-requisicion', () => ({
  aplicarEjecucionRequisicion: jest.fn().mockResolvedValue(undefined),
  revertirEjecucionRequisicion: jest.fn().mockResolvedValue(undefined),
  revaluarEjecucionRequisicion: jest.fn().mockResolvedValue(undefined),
  mismaEjecucion: jest.fn().mockReturnValue(true),
  monedaDelDocumento: jest.fn().mockResolvedValue({ monedaCodigo: 'PYG', cotizacion: 1 }),
}));

const CONTADO = 1;
const CREDITO = 2;
const TOTAL = 1000;

const dto = (pagos: any[] = []) =>
  ({
    cabecera: {
      proveedor_id: 'prov-1',
      deposito_id: 'dep-1',
      sucursal_id: 'suc-1',
      moneda_id: 'm-1',
      condicion_operacion_id: 'cond-1',
      establecimiento: '001',
      punto_expedicion: '001',
      numero_factura: '0000001',
      fecha_emision: '2026-11-01',
    },
    items: [],
    pagos,
  }) as any;
const PAGO = [{ medio_pago_id: 1, monto: TOTAL }];

/**
 * Servicio con los pasos ajenos a D12 aislados. Corren de verdad la regla de pagos
 * (`validateReglasPagoCompra`) y la decisión de la orden de pago automática.
 */
const montar = (opts: { config: boolean; condicion: number; guardada?: any }) => {
  const tx: any = {
    $executeRaw: jest.fn().mockResolvedValue(1),
    compra_cab: {
      create: jest.fn().mockResolvedValue({ id: 'c-1' }),
      update: jest.fn().mockResolvedValue({ id: 'c-1' }),
      findFirst: jest
        .fn()
        .mockResolvedValue({
          id: 'c-1',
          empresa_id: 'emp-1',
          activo: true,
          anulado: false,
          embarque_id: null,
          requisicion_id: null,
          orden_compra_id: null,
          deposito_id: 'dep-1',
          sucursal_id: 'suc-1',
          moneda_id: 'm-1',
          cotizacion: 1,
          usuario_id: 'u-1',
          es_preimpreso: true,
          fecha_emision: new Date('2026-10-01'),
          compra_det: [],
          ...opts.guardada,
        }),
    },
    compra_forma_pagos: { deleteMany: jest.fn().mockResolvedValue({ count: 0 }) },
    compra_subtotales: { deleteMany: jest.fn().mockResolvedValue({ count: 0 }) },
    compra_det: { deleteMany: jest.fn().mockResolvedValue({ count: 0 }) },
    cuentas_pagar: { deleteMany: jest.fn().mockResolvedValue({ count: 0 }), findMany: jest.fn().mockResolvedValue([{ id: 'cxp-1', moneda_id: 'm-1', saldo_pendiente: TOTAL }]) },
  };
  const prisma: any = { $transaction: jest.fn((fn: any) => fn(tx)) };
  const lotes: any = { isEnabledForEmpresa: jest.fn().mockResolvedValue(false), getEmpresaConfig: jest.fn().mockResolvedValue({ compras_credito_requiere_cuotas: false }) };
  const contabilidad: any = { integrarFacturaCompra: jest.fn().mockResolvedValue(undefined) };
  const pagosProveedor: any = { syncTesoreriaOrdenPago: jest.fn().mockResolvedValue(undefined) };
  const service = new ComprasService(prisma, lotes, contabilidad, pagosProveedor, {} as any, {} as any, { logEnTransaccion: jest.fn() } as any) as any;
  const stub = (nombre: string, valor?: unknown) => (service[nombre] = jest.fn().mockResolvedValue(valor));
  const stubSync = (nombre: string, valor?: unknown) => (service[nombre] = jest.fn().mockReturnValue(valor));
  [
    'validateCreateOrUpdatePayload',
    'assertComprobanteNoDuplicado',
    'validateItems',
    'bloquearOrdenCompra',
    'bloquearOrdenesCompra',
    'assertRequisicionCompraEjecutable',
    'validateMatchingOrdenCompra',
    'ensureLotesForItems',
    'persistSubtotales',
    'persistPagos',
    'persistCuentasPagar',
    'applyInventarioYCostos',
    'aplicarCostoFacturaARecepciones',
    'recalculateOrdenCompraEstado',
    'autoCancelBorradorOrdenesForCompra',
    'assertNoActiveOrdenesForCompra',
    'assertNoCxpPagadaForCompra',
    'cleanupInactiveOrdenesForCompra',
    'restaurarCostoLotesDeFactura',
    'recalculateProductCosts',
    'revertInventario',
  ].forEach((n) => stub(n));
  stub('validateCabeceraRefs', { depositoSucursalId: 'suc-1' });
  stub('getOrCreateConfigCompras', { generar_cxp_automatico: true, incluir_contado_en_orden_pago: opts.config });
  stub('resolveCondicionOperacion', { codigo: opts.condicion });
  stub('resolveRedondeoConfig', undefined);
  stub('resolveFlujoCompra', { afectarStockEnCompra: false });
  stub('persistDetalles', []);
  stub('resolveTipoMovimientoEntradaId', 'tm-1');
  stub('hasInventarioAplicadoEnCompra', false);
  stub('createOrdenPagoAutomatica', { id: 'op-auto' });
  stub('findOne', { id: 'c-1' });
  stubSync('normalizeItems', []);
  stubSync('resolveDescuentoGlobal', { tipo: 'por_item', global_pct: 0, global_monto: 0 });
  stubSync('aplicarDescuentoGlobalEnItems');
  stubSync('buildCuotasPersist', []);
  stubSync('calculateTotals', {
    total_exento: 0,
    total_gravado_5: 0,
    total_gravado_10: TOTAL,
    total_iva_5: 0,
    total_iva_10: 91,
    total_iva: 91,
    subtotal: TOTAL,
    total: TOTAL,
    total_descuento: 0,
    subtotalesPorIva: [],
  });
  return { service, tx };
};

describe('alta: la compra graba contado_en_orden_pago con el valor de la config', () => {
  it.each([
    ['contado', true, CONTADO, []],
    ['contado', false, CONTADO, PAGO],
    ['crédito', true, CREDITO, []],
    ['crédito', false, CREDITO, []],
  ])('%s con la config en %s', async (_n, config, condicion, pagos) => {
    const { service, tx } = montar({ config, condicion });
    await service.create(dto(pagos), 'emp-1', 'u-1');
    expect(tx.compra_cab.create.mock.calls[0][0].data.contado_en_orden_pago).toBe(config);
  });
});

describe('edición: usa el contado_en_orden_pago de la compra, no la config', () => {
  it('compra true con la config ya en false → el contado no se autopaga (queda la CxP)', async () => {
    const { service } = montar({ config: false, condicion: CONTADO, guardada: { contado_en_orden_pago: true } });
    await service.update('c-1', dto([]), 'emp-1', 'u-1');
    expect(service.persistCuentasPagar).toHaveBeenCalled();
    expect(service.createOrdenPagoAutomatica).not.toHaveBeenCalled();
  });

  it('compra false con la config ya en true → el contado se autopaga como al registrarla', async () => {
    const { service } = montar({ config: true, condicion: CONTADO, guardada: { contado_en_orden_pago: false } });
    await service.update('c-1', dto(PAGO), 'emp-1', 'u-1');
    expect(service.createOrdenPagoAutomatica).toHaveBeenCalledTimes(1);
  });

  it('la edición no cambia contado_en_orden_pago (compra_cab.update no lo lleva en data)', async () => {
    const { service, tx } = montar({ config: false, condicion: CONTADO, guardada: { contado_en_orden_pago: true } });
    await service.update('c-1', dto([]), 'emp-1', 'u-1');
    expect(tx.compra_cab.update).toHaveBeenCalledTimes(1);
    expect(tx.compra_cab.update.mock.calls[0][0].data).not.toHaveProperty('contado_en_orden_pago');
  });

  it('una edición que pasa de crédito a contado usa el valor de la compra', async () => {
    // Registrada a crédito con la opción encendida; hoy la opción está apagada.
    const { service } = montar({ config: false, condicion: CONTADO, guardada: { contado_en_orden_pago: true, plazo_credito: 30 } });
    await service.update('c-1', dto([]), 'emp-1', 'u-1');
    expect(service.createOrdenPagoAutomatica).not.toHaveBeenCalled();
    expect(service.persistCuentasPagar).toHaveBeenCalled();
  });
});

describe('detalle de la compra (GET /compras/:id): devuelve contado_en_orden_pago para el formulario en edición', () => {
  it.each([true, false])('con %s, findOne lee la compra con include (sin select) y devuelve el valor guardado', async (valor) => {
    const prisma: any = {
      compra_cab: { findFirst: jest.fn().mockResolvedValue({ id: 'c-1', activo: true, anulado: false, contado_en_orden_pago: valor }) },
      orden_pago_proveedor_cab: { findMany: jest.fn().mockResolvedValue([]) },
      imp_componentes_costo: { findFirst: jest.fn().mockResolvedValue(null) },
    };
    const service = new ComprasService(prisma, {} as any, {} as any, {} as any, {} as any, {} as any, { logEnTransaccion: jest.fn() } as any);
    const compra = await service.findOne('c-1', 'emp-1');
    const arg = prisma.compra_cab.findFirst.mock.calls[0][0];
    // Con `include` Prisma trae todos los escalares de compra_cab, entre ellos la columna nueva.
    expect(arg.include).toBeDefined();
    expect(arg.select).toBeUndefined();
    expect(compra.contado_en_orden_pago).toBe(valor);
  });
});
