import { BadRequestException } from '@nestjs/common';
import { ComprasService } from './compras.service';

// El alcance por sucursal se prueba aparte; acá se deja sin recorte.
jest.mock('src/utils/alcance-sucursal', () => ({
  ...jest.requireActual('src/utils/alcance-sucursal'),
  alcanceSucursalUsuario: jest.fn().mockResolvedValue({}),
  filtroSucursalOperativo: jest.fn().mockReturnValue(undefined),
}));

const VISIBLES_CON_ANULADAS = { OR: [{ activo: true }, { anulado: true }] };

/** Prisma falso para `findAll`: guarda los `where` que recibe cada consulta. */
const prismaListado = () => {
  const prisma: any = {
    compra_cab: {
      findMany: jest.fn().mockResolvedValue([]),
      count: jest.fn().mockResolvedValue(0),
      groupBy: jest.fn().mockResolvedValue([]),
    },
    moneda: { findMany: jest.fn().mockResolvedValue([]) },
    $transaction: jest.fn((ops: any) => (Array.isArray(ops) ? Promise.all(ops) : ops(prisma))),
  };
  return prisma;
};

const crearServicio = (prisma: any) =>
  new ComprasService(prisma, {} as any, {} as any, {} as any, {} as any, {} as any, { logEnTransaccion: jest.fn() } as any);

describe('Facturas de compra: anuladas visibles, KPI y búsqueda (bugs 1, 7 y 10)', () => {
  it('findAll sin filtro sigue filtrando activo: true', async () => {
    const prisma = prismaListado();
    await crearServicio(prisma).findAll('emp-1', {});

    const where = prisma.compra_cab.findMany.mock.calls[0][0].where;
    expect(where.activo).toBe(true);
    expect(JSON.stringify(where)).not.toContain('"anulado":true');
  });

  it.each([
    ['incluir_anuladas=true', { incluir_anuladas: 'true' }],
    ['estado=anulada', { estado: 'anulada' }],
  ])('con %s incluye anulado: true', async (_nombre, query) => {
    const prisma = prismaListado();
    await crearServicio(prisma).findAll('emp-1', query);

    const where = prisma.compra_cab.findMany.mock.calls[0][0].where;
    expect(where.activo).toBeUndefined();
    expect(where.AND).toContainEqual(VISIBLES_CON_ANULADAS);
    expect(prisma.compra_cab.count.mock.calls[0][0].where).toBe(where);
  });

  it("incluir_anuladas con otro valor que 'true' no cuenta", async () => {
    const prisma = prismaListado();
    await crearServicio(prisma).findAll('emp-1', { incluir_anuladas: '1' });

    expect(prisma.compra_cab.findMany.mock.calls[0][0].where.activo).toBe(true);
  });

  it('la búsqueda convive con las anuladas sin pisar el OR de visibilidad', async () => {
    const prisma = prismaListado();
    await crearServicio(prisma).findAll('emp-1', { incluir_anuladas: 'true', search: 'acme' });

    const where = prisma.compra_cab.findMany.mock.calls[0][0].where;
    expect(where.AND).toContainEqual(VISIBLES_CON_ANULADAS);
    expect(where.OR).toContainEqual({ numero_factura: { contains: 'acme', mode: 'insensitive' } });
  });

  it('el groupBy de monto excluye anuladas', async () => {
    const prisma = prismaListado();
    await crearServicio(prisma).findAll('emp-1', { incluir_anuladas: 'true' });

    const llamadas = prisma.compra_cab.groupBy.mock.calls.map((c: any[]) => c[0]);
    const porMoneda = llamadas.find((a: any) => a.by.includes('moneda_id'));
    const porEstado = llamadas.find((a: any) => a.by.includes('estado'));
    expect(porMoneda.where.anulado).toEqual({ not: true });
    expect(porMoneda.where.AND).toContainEqual(VISIBLES_CON_ANULADAS);
    // El conteo por estado sí las cuenta: el KPI "Anuladas" sale de ahí.
    expect(porEstado.where.anulado).toBeUndefined();
  });

  it('la búsqueda con prefijo suma la condición por establecimiento, punto y número', async () => {
    const prisma = prismaListado();
    await crearServicio(prisma).findAll('emp-1', { search: '1-2-123' });

    const where = prisma.compra_cab.findMany.mock.calls[0][0].where;
    expect(where.OR).toContainEqual({ establecimiento: '001', punto_expedicion: '002', numero_factura: '0000123' });
  });

  it('una búsqueda sin forma de comprobante no suma condición de prefijo', async () => {
    const prisma = prismaListado();
    await crearServicio(prisma).findAll('emp-1', { search: 'acme' });

    const where = prisma.compra_cab.findMany.mock.calls[0][0].where;
    expect(where.OR).toHaveLength(5);
  });

  it('findOne devuelve una anulada y su componente_importacion', async () => {
    const anulada = { id: 'c-1', activo: false, anulado: true, estado: 'anulada', embarque_id: 'e1' };
    const prisma: any = {
      compra_cab: { findFirst: jest.fn().mockResolvedValue(anulada) },
      orden_pago_proveedor_cab: { findMany: jest.fn().mockResolvedValue([]) },
      imp_componentes_costo: { findFirst: jest.fn().mockResolvedValue({ id: 'k-comp', concepto_id: 'k1' }) },
    };

    const compra = await crearServicio(prisma).findOne('c-1', 'emp-1');

    const where = prisma.compra_cab.findFirst.mock.calls[0][0].where;
    expect(where).toMatchObject({ id: 'c-1', empresa_id: 'emp-1', ...VISIBLES_CON_ANULADAS });
    expect(where.activo).toBeUndefined();
    expect(compra.anulado).toBe(true);
    expect(compra.componente_importacion).toEqual({ id: 'k-comp', concepto_id: 'k1' });
    expect(prisma.imp_componentes_costo.findFirst).toHaveBeenCalledWith({
      where: { compra_id: 'c-1', empresa_id: 'emp-1', activo: true },
      select: { id: true, concepto_id: true },
    });
  });

  it('findOne pide el _count de líneas de cada OP vinculada (las manuales también)', async () => {
    const prisma: any = {
      compra_cab: { findFirst: jest.fn().mockResolvedValue({ id: 'c-3', activo: true, anulado: false }) },
      orden_pago_proveedor_cab: {
        findMany: jest.fn().mockResolvedValue([{ id: 'op-1', _count: { orden_pago_proveedor_det: 2 } }]),
      },
      imp_componentes_costo: { findFirst: jest.fn().mockResolvedValue(null) },
    };

    const compra = await crearServicio(prisma).findOne('c-3', 'emp-1');

    const arg = prisma.orden_pago_proveedor_cab.findMany.mock.calls[0][0];
    expect(arg.where.OR).toHaveLength(2);
    expect(arg.select._count).toEqual({ select: { orden_pago_proveedor_det: true } });
    expect(compra.orden_pago_proveedor_cab[0]._count.orden_pago_proveedor_det).toBe(2);
  });

  it('findOne trae requisicion_compra_cab con el número', async () => {
    const prisma: any = {
      compra_cab: { findFirst: jest.fn().mockResolvedValue({ id: 'c-4', activo: true, anulado: false }) },
      orden_pago_proveedor_cab: { findMany: jest.fn().mockResolvedValue([]) },
      imp_componentes_costo: { findFirst: jest.fn().mockResolvedValue(null) },
    };

    await crearServicio(prisma).findOne('c-4', 'emp-1');

    const include = prisma.compra_cab.findFirst.mock.calls[0][0].include;
    expect(include.requisicion_compra_cab).toEqual({ select: { id: true, numero_requisicion: true } });
  });

  it('findOne sin componente devuelve componente_importacion null', async () => {
    const prisma: any = {
      compra_cab: { findFirst: jest.fn().mockResolvedValue({ id: 'c-2', activo: true, anulado: false }) },
      orden_pago_proveedor_cab: { findMany: jest.fn().mockResolvedValue([]) },
      imp_componentes_costo: { findFirst: jest.fn().mockResolvedValue(null) },
    };

    const compra = await crearServicio(prisma).findOne('c-2', 'emp-1');
    expect(compra.componente_importacion).toBeNull();
  });
});

