import { recalcularPendientes } from './recalcular-costeo';

/** Un embarque con IVA marcado como costo (antes 1.100) y un flete de 1.000 que sí entra: después debe quedar en 1.000. */
function crearDb(embarques: any[], opts: { costoItem?: number; relectura?: any; componentes?: any[] } = {}) {
  const orden: string[] = [];
  const itemUpdate = jest.fn();
  const embUpdate = jest.fn();
  const raw = jest.fn(async (sql: string) => { orden.push(sql); });
  const tx: any = {
    $executeRawUnsafe: raw,
    imp_embarques: {
      findMany: jest.fn().mockResolvedValue(embarques),
      findFirst: jest.fn(async (a: any) => {
        orden.push('findFirst');
        return opts.relectura !== undefined ? opts.relectura : embarques.find((e) => e.id === a.where.id) ?? null;
      }),
      update: embUpdate,
    },
    imp_embarque_items: {
      findMany: jest.fn().mockResolvedValue([{ id: 'i1', cantidad: 1, fob_total_usd: 10, peso_unit_kg: 0, cbm_unit: 0, costo_total_gs: opts.costoItem ?? 1100 }]),
      update: itemUpdate,
    },
    imp_componentes_costo: {
      findMany: jest.fn().mockResolvedValue(opts.componentes ?? [{ id: 'c1', es_directo: false, importe_gs: 1000, criterio_prorrateo: 'FOB' }]),
    },
  };
  const db: any = { imp_embarques: tx.imp_embarques, $transaction: jest.fn(async (fn: any) => fn(tx)) };
  return { db, tx, itemUpdate, embUpdate, raw, orden };
}

const emb = (estado: string, costo = '1100') => ({ id: `e-${estado}`, empresa_id: 'emp', numero: `IMP-${estado}`, estado, costo_total_gs: costo, empresas: { razon_social: 'DOBA' } });

describe('recalcularPendientes', () => {
  it('busca solo BORRADOR…DESPACHADO con IVA: LIBERADO, CERRADO y SELLADO no', async () => {
    const { db, tx } = crearDb([emb('BORRADOR')]);
    await recalcularPendientes(db, { dry: false });
    const where = tx.imp_embarques.findMany.mock.calls[0][0].where;
    expect(where.estado.in).toEqual(['BORRADOR', 'EN_TRANSITO', 'ARRIBADO', 'EN_DESPACHO', 'DESPACHADO']);
    expect(where.activo).toBe(true);
    expect(JSON.stringify(where.componentes_costo)).toContain('IMP_IVA_IMPORTACION');
  });

  it('devuelve antes y después del costo y escribe sin --dry', async () => {
    const { db, itemUpdate, embUpdate } = crearDb([emb('ARRIBADO')]);
    const r = await recalcularPendientes(db, { dry: false });
    expect(r).toEqual([{ empresa: 'DOBA', numero: 'IMP-ARRIBADO', estado: 'ARRIBADO', antes: '1100', despues: '1000' }]);
    expect(itemUpdate).toHaveBeenCalledTimes(1);
    expect(embUpdate).toHaveBeenCalledTimes(1);
  });

  it('dry: SET TRANSACTION READ ONLY es la primera sentencia y no se llama a update', async () => {
    const { db, itemUpdate, embUpdate, raw, orden } = crearDb([emb('ARRIBADO')]);
    const r = await recalcularPendientes(db, { dry: true });
    expect(raw).toHaveBeenCalledWith('SET TRANSACTION READ ONLY');
    expect(orden[0]).toBe('SET TRANSACTION READ ONLY');
    expect(orden.indexOf('findFirst')).toBeGreaterThan(0);
    expect(r).toHaveLength(1);
    expect(r[0].despues).toBe('1000');
    expect(itemUpdate).not.toHaveBeenCalled();
    expect(embUpdate).not.toHaveBeenCalled();
  });

  it('idempotente: si el total y el reparto por ítem ya coinciden, 0 cambios', async () => {
    const { db } = crearDb([emb('ARRIBADO', '1000')], { costoItem: 1000 });
    expect(await recalcularPendientes(db, { dry: false })).toEqual([]);
  });

  it('mismo total pero distinto reparto por ítem: cuenta como cambio', async () => {
    const { db } = crearDb([emb('ARRIBADO', '1000')], { costoItem: 700 });
    const r = await recalcularPendientes(db, { dry: true });
    expect(r).toHaveLength(1);
    expect(r[0]).toMatchObject({ antes: '1000', despues: '1000' });
  });

  it('si al releer dentro de la transacción ya no es recalculable, lo omite y no escribe', async () => {
    const { db, itemUpdate, embUpdate } = crearDb([emb('DESPACHADO')], { relectura: null });
    const r = await recalcularPendientes(db, { dry: false });
    expect(r).toEqual([expect.objectContaining({ numero: 'IMP-DESPACHADO', omitido: expect.any(String) })]);
    expect(itemUpdate).not.toHaveBeenCalled();
    expect(embUpdate).not.toHaveBeenCalled();
  });

  it('un embarque con error se informa con su código y la corrida sigue con los demás', async () => {
    const { db } = crearDb([emb('BORRADOR'), emb('ARRIBADO')], {});
    let n = 0;
    db.$transaction = jest.fn(async (fn: any) => {
      n += 1;
      if (n === 1) throw Object.assign(new Error('Un costo directo necesita el ítem'), { codigo: 'COSTO_DIRECTO_SIN_ITEM' });
      return (db as any).__tx ? fn((db as any).__tx) : fn(db);
    });
    // segundo embarque: usa los mismos delegados del mock
    (db as any).imp_embarque_items = { findMany: jest.fn().mockResolvedValue([]), update: jest.fn() };
    (db as any).imp_componentes_costo = { findMany: jest.fn().mockResolvedValue([]) };
    (db as any).$executeRawUnsafe = jest.fn();
    const r = await recalcularPendientes(db, { dry: true });
    expect(r[0]).toMatchObject({ numero: 'IMP-BORRADOR', error: { codigo: 'COSTO_DIRECTO_SIN_ITEM' } });
    expect(db.$transaction).toHaveBeenCalledTimes(2);
  });
});
