import { ACCION_REVERSION, revertirPedidoPorAnulacionFactura } from './reversion-anulacion-factura';

const EMPRESA = 'emp-1';
const FACTURA = 'fac-1';

/**
 * Base en memoria: pedidos, renglones, historial, stock y la factura. Alcanza
 * para la reversión, que solo lee y escribe esas tablas dentro de una transacción.
 */
function crearDb(opts: {
  pedido: Record<string, any>;
  renglones: Array<Record<string, any>>;
  historial?: Array<Record<string, any>>;
  stock?: Record<string, { cantidad_disponible: number; cantidad_reservada: number }>;
  factura?: Record<string, any> | null;
  facturaDets?: Array<Record<string, any>>;
  configSucursal?: Record<string, unknown> | null;
}) {
  const stock = opts.stock ?? {};
  const historial = opts.historial ?? [];
  const pedidos = [opts.pedido];
  const factura =
    opts.factura === undefined ? { pedido_id: opts.pedido.id, dest: '001', dpunexp: '001', dnumdoc: '0000123' } : opts.factura;
  const key = (w: any) => `${w.deposito_id_producto_id.deposito_id}|${w.deposito_id_producto_id.producto_id}`;
  const conProducto = (r: any) => ({ ...r, producto: { maneja_inventario: r.maneja_inventario !== false } });

  const tx: any = {
    $queryRaw: jest.fn(async () => []),
    factura_cab: { findFirst: jest.fn(async () => factura) },
    factura_det: { findMany: jest.fn(async () => opts.facturaDets ?? []) },
    pedidos: {
      findFirst: jest.fn(async ({ where }: any) =>
        pedidos.find((p) => where.OR.some((c: any) => (c.id ? p.id === c.id : p.factura_id === c.factura_id))) ?? null,
      ),
      findUnique: jest.fn(async ({ where }: any) => pedidos.find((p) => p.id === where.id) ?? null),
      update: jest.fn(async ({ where, data }: any) => Object.assign(pedidos.find((p) => p.id === where.id)!, data)),
    },
    pedido_detalle: {
      findMany: jest.fn(async ({ where }: any) =>
        opts.renglones
          .filter((r) => r.pedido_id === where.pedido_id)
          .filter((r) => !where.deposito_id || r.deposito_id != null)
          .filter((r) => !where.producto || r.maneja_inventario !== false)
          .map(conProducto),
      ),
      update: jest.fn(async ({ where, data }: any) => Object.assign(opts.renglones.find((r) => r.id === where.id)!, data)),
    },
    pedido_historial: {
      findMany: jest.fn(async ({ where }: any) =>
        historial.filter((h) => h.pedido_id === where.pedido_id && h.datos?.factura_id === where.datos.equals),
      ),
      count: jest.fn(
        async ({ where }: any) =>
          historial.filter((h) => h.pedido_id === where.pedido_id && where.accion.in.includes(h.accion)).length,
      ),
      create: jest.fn(async ({ data }: any) => historial.push(data)),
    },
    stock_deposito: {
      upsert: jest.fn(async ({ where, create, update }: any) => {
        const s = stock[key(where)];
        if (!s) stock[key(where)] = { cantidad_disponible: 0, cantidad_reservada: create.cantidad_reservada };
        else s.cantidad_reservada += update.cantidad_reservada.increment;
      }),
    },
    empresas_sucursales: { findUnique: jest.fn(async () => ({ config: opts.configSucursal ?? {} })) },
  };
  const db: any = { $transaction: jest.fn(async (fn: any) => fn(tx)) };
  return { db, tx, stock, historial, pedido: pedidos[0], renglones: opts.renglones };
}