describe('Facturas de compra: edición sin pérdidas (bug 3)', () => {
  const existente = (extra: Record<string, unknown> = {}) => ({
    id: 'c-1',
    empresa_id: 'emp-1',
    activo: true,
    anulado: false,
    es_preimpreso: true,
    embarque_id: null as string | null,
    deposito_id: 'dep-1',
    requisicion_id: null,
    orden_compra_id: null,
    usuario_id: 'u-1',
    fecha_emision: new Date('2026-10-05T00:00:00.000Z'),
    establecimiento: '001',
    punto_expedicion: '001',
    numero_factura: '0000001',
    compra_det: [],
    ...extra,
  });

  const dto = (cabecera: Record<string, unknown> = {}) =>
    ({
      cabecera: {
        proveedor_id: 'p-1',
        deposito_id: 'dep-1',
        sucursal_id: 'suc-1',
        moneda_id: 'm-usd',
        cotizacion: 7300,
        condicion_operacion_id: 'cond-1',
        establecimiento: '001',
        punto_expedicion: '001',
        numero_factura: '0000001',
        fecha_emision: '2026-10-05',
        ...cabecera,
      },
      items: [],
      pagos: [],
    }) as any;

  /** Servicio con la transacción falsa y los pasos internos aislados. */
  const montar = (compraGuardada: any) => {
    const tx: any = {
      $executeRaw: jest.fn().mockResolvedValue(1), // lock compra:<id>
      compra_cab: {
        findFirst: jest.fn().mockResolvedValue(compraGuardada),
        update: jest.fn().mockResolvedValue({}),
      },
      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() },
      // Lotes cuyo costo corrigió esta factura (restaurarCostoLotesDeFactura): ninguno.
      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);
      return service[nombre];
    };
    [
      'validateCreateOrUpdatePayload',
      'assertComprobanteNoDuplicado',
      'autoCancelBorradorOrdenesForCompra',
      'assertNoActiveOrdenesForCompra',
      'assertNoCxpPagadaForCompra',
      'cleanupInactiveOrdenesForCompra',
      'validateItems',
      'validateMatchingOrdenCompra',
      'ensureLotesForItems',
      'persistSubtotales',
      'persistPagos',
      'persistCuentasPagar',
      'createOrdenPagoAutomatica',
      'recalculateOrdenCompraEstado',
      'recalculateProductCosts',
    ].forEach((n) => stub(n));
    stub('validateCabeceraRefs', { depositoSucursalId: 'suc-1' });
    stub('getOrCreateConfigCompras', { generar_cxp_automatico: false });
    stub('resolveCondicionOperacion', { codigo: 1 });
    stub('resolveRedondeoConfig', { decimalesMonto: 2, decimalesPorcentaje: 2 });
    stub('resolveFlujoCompra', { afectarStockEnCompra: true });
    stub('hasInventarioAplicadoEnCompra', false);
    stub('resolveTipoMovimientoEntradaId', 'tm-entrada');
    stub('persistDetalles', []);
    stub('findOne', { id: 'c-1' });
    // Las reglas de pago de contado se prueban en compras.service.spec.ts.
    service.validateReglasPagoCompra = jest.fn();
    const applyInventario = stub('applyInventarioYCostos', []);

    return { service, tx, applyInventario };
  };

  it('update graba es_preimpreso false', async () => {
    const { service, tx } = montar(existente());

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

    expect(tx.compra_cab.update.mock.calls[0][0].data.es_preimpreso).toBe(false);
  });

  it('update sin es_preimpreso en el DTO conserva el guardado', async () => {
    const { service, tx } = montar(existente({ es_preimpreso: false }));

    await service.update('c-1', dto(), 'emp-1', 'u-1');

    expect(tx.compra_cab.update.mock.calls[0][0].data.es_preimpreso).toBe(false);
  });

  it('update de una compra con embarque sin embarque_id en el DTO lo conserva y no llama applyInventarioYCostos', async () => {
    const { service, tx, applyInventario } = montar(existente({ embarque_id: 'e1' }));

    await service.update('c-1', dto(), 'emp-1', 'u-1');

    const data = tx.compra_cab.update.mock.calls[0][0].data;
    expect(data.embarque_id === undefined || data.embarque_id === 'e1').toBe(true);
    expect(applyInventario).not.toHaveBeenCalled();
  });

  it('update de una compra sin embarque sí mueve stock', async () => {
    const { service, applyInventario } = montar(existente());

    await service.update('c-1', dto(), 'emp-1', 'u-1');

    expect(applyInventario).toHaveBeenCalled();
  });

  it('update con otro embarque → 400 EMBARQUE_NO_EDITABLE', async () => {
    const { service, tx } = montar(existente({ embarque_id: 'e1' }));

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

    expect(error).toBeInstanceOf(BadRequestException);
    expect((error as BadRequestException).getResponse()).toMatchObject({
      codigo: 'EMBARQUE_NO_EDITABLE',
      campo: 'embarque_id',
      message: expect.any(String),
    });
    expect(tx.compra_cab.update).not.toHaveBeenCalled();
  });

  it('update que intenta vincular un embarque a una compra que no lo tenía → 400 EMBARQUE_NO_EDITABLE', async () => {
    const { service } = montar(existente());

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

    expect((error as BadRequestException).getResponse()).toMatchObject({ codigo: 'EMBARQUE_NO_EDITABLE' });
  });

  it('update con el mismo embarque que el guardado sigue', async () => {
    const { service, applyInventario } = montar(existente({ embarque_id: 'e1' }));

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

    expect(applyInventario).not.toHaveBeenCalled();
  });
});

