import {
  aplicarEjecucionRequisicion,
  mismaEjecucion,
  ParamsEjecucion,
  ParamsRevaluacion,
  revaluarEjecucionRequisicion,
  revertirEjecucionRequisicion,
} from './ejecucion-requisicion';
import { armar, params } from './ejecucion-requisicion.fixture';

/** Error lanzado por la promesa (falla si no lanzó). */
const errorDe = async (p: Promise<unknown>): Promise<any> => {
  try {
    await p;
  } catch (e) {
    return e;
  }
  throw new Error('Se esperaba un error y no hubo');
};

describe('ejecucion-requisicion', () => {
  it('toma req: antes de leer las líneas', async () => {
    const { tx, orden } = armar();
    await aplicarEjecucionRequisicion(tx, params());
    expect(orden.slice(0, 2)).toEqual(['lock req:req-1', 'leer']);
  });

  it('dos aplicaciones seguidas sobre la misma línea acumulan sobre lo releído', async () => {
    const { tx, det, cab, orden } = armar();
    await aplicarEjecucionRequisicion(tx, params());
    await aplicarEjecucionRequisicion(tx, params({ items: [{ requisicion_det_id: 'rd-1', cantidad: 6, subtotal: 600000 }] }));
    expect(orden).toEqual(['lock req:req-1', 'leer', 'lock req:req-1', 'leer']);
    expect(det[0]).toMatchObject({ cantidad_ejecutada: 10, monto_ejecutado: 1000000, estado: 'ejecutada_total' });
    expect(cab).toMatchObject({ total_ejecutado: 1000000, estado: 'ejecutada_total' });
  });

  it('pasar lo pendiente → CANTIDAD_SUPERA_PENDIENTE con linea', async () => {
    const { tx } = armar({
      lineas: [
        { id: 'rd-1', cantidad_solicitada: '10.0000', cantidad_ejecutada: '0.0000', monto_ejecutado: '0.00', centro_costo_id: null },
        { id: 'rd-2', cantidad_solicitada: '5.0000', cantidad_ejecutada: '3.0000', monto_ejecutado: '300.00', centro_costo_id: null },
      ],
    });
    const e = await errorDe(
      aplicarEjecucionRequisicion(
        tx,
        params({
          items: [
            { requisicion_det_id: 'rd-1', cantidad: 1, subtotal: 100 },
            { requisicion_det_id: 'rd-2', cantidad: 2.0001, subtotal: 200 },
          ],
        }),
      ),
    );
    expect(e.getStatus()).toBe(400);
    expect(e.getResponse()).toMatchObject({ codigo: 'CANTIDAD_SUPERA_PENDIENTE', campo: 'requisicion_det_id', linea: 2 });
    expect(tx.requisicion_det.update).not.toHaveBeenCalled();
  });

  it('un gasto USD a 7300 suma en guaraníes', async () => {
    const { tx, det, cab } = armar();
    await aplicarEjecucionRequisicion(tx, params({ monedaCodigo: 'USD', cotizacion: 7300, items: [{ requisicion_det_id: 'rd-1', cantidad: 4, subtotal: 100 }] }));
    expect(det[0]).toMatchObject({ cantidad_ejecutada: 4, monto_ejecutado: 730000, estado: 'ejecutada_parcial' });
    expect(cab).toMatchObject({ total_ejecutado: 730000, estado: 'ejecutada_parcial' });
  });

  it('aplicar y revertir un gasto USD deja la línea igual que antes', async () => {
    const { tx, det, cab } = armar({
      lineas: [{ id: 'rd-1', cantidad_solicitada: '10.0000', cantidad_ejecutada: '1.5000', monto_ejecutado: '123456.78', centro_costo_id: null }],
      estado: 'ejecutada_parcial',
    });
    const usd = params({
      monedaCodigo: 'USD',
      cotizacion: 7312.37,
      items: [
        { requisicion_det_id: 'rd-1', cantidad: 1.3333, subtotal: 33.33 },
        { requisicion_det_id: 'rd-1', cantidad: 0.6667, subtotal: 16.67 },
      ],
    });
    await aplicarEjecucionRequisicion(tx, usd);
    // 33,33 × 7312,37 = 243.721,29 y 16,67 × 7312,37 = 121.897,21 (ítem por ítem, como la migración).
    expect(det[0]).toMatchObject({ cantidad_ejecutada: 3.5, monto_ejecutado: 489075.28 });
    await revertirEjecucionRequisicion(tx, usd);
    expect(det[0]).toMatchObject({ cantidad_ejecutada: 1.5, monto_ejecutado: 123456.78, estado: 'ejecutada_parcial' });
    expect(cab).toMatchObject({ total_ejecutado: 123456.78, estado: 'ejecutada_parcial' });
  });

  it('revertir todo lo ejecutado vuelve la cabecera a aprobada; revertir no mira el estado', async () => {
    const { tx, det, cab } = armar({
      lineas: [{ id: 'rd-1', cantidad_solicitada: '10.0000', cantidad_ejecutada: '4.0000', monto_ejecutado: '400000.00', centro_costo_id: null }],
      estado: 'ejecutada_parcial',
    });
    await revertirEjecucionRequisicion(tx, params());
    expect(det[0]).toMatchObject({ cantidad_ejecutada: 0, monto_ejecutado: 0, estado: 'pendiente' });
    expect(cab.estado).toBe('aprobada');

    const cancelada = armar({
      lineas: [{ id: 'rd-1', cantidad_solicitada: '10.0000', cantidad_ejecutada: '4.0000', monto_ejecutado: '400000.00', centro_costo_id: null }],
      estado: 'cancelada',
    });
    await revertirEjecucionRequisicion(cancelada.tx, params());
    expect(cancelada.det[0]).toMatchObject({ cantidad_ejecutada: 0, estado: 'pendiente' });
    // La cabecera cancelada sigue cancelada, pero su total_ejecutado acompaña a las líneas (el listado lo muestra).
    expect(cancelada.cab).toMatchObject({ estado: 'cancelada', total_ejecutado: 0 });
    expect(cancelada.tx.requisicion_cab.update.mock.calls[0][0].data).not.toHaveProperty('estado');
  });

  it.each(['cancelada', 'rechazada', 'ejecutada_total', 'borrador'])(
    'aplicar sobre una requisición %s (cambió bajo el lock) → 409 REQUISICION_ESTADO_CAMBIADO',
    async (estado) => {
      const { tx } = armar({ estado });
      const e = await errorDe(aplicarEjecucionRequisicion(tx, params()));
      expect(e.getStatus()).toBe(409);
      expect(e.getResponse()).toMatchObject({ codigo: 'REQUISICION_ESTADO_CAMBIADO', estado_actual: estado });
      expect(tx.requisicion_det.update).not.toHaveBeenCalled();
    },
  );

  it('sin requisicionId no hace nada', async () => {
    const { tx } = armar();
    await aplicarEjecucionRequisicion(tx, params({ requisicionId: null }));
    await revertirEjecucionRequisicion(tx, params({ requisicionId: null }));
    expect(tx.$executeRaw).not.toHaveBeenCalled();
    expect(tx.requisicion_cab.findFirst).not.toHaveBeenCalled();
  });

  it('la ejecución por encima de lo aprobado pasa', async () => {
    // Solicitado 10 a un estimado de 1.000 (10.000 aprobado); se ejecutan las 10 por 50.000.
    const { tx, det, cab } = armar();
    await aplicarEjecucionRequisicion(tx, params({ items: [{ requisicion_det_id: 'rd-1', cantidad: 10, subtotal: 50000 }] }));
    expect(det[0]).toMatchObject({ cantidad_ejecutada: 10, monto_ejecutado: 50000, estado: 'ejecutada_total' });
    expect(cab).toMatchObject({ total_ejecutado: 50000, estado: 'ejecutada_total' });
  });

  it('ajusta el presupuesto del centro de costo', async () => {
    const { tx, presupuesto } = armar({
      lineas: [{ id: 'rd-1', cantidad_solicitada: '10.0000', cantidad_ejecutada: '0.0000', monto_ejecutado: '0.00', centro_costo_id: 'cc-1' }],
      presupuesto: 1000,
    });
    const usd = params({ monedaCodigo: 'USD', cotizacion: 7300, items: [{ requisicion_det_id: 'rd-1', cantidad: 1, subtotal: 10 }] });
    await aplicarEjecucionRequisicion(tx, usd);
    expect(tx.requisicion_presupuesto.findFirst).toHaveBeenCalledWith(
      expect.objectContaining({
        where: { empresa_id: 'emp', periodo_id: 'per-1', centro_costo_id: 'cc-1', origen_tipo: 'gasto', activo: true },
      }),
    );
    expect(presupuesto().monto_ejecutado).toBe(1000 + 73000);
    await revertirEjecucionRequisicion(tx, usd);
    expect(presupuesto().monto_ejecutado).toBe(1000);
  });

  describe('revaluar (solo cambia la cotización)', () => {
    // Un gasto USD de 100 por 4 unidades, ya ejecutado a 7000 (700.000).
    const lineaEjecutada = (centro: string | null = null) => [
      { id: 'rd-1', cantidad_solicitada: '10.0000', cantidad_ejecutada: '4.0000', monto_ejecutado: '700000.00', estado: 'ejecutada_parcial', centro_costo_id: centro },
    ];
    const reval = (antes: number, despues: number): ParamsRevaluacion => ({
      empresaId: 'emp',
      requisicionId: 'req-1',
      items: [{ requisicion_det_id: 'rd-1', cantidad: 4, subtotal: 100 }],
      antes: { monedaCodigo: 'USD', cotizacion: antes },
      despues: { monedaCodigo: 'USD', cotizacion: despues },
      fechaOperacion: new Date('2026-10-05T00:00:00.000Z'),
    });

    it('en una requisición cancelada pasa y ajusta el monto de la línea y el presupuesto (sin chequear el estado)', async () => {
      const { tx, det, cab, orden, presupuesto } = armar({ estado: 'cancelada', lineas: lineaEjecutada('cc-1'), presupuesto: 700000 });
      await revaluarEjecucionRequisicion(tx, reval(7000, 7300));
      // El presupuesto del centro de costo también se ajusta por la diferencia (730.000 − 700.000).
      expect(presupuesto().monto_ejecutado).toBe(730000);
      expect(orden.slice(0, 2)).toEqual(['lock req:req-1', 'leer']);
      expect(det[0]).toMatchObject({ cantidad_ejecutada: '4.0000', monto_ejecutado: 730000, estado: 'ejecutada_parcial' });
      expect(tx.requisicion_det.update.mock.calls[0][0].data).not.toHaveProperty('cantidad_ejecutada');
      expect(tx.requisicion_det.update.mock.calls[0][0].data).not.toHaveProperty('estado');
      // La cabecera cancelada sigue cancelada; su total_ejecutado acompaña a las líneas.
      expect(tx.requisicion_cab.update.mock.calls[0][0].data).not.toHaveProperty('estado');
      expect(cab).toMatchObject({ estado: 'cancelada', total_ejecutado: 730000 });
    });

    it('en una aprobada ajusta el monto y el total_ejecutado, sin cambiar el estado', async () => {
      const { tx, det, cab } = armar({ estado: 'ejecutada_parcial', lineas: lineaEjecutada() });
      await revaluarEjecucionRequisicion(tx, reval(7000, 7300));
      expect(det[0]).toMatchObject({ cantidad_ejecutada: '4.0000', monto_ejecutado: 730000, estado: 'ejecutada_parcial' });
      expect(cab).toMatchObject({ total_ejecutado: 730000, estado: 'ejecutada_parcial' });
    });

    it('revaluar y volver deja todo igual (línea, cabecera y presupuesto)', async () => {
      const { tx, det, cab, presupuesto } = armar({ estado: 'ejecutada_parcial', lineas: lineaEjecutada('cc-1'), presupuesto: 700000 });
      await revaluarEjecucionRequisicion(tx, reval(7000, 7312.37));
      expect(det[0].monto_ejecutado).toBe(731237);
      expect(presupuesto().monto_ejecutado).toBe(731237);
      await revaluarEjecucionRequisicion(tx, reval(7312.37, 7000));
      expect(det[0]).toMatchObject({ cantidad_ejecutada: '4.0000', monto_ejecutado: 700000, estado: 'ejecutada_parcial' });
      expect(cab).toMatchObject({ total_ejecutado: 700000, estado: 'ejecutada_parcial' });
      expect(presupuesto().monto_ejecutado).toBe(700000);
    });

    it('la misma cotización no escribe nada; sin requisición no toma lock', async () => {
      const { tx } = armar({ lineas: lineaEjecutada() });
      await revaluarEjecucionRequisicion(tx, reval(7000, 7000));
      expect(tx.requisicion_det.update).not.toHaveBeenCalled();
      expect(tx.requisicion_cab.update).not.toHaveBeenCalled();
      await revaluarEjecucionRequisicion(tx, { ...reval(7000, 7300), requisicionId: null });
      expect(tx.$executeRaw).toHaveBeenCalledTimes(1);
    });
  });

  describe('mismaEjecucion', () => {
    const it1 = { requisicion_det_id: 'rd-1', cantidad: 2, subtotal: 150 };
    it('mismas líneas, cantidades y subtotales (aunque partidas en otros ítems) → igual', () => {
      expect(mismaEjecucion([it1], [{ ...it1, cantidad: 1, subtotal: 75 }, { ...it1, cantidad: 1, subtotal: 75 }])).toBe(true);
    });
    it('los ítems sin línea de la requisición no cuentan', () => {
      expect(mismaEjecucion([it1], [it1, { requisicion_det_id: null, cantidad: 5, subtotal: 9 }])).toBe(true);
    });
    it.each([
      ['otra cantidad', [{ ...it1, cantidad: 3 }]],
      ['otro subtotal', [{ ...it1, subtotal: 151 }]],
      ['otra línea', [{ ...it1, requisicion_det_id: 'rd-2' }]],
      ['una línea menos', []],
    ])('%s → distinta', (_n, otros) => {
      expect(mismaEjecucion([it1], otros as any)).toBe(false);
    });
  });
});