describe('revertirPedidoPorAnulacionFactura', () => {
  it('pedido facturado: vuelve a «confirmado» y vuelve a reservar en el depósito de cada renglón', async () => {
    const { db, stock, historial, pedido } = crearDb({
      pedido: { id: 'ped-1', tipo_pedido: 'venta_mayorista', estado: 'facturado', factura_id: FACTURA, numero_pedido: 'P-1' },
      renglones: [
        { id: 'r1', pedido_id: 'ped-1', producto_id: 'prod-a', deposito_id: 'dep-1', cantidad: 2, cantidad_base: 24, cant_pendiente: null },
        { id: 'r2', pedido_id: 'ped-1', producto_id: 'prod-b', deposito_id: 'dep-2', cantidad: 3, cantidad_base: 3, cant_pendiente: null },
        { id: 'r3', pedido_id: 'ped-1', producto_id: 'serv', deposito_id: null, cantidad: 1, cantidad_base: 1, cant_pendiente: null },
      ],
      stock: { 'dep-1|prod-a': { cantidad_disponible: 50, cantidad_reservada: 5 } },
    });

    const r = await revertirPedidoPorAnulacionFactura(db, FACTURA, EMPRESA);

    expect(r).toMatchObject({ revertido: true, tipo: 'pedido', estadoAnterior: 'facturado', estadoNuevo: 'confirmado', reservado: 27 });
    expect(pedido).toMatchObject({ estado: 'confirmado', factura_id: null });
    expect(stock['dep-1|prod-a'].cantidad_reservada).toBe(29); // 5 de otros + 24 de este pedido
    expect(stock['dep-2|prod-b'].cantidad_reservada).toBe(3);
    expect(historial.at(-1)).toMatchObject({ accion: ACCION_REVERSION, datos: { factura_id: FACTURA } });
  });

  it('pedido: anular dos veces (local + ECAN) revierte una sola vez', async () => {
    const { db, stock } = crearDb({
      pedido: { id: 'ped-1', tipo_pedido: 'venta_mayorista', estado: 'facturado', factura_id: FACTURA },
      renglones: [{ id: 'r1', pedido_id: 'ped-1', producto_id: 'prod-a', deposito_id: 'dep-1', cantidad: 4, cantidad_base: 4, cant_pendiente: null }],
    });
    await revertirPedidoPorAnulacionFactura(db, FACTURA, EMPRESA);
    const segunda = await revertirPedidoPorAnulacionFactura(db, FACTURA, EMPRESA);
    expect(segunda).toEqual({ revertido: false });
    expect(stock['dep-1|prod-a'].cantidad_reservada).toBe(4);
  });

  it('pedido facturado con OTRA factura: no se toca', async () => {
    const { db, pedido } = crearDb({
      pedido: { id: 'ped-1', tipo_pedido: 'venta_mayorista', estado: 'facturado', factura_id: 'fac-otra' },
      renglones: [],
    });
    expect(await revertirPedidoPorAnulacionFactura(db, FACTURA, EMPRESA)).toEqual({ revertido: false });
    expect(pedido.estado).toBe('facturado');
  });

  it('factura sin pedido: no hace nada', async () => {
    const { db, tx } = crearDb({
      pedido: { id: 'ped-1', tipo_pedido: 'venta_mayorista', estado: 'confirmado', factura_id: null },
      renglones: [],
      factura: { pedido_id: null, dest: '001', dpunexp: '001', dnumdoc: '1' },
    });
    expect(await revertirPedidoPorAnulacionFactura(db, FACTURA, EMPRESA)).toEqual({ revertido: false });
    expect(tx.pedidos.update).not.toHaveBeenCalled();
  });

  it('orden de venta parcial: devuelve lo facturado a lo pendiente, lo vuelve a reservar y queda «facturada_parcial»', async () => {
    // Orden de 10 cajas (x12) y 5 unidades; la factura anulada facturó 4 cajas.
    // Otra factura (fac-2) facturó 2 unidades y sigue viva.
    const { db, stock, pedido, renglones, historial } = crearDb({
      pedido: { id: 'ov-1', tipo_pedido: 'orden_venta', estado_orden: 'facturada_parcial', stock_reservado: true, sucursal_id: 'suc-1' },
      renglones: [
        { id: 'r1', pedido_id: 'ov-1', producto_id: 'prod-a', deposito_id: 'dep-1', cantidad: 10, cantidad_base: 120, cant_pendiente: 6 },
        { id: 'r2', pedido_id: 'ov-1', producto_id: 'prod-b', deposito_id: 'dep-2', cantidad: 5, cantidad_base: 5, cant_pendiente: 3 },
      ],
      historial: [
        { pedido_id: 'ov-1', accion: 'facturada_parcial', datos: { factura_id: FACTURA, reservaba: true } },
        { pedido_id: 'ov-1', accion: 'facturada_parcial', datos: { factura_id: 'fac-2', reservaba: true } },
      ],
      stock: { 'dep-1|prod-a': { cantidad_disponible: 200, cantidad_reservada: 72 } },
      facturaDets: [{ producto_id: 'prod-a', dcantproser: 4 }],
    });

    const r = await revertirPedidoPorAnulacionFactura(db, FACTURA, EMPRESA);

    expect(r).toMatchObject({ revertido: true, tipo: 'orden_venta', estadoNuevo: 'facturada_parcial', reservado: 48 });
    expect(Number(renglones[0].cant_pendiente)).toBe(10);
    expect(Number(renglones[1].cant_pendiente)).toBe(3); // lo de fac-2 no se toca
    expect(stock['dep-1|prod-a'].cantidad_reservada).toBe(120); // 72 que quedaban + 48
    expect(pedido).toMatchObject({ estado_orden: 'facturada_parcial', stock_reservado: true });

    // Idempotencia: la marca de reversión con esta factura frena la segunda pasada.
    expect(await revertirPedidoPorAnulacionFactura(db, FACTURA, EMPRESA)).toEqual({ revertido: false });
    expect(stock['dep-1|prod-a'].cantidad_reservada).toBe(120);
    expect(historial.filter((h) => h.accion === ACCION_REVERSION)).toHaveLength(1);
  });

  it('orden facturada entera que reservaba: vuelve a «en_proceso», reserva todo y stock_reservado otra vez en true', async () => {
    const { db, stock, pedido } = crearDb({
      pedido: { id: 'ov-1', tipo_pedido: 'orden_venta', estado_orden: 'facturada', stock_reservado: false, sucursal_id: 'suc-1' },
      renglones: [{ id: 'r1', pedido_id: 'ov-1', producto_id: 'prod-a', deposito_id: 'dep-1', cantidad: 3, cantidad_base: 3, cant_pendiente: 0 }],
      historial: [
        { pedido_id: 'ov-1', accion: 'aprobada', datos: null },
        { pedido_id: 'ov-1', accion: 'facturada', datos: { factura_id: FACTURA, reservaba: true } },
      ],
      facturaDets: [{ producto_id: 'prod-a', dcantproser: 3 }],
    });
    const r = await revertirPedidoPorAnulacionFactura(db, FACTURA, EMPRESA);
    expect(r).toMatchObject({ revertido: true, estadoNuevo: 'en_proceso', reservado: 3 });
    expect(pedido).toMatchObject({ estado_orden: 'en_proceso', stock_reservado: true });
    expect(stock['dep-1|prod-a'].cantidad_reservada).toBe(3);
  });

  it('orden que no reservaba: devuelve lo pendiente sin reservar', async () => {
    const { db, stock, pedido, tx } = crearDb({
      pedido: { id: 'ov-1', tipo_pedido: 'orden_venta', estado_orden: 'facturada', stock_reservado: false, sucursal_id: 'suc-1' },
      renglones: [{ id: 'r1', pedido_id: 'ov-1', producto_id: 'prod-a', deposito_id: 'dep-1', cantidad: 3, cantidad_base: 3, cant_pendiente: 0 }],
      historial: [{ pedido_id: 'ov-1', accion: 'facturada', datos: { factura_id: FACTURA, reservaba: false } }],
      facturaDets: [{ producto_id: 'prod-a', dcantproser: 3 }],
      configSucursal: { orden_reserva_stock: true }, // la marca del historial manda sobre la config de hoy
    });
    const r = await revertirPedidoPorAnulacionFactura(db, FACTURA, EMPRESA);
    expect(r).toMatchObject({ revertido: true, estadoNuevo: 'aprobada', reservado: 0 });
    expect(pedido.stock_reservado).toBe(false);
    expect(stock).toEqual({});
    expect(tx.empresas_sucursales.findUnique).not.toHaveBeenCalled();
  });

  it('orden facturada antes de la marca «reservaba»: usa la configuración de la sucursal', async () => {
    const { db, stock } = crearDb({
      pedido: { id: 'ov-1', tipo_pedido: 'orden_venta', estado_orden: 'facturada', stock_reservado: false, sucursal_id: 'suc-1' },
      renglones: [{ id: 'r1', pedido_id: 'ov-1', producto_id: 'prod-a', deposito_id: 'dep-1', cantidad: 2, cantidad_base: 2, cant_pendiente: 0 }],
      historial: [{ pedido_id: 'ov-1', accion: 'facturada', datos: { factura_id: FACTURA } }],
      facturaDets: [{ producto_id: 'prod-a', dcantproser: 2 }],
      configSucursal: { orden_reserva_stock: true },
    });
    await revertirPedidoPorAnulacionFactura(db, FACTURA, EMPRESA);
    expect(stock['dep-1|prod-a'].cantidad_reservada).toBe(2);
  });

  it('orden que nunca registró la facturación con esta factura: no se toca', async () => {
    const { db, renglones } = crearDb({
      pedido: { id: 'ov-1', tipo_pedido: 'orden_venta', estado_orden: 'aprobada', stock_reservado: true, sucursal_id: 'suc-1' },
      renglones: [{ id: 'r1', pedido_id: 'ov-1', producto_id: 'prod-a', deposito_id: 'dep-1', cantidad: 2, cantidad_base: 2, cant_pendiente: 2 }],
      facturaDets: [{ producto_id: 'prod-a', dcantproser: 2 }],
    });
    expect(await revertirPedidoPorAnulacionFactura(db, FACTURA, EMPRESA)).toEqual({ revertido: false });
    expect(renglones[0].cant_pendiente).toBe(2);
  });
});