describe('Último costo del proveedor: con la moneda de la compra anterior', () => {
  it('devuelve moneda { id, codigo } de esa compra y pide solo esos campos', async () => {
    const findFirst = jest.fn().mockResolvedValue({
      precio_unitario: '4.2',
      descuento_pct: '0',
      cantidad: '10',
      compra_cab: {
        fecha_emision: new Date('2026-09-20T00:00:00.000Z'),
        establecimiento: null,
        punto_expedicion: null,
        numero_factura: 'INV-7',
        moneda: { id: 'mon-usd', codigo: 'USD' },
      },
    });
    const r = await crearServicio({ compra_det: { findFirst } }).getUltimoCostoProveedor('emp-1', 'prov-1', 'prod-1');

    expect(r).toMatchObject({ costo_unitario: 4.2, moneda: { id: 'mon-usd', codigo: 'USD' } });
    expect(findFirst.mock.calls[0][0].select.compra_cab.select.moneda).toEqual({ select: { id: true, codigo: true } });
  });

  it('sin compras anteriores sigue devolviendo null', async () => {
    const findFirst = jest.fn().mockResolvedValue(null);
    expect(
      await crearServicio({ compra_det: { findFirst } }).getUltimoCostoProveedor('emp-1', 'prov-1', 'prod-1'),
    ).toBeNull();
  });
});
