import { BadRequestException } from '@nestjs/common';
import { ComprasService } from './compras.service';
import { armar } from 'src/requisiciones/ejecucion-requisicion.fixture';

/**
 * Editar una factura de una requisición (revisión final, I1): como en Gastos, la ejecución se reemplaza solo si
 * cambia la requisición o lo que la factura ejecuta por línea; si cambia solo la moneda o la cotización se revalúa;
 * si no, no se toca. La requisición y sus líneas son las del Prisma en memoria de `ejecucion-requisicion.fixture`,
 * con la ejecución real (revertir, validar, aplicar, revaluar).
 */
describe('Editar la factura de una requisición ejecutada total o cancelada', () => {
  const existente = (extra: Record<string, unknown> = {}) => ({
    id: 'c-1',
    empresa_id: 'emp',
    activo: true,
    anulado: false,
    es_preimpreso: false,
    embarque_id: null,
    deposito_id: 'dep-1',
    requisicion_id: 'req-1',
    orden_compra_id: null,
    usuario_id: 'u-1',
    moneda_id: null,
    cotizacion: '1.000000',
    fecha_emision: new Date('2026-10-05T00:00:00.000Z'),
    establecimiento: '001',
    punto_expedicion: '001',
    numero_factura: '0000001',
    compra_det: [
      {
        id: 'cd-1',
        producto_id: null,
        orden_compra_det_id: null,
        requisicion_det_id: 'rd-1',
        cantidad: '10.0000',
        subtotal: '1000000.00',
        afecta_stock: false,
        costo_anterior: null,
      },
    ],
    ...extra,
  });

  const dto = (opts: { cantidad?: number; precio?: number; cabecera?: Record<string, unknown> } = {}) =>
    ({
      cabecera: {
        proveedor_id: 'p-1',
        deposito_id: 'dep-1',
        sucursal_id: 'suc-1',
        moneda_id: null,
        cotizacion: 1,
        condicion_operacion_id: 'cond-1',
        establecimiento: '001',
        punto_expedicion: '001',
        numero_factura: '0000001',
        fecha_emision: '2026-10-05',
        requisicion_id: 'req-1',
        ...opts.cabecera,
      },
      items: [
        {
          requisicion_det_id: 'rd-1',
          descripcion: 'Resma A4',
          cantidad: opts.cantidad ?? 10,
          precio_unitario: opts.precio ?? 100000,
          porcentaje_iva: 10,
          afecta_stock: false,
        },
      ],
      pagos: [],
    }) as any;

  const montar = (req: Parameters<typeof armar>[0], compraGuardada: any) => {
    const r = armar(req);
    r.cab.origen_tipo = 'compra';
    const tx: any = {
      ...r.tx,
      compra_cab: {
        findFirst: jest.fn().mockResolvedValue(compraGuardada),
        update: jest.fn().mockResolvedValue({}),
      },
      moneda: { findUnique: jest.fn().mockResolvedValue({ codigo: 'USD' }) },
      compra_forma_pagos: { deleteMany: jest.fn() },
      compra_subtotales: { deleteMany: jest.fn() },
      cuentas_pagar: { deleteMany: jest.fn(), findMany: jest.fn().mockResolvedValue([]) },
      compra_det: { deleteMany: jest.fn() },
      compra_costo_lote: { findMany: jest.fn().mockResolvedValue([]), deleteMany: jest.fn().mockResolvedValue({ count: 0 }) },
    };
    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 service = new ComprasService(prisma, lotes, {} as any, {} as any, {} as any, {} as any, { logEnTransaccion: jest.fn() } as any) as any;
    const stub = (nombre: string, valor?: unknown) => {
      service[nombre] = jest.fn().mockResolvedValue(valor);
    };
    [
      'validateCreateOrUpdatePayload',
      'assertComprobanteNoDuplicado',
      'autoCancelBorradorOrdenesForCompra',
      'assertNoActiveOrdenesForCompra',
      'assertNoCxpPagadaForCompra',
      'cleanupInactiveOrdenesForCompra',
      'validateItems',
      'validateMatchingOrdenCompra',
      'ensureLotesForItems',
      'persistSubtotales',
      'persistPagos',
      'persistCuentasPagar',
      'recalculateOrdenCompraEstado',
      'recalculateProductCosts',
      'aplicarCostoFacturaARecepciones',
    ].forEach((n) => stub(n));
    stub('validateCabeceraRefs', { depositoSucursalId: 'suc-1' });
    stub('getOrCreateConfigCompras', { generar_cxp_automatico: false, modo_flujo_compra: 'requisicion_opcional' });
    stub('resolveCondicionOperacion', { codigo: 1 });
    stub('resolveRedondeoConfig', { decimalesMonto: 2, decimalesPorcentaje: 2 });
    stub('hasInventarioAplicadoEnCompra', false);
    stub('resolveTipoMovimientoEntradaId', 'tm-entrada');
    stub('applyInventarioYCostos', []);
    stub('persistDetalles', []);
    stub('findOne', { id: 'c-1' });
    service.validateReglasPagoCompra = jest.fn();
    return { service, tx, cab: r.cab, det: r.det };
  };

  const totalLinea = (cantidad: string, monto: string) => [
    { id: 'rd-1', cantidad_solicitada: '10.0000', cantidad_ejecutada: cantidad, monto_ejecutado: monto, centro_costo_id: null },
  ];

  it('ejecutada total: corregir el vencimiento del timbrado (mismos ítems) se guarda y no toca la requisición', async () => {
    const { service, tx, cab, det } = montar(
      { estado: 'ejecutada_total', lineas: totalLinea('10.0000', '1000000.00') },
      existente(),
    );

    await service.update('c-1', dto({ cabecera: { fecha_vencimiento_timbrado: '2027-12-31' } }), 'emp', 'u-1');

    expect(tx.compra_cab.update).toHaveBeenCalledTimes(1);
    expect(tx.compra_cab.update.mock.calls[0][0].data.fecha_vencimiento_timbrado).toEqual(new Date('2027-12-31'));
    expect(tx.requisicion_det.update).not.toHaveBeenCalled();
    expect(tx.requisicion_cab.update).not.toHaveBeenCalled();
    expect(cab.estado).toBe('ejecutada_total');
    expect(det[0]).toMatchObject({ cantidad_ejecutada: '10.0000', monto_ejecutado: '1000000.00' });
  });

  it('ejecutada total: bajar la cantidad revierte, valida sobre la requisición ya revertida y vuelve a aplicar', async () => {
    const { service, cab, det } = montar({ estado: 'ejecutada_total', lineas: totalLinea('10.0000', '1000000.00') }, existente());

    await service.update('c-1', dto({ cantidad: 8 }), 'emp', 'u-1');

    expect(det[0]).toMatchObject({ cantidad_ejecutada: 8, monto_ejecutado: 800000, estado: 'ejecutada_parcial' });
    expect(cab).toMatchObject({ estado: 'ejecutada_parcial', total_ejecutado: 800000 });
  });

  it('cancelada: editar sin tocar los ítems se guarda y lo ejecutado queda como está', async () => {
    const { service, tx, cab, det } = montar(
      { estado: 'cancelada', lineas: totalLinea('10.0000', '1000000.00') },
      existente(),
    );

    await service.update('c-1', dto({ cabecera: { observaciones: 'Corrijo la observación' } }), 'emp', 'u-1');

    expect(tx.compra_cab.update).toHaveBeenCalledTimes(1);
    expect(tx.requisicion_det.update).not.toHaveBeenCalled();
    expect(cab.estado).toBe('cancelada');
    expect(det[0]).toMatchObject({ cantidad_ejecutada: '10.0000' });
  });

  it('cancelada: cambiar solo la cotización revalúa el monto de la línea sin chequear el estado', async () => {
    const guardada = existente({
      moneda_id: 'm-usd',
      cotizacion: '7000.000000',
      compra_det: [{ ...existente().compra_det[0], cantidad: '4.0000', subtotal: '100.00' }],
    });
    const { service, cab, det } = montar({ estado: 'cancelada', lineas: totalLinea('4.0000', '700000.00') }, guardada);

    await service.update('c-1', dto({ cantidad: 4, precio: 25, cabecera: { moneda_id: 'm-usd', cotizacion: 7300 } }), 'emp', 'u-1');

    expect(det[0]).toMatchObject({ cantidad_ejecutada: '4.0000', monto_ejecutado: 730000 });
    expect(cab).toMatchObject({ estado: 'cancelada', total_ejecutado: 730000 });
  });

  it('cancelada: cambiar la cantidad (ejecución nueva) → 400 REQUISICION_NO_DISPONIBLE', async () => {
    const { service } = montar({ estado: 'cancelada', lineas: totalLinea('10.0000', '1000000.00') }, existente());

    const error = await service.update('c-1', dto({ cantidad: 9 }), 'emp', 'u-1').catch((e: unknown) => e);

    expect(error).toBeInstanceOf(BadRequestException);
    expect((error as BadRequestException).getResponse()).toMatchObject({
      codigo: 'REQUISICION_NO_DISPONIBLE',
      estado_actual: 'cancelada',
    });
  });
});
