import { BadRequestException, Logger } from '@nestjs/common';
import { AVISO_SIN_REGLA_PAGO_GASTO } from 'src/common/utils/cuenta-pago-gasto.util';
import {
  AVISO_EGRESO_ANULADO,
  AVISO_TESORERIA_NADA,
  avisoTesoreria,
  estadoTesoreria,
  GastosService,
} from './gastos.service';
import { GastosTesoreriaService } from './services/gastos-tesoreria.service';

/**
 * Tesorería de gastos (Task 8): el egreso solo sale cuando el gasto pagó de una vez
 * desde una cuenta; el estado no queda PENDIENTE donde no corresponde (S5 y el
 * crédito pagado por OP del Review Focus) y lo que pasó vuelve en `avisos` (S3, S4).
 */

// Los avisos esperados se loguean como WARN/ERROR: no ensucian la salida de jest.
beforeAll(() => {
  jest.spyOn(Logger.prototype, 'warn').mockImplementation(() => undefined);
  jest.spyOn(Logger.prototype, 'error').mockImplementation(() => undefined);
});

const CUENTA_PYG = { id: 'pyg', nombre: 'Banco Continental', moneda: 'PYG', cuenta_contable_id: 'cc-pyg' };

function tesoreria(gasto: Record<string, unknown>, opciones: { cxpPagadaPorOp?: boolean } = {}) {
  const creados = { movimientos: [] as any[], cheques: [] as any[] };
  const tx: any = {
    gasto_cab: {
      findFirst: jest.fn().mockResolvedValue({
        id: 'g1',
        empresa_id: 'emp',
        estado: 'pagada',
        forma_pago: 'CONTADO',
        pago_historico: false,
        fecha_emision: new Date('2026-10-16'),
        numero_factura: '001-001-0000123',
        total: 110000,
        cotizacion: 1,
        moneda_id: 'mon-pyg',
        medio_pago_id: 'mp',
        cuenta_tesoreria_id: 'pyg',
        medio_pago: { codigo: 1, descripcion: 'Efectivo' },
        moneda: { codigo: 'PYG' },
        ...gasto,
      }),
    },
    tes_movimientos: {
      findFirst: jest.fn().mockResolvedValue(null),
      create: jest.fn().mockImplementation(({ data }) => (creados.movimientos.push(data), { id: 'm1' })),
    },
    tes_cheques: {
      findFirst: jest.fn().mockResolvedValue(null),
      create: jest.fn().mockImplementation(({ data }) => (creados.cheques.push(data), {})),
    },
    tes_cuentas: { findFirst: jest.fn().mockResolvedValue(CUENTA_PYG), update: jest.fn().mockResolvedValue({}) },
    tes_reglas: { findMany: jest.fn().mockResolvedValue([]) },
    tes_categorias: { findFirst: jest.fn().mockResolvedValue({ id: 'cat' }) },
    tes_movimiento_det: { create: jest.fn().mockResolvedValue({}) },
    cont_documentos: { findFirst: jest.fn().mockResolvedValue(null) },
    $queryRaw: jest.fn().mockResolvedValue([]),
    orden_pago_proveedor_det: {
      findMany: jest.fn().mockResolvedValue(opciones.cxpPagadaPorOp ? [{ cuentas_pagar: { origen_id: 'g1' } }] : []),
    },
    pagos_proveedor: { findMany: jest.fn().mockResolvedValue([]) },
    rec_multi_gastos: { findMany: jest.fn().mockResolvedValue([]) },
    // Medios que no mueven caja (medio-pago-sin-caja.util): acá la empresa no marcó ninguno.
    medio_pago: { findUnique: jest.fn().mockResolvedValue({ codigo: 1 }) },
    empresa_medio_pago: { findFirst: jest.fn().mockResolvedValue(null), findMany: jest.fn().mockResolvedValue([]) },
  };
  const prisma: any = { ...tx, $transaction: (fn: any) => fn(tx) };
  return { service: new GastosTesoreriaService(prisma), creados, tx };
}

describe('GastosTesoreriaService.integrarGasto', () => {
  it('integrarGasto no hace nada con pago_historico, con CREDITO pagado ni con CxP activa', async () => {
    for (const caso of [
      tesoreria({ pago_historico: true }),
      tesoreria({ forma_pago: 'CREDITO' }),
      tesoreria({ forma_pago: 'CONTADO' }, { cxpPagadaPorOp: true }),
    ]) {
      expect(await caso.service.integrarGasto('g1')).toEqual({ registrado: null });
      expect(caso.creados.movimientos).toHaveLength(0);
      expect(caso.creados.cheques).toHaveLength(0);
      expect(caso.tx.tes_cuentas.update).not.toHaveBeenCalled();
    }
  });

  it('devuelve registrado MOVIMIENTO en un contado', async () => {
    const { service, creados } = tesoreria({});
    expect(await service.integrarGasto('g1')).toEqual({ registrado: 'MOVIMIENTO' });
    expect(creados.movimientos[0]).toMatchObject({ cuenta_id: 'pyg', monto: 110000 });
  });

  it('devuelve registrado CHEQUE en un pago con cheque', async () => {
    const { service, creados } = tesoreria({ medio_pago: { codigo: 2, descripcion: 'Cheque' } });
    expect(await service.integrarGasto('g1')).toEqual({ registrado: 'CHEQUE' });
    expect(creados.cheques[0]).toMatchObject({ estado: 'EN_CARTERA', monto: 110000, moneda: 'PYG' });
  });

  it('sin cuenta ni regla: no registra y devuelve el aviso de hoy', async () => {
    const { service, tx } = tesoreria({ cuenta_tesoreria_id: null });
    expect(await service.integrarGasto('g1')).toEqual({ registrado: null, warning: AVISO_SIN_REGLA_PAGO_GASTO });
    expect(tx.tes_movimientos.create).not.toHaveBeenCalled();
  });
});

describe('estadoTesoreria', () => {
  const pagadaContado = { estado: 'pagada', forma_pago: 'CONTADO', pago_historico: false };

  it('cheque EN_CARTERA → EN_CARTERA (sin PENDIENTE); histórico → HISTORICO; CREDITO pagada sin movimiento → null; CONTADO pagada sin nada → PENDIENTE', () => {
    expect(estadoTesoreria(pagadaContado, null, { estado: 'EN_CARTERA' })).toBe('EN_CARTERA');
    expect(estadoTesoreria(pagadaContado, null, { estado: 'DIFERIDO' })).toBe('DIFERIDO');
    expect(estadoTesoreria({ ...pagadaContado, pago_historico: true }, null, null)).toBe('HISTORICO');
    expect(estadoTesoreria({ ...pagadaContado, forma_pago: 'CREDITO' }, null, null)).toBeNull();
    expect(estadoTesoreria(pagadaContado, null, null)).toBe('PENDIENTE');
  });

  it('contado diferido pagado por OP → null; anticipo → null; registrado → null', () => {
    expect(estadoTesoreria({ ...pagadaContado, cxp_pagada_por_otro: true }, null, null)).toBeNull();
    expect(estadoTesoreria({ ...pagadaContado, forma_pago: 'ANTICIPO' }, null, null)).toBeNull();
    expect(estadoTesoreria({ ...pagadaContado, estado: 'registrado' }, null, null)).toBeNull();
  });

  it('el registro vigente gana; solo anulados en un gasto vigente → PENDIENTE; en uno anulado → ANULADO', () => {
    expect(estadoTesoreria(pagadaContado, { estado: 'CONFIRMADO' }, null)).toBe('CONFIRMADO');
    expect(estadoTesoreria(pagadaContado, { estado: 'ANULADO' }, { estado: 'EN_CARTERA' })).toBe('EN_CARTERA');
    expect(estadoTesoreria(pagadaContado, { estado: 'ANULADO' }, null)).toBe('PENDIENTE');
    expect(estadoTesoreria({ ...pagadaContado, anulado: true }, { estado: 'ANULADO' }, null)).toBe('ANULADO');
  });
});

describe('GastosService — avisos de tesorería en las respuestas', () => {
  function servicio(opciones: {
    integrar?: jest.Mock;
    tesoreriaEstado?: string | null;
    prisma?: Record<string, unknown>;
  }) {
    const contabilidad = {
      integrarGasto: jest.fn().mockResolvedValue(undefined),
      revertirDocumento: jest.fn().mockResolvedValue(undefined),
    };
    const gastosTesoreria = {
      integrarGasto: opciones.integrar ?? jest.fn().mockResolvedValue({ registrado: 'MOVIMIENTO' }),
    };
    const prisma: any = {
      // El cuerpo de la transacción del alta ya lo cubren los otros specs: acá solo importa lo de después.
      $transaction: jest.fn().mockResolvedValue('g1'),
      gasto_cab: { findFirst: jest.fn().mockResolvedValue({ id: 'g1', anulado: false, numero_factura: '001-001-0000123' }) },
      ...opciones.prisma,
    };
    const service = new GastosService(prisma, contabilidad as any, gastosTesoreria as any, {} as any, {} as any);
    jest.spyOn(service as any, 'validatePayload').mockReturnValue(undefined);
    jest
      .spyOn(service, 'findOne')
      .mockResolvedValue({ id: 'g1', tesoreria_estado: opciones.tesoreriaEstado ?? null } as any);
    return { service, contabilidad, gastosTesoreria };
  }
  const dto = { cabecera: { forma_pago: 'CONTADO' }, items: [] } as any;

  it("POST /gastos devuelve avisos.tesoreria con el warning 'No existe una regla…'", async () => {
    const { service, contabilidad } = servicio({
      integrar: jest.fn().mockResolvedValue({ registrado: null, warning: AVISO_SIN_REGLA_PAGO_GASTO }),
      tesoreriaEstado: 'PENDIENTE',
    });
    const r = await service.create(dto, 'emp', 'u1');
    expect(r).toEqual({ id: 'g1', tesoreria_estado: 'PENDIENTE', avisos: { tesoreria: AVISO_SIN_REGLA_PAGO_GASTO } });
    // M10: el asiento y el egreso reciben la misma referencia, decidida una vez.
    expect(contabilidad.integrarGasto).toHaveBeenCalledWith('g1', { referencia: '001-001-0000123' });
  });

  it("reintentar-tesoreria sin registrar nada → 'No se registró nada en Tesorería.'", async () => {
    const { service } = servicio({
      integrar: jest.fn().mockResolvedValue({ registrado: null }),
      tesoreriaEstado: 'PENDIENTE',
    });
    expect((await service.reintentarTesoreria('g1', 'emp')).avisos).toEqual({ tesoreria: AVISO_TESORERIA_NADA });
    expect(AVISO_TESORERIA_NADA).toBe('No se registró nada en Tesorería.');
  });

  it('reintentar-tesoreria con el egreso ya hecho (idempotente) no avisa', async () => {
    const { service } = servicio({
      integrar: jest.fn().mockResolvedValue({ registrado: null }),
      tesoreriaEstado: 'CONFIRMADO',
    });
    expect((await service.reintentarTesoreria('g1', 'emp')).avisos).toEqual({});
  });

  it('si tesorería tira, el gasto queda y el aviso lo dice', async () => {
    const { service } = servicio({
      integrar: jest.fn().mockRejectedValue(new Error('se cayó la base')),
      tesoreriaEstado: 'PENDIENTE',
    });
    const r = await service.create(dto, 'emp', 'u1');
    expect(r.id).toBe('g1');
    expect(r.avisos.tesoreria).toContain('no se pudo registrar en Tesorería');
    expect(r.avisos.tesoreria).toContain('se cayó la base');
  });

  it('si contabilidad tira, el aviso de contabilidad lo dice y tesorería sigue', async () => {
    const { service, contabilidad, gastosTesoreria } = servicio({ tesoreriaEstado: 'CONFIRMADO' });
    contabilidad.integrarGasto.mockRejectedValue(new Error('período cerrado'));
    const r = await service.reintentarContabilidad('g1', 'emp', 'u1');
    expect(r.avisos.contabilidad).toContain('período cerrado');
    expect(gastosTesoreria.integrarGasto).not.toHaveBeenCalled();
  });
});

describe('GastosService.findOne — crédito pagado por una OP (Review Focus)', () => {
  function findOne(gasto: Record<string, unknown>, opDets: unknown[]) {
    const vacio = { findFirst: jest.fn().mockResolvedValue(null) };
    const prisma: any = {
      gasto_cab: {
        findFirst: jest
          .fn()
          .mockResolvedValue({ id: 'g1', estado: 'pagada', pago_historico: false, anulado: false, ...gasto }),
      },
      cont_documentos: vacio,
      tes_movimientos: vacio,
      tes_cheques: vacio,
      orden_pago_proveedor_det: { findMany: jest.fn().mockResolvedValue(opDets) },
      pagos_proveedor: { findMany: jest.fn().mockResolvedValue([]) },
      rec_multi_gastos: { findMany: jest.fn().mockResolvedValue([]) },
    };
    return new GastosService(prisma, {} as any, {} as any, {} as any, {} as any).findOne('g1', 'emp');
  }

  it('crédito pagado sin movimiento propio → sin PENDIENTE (no ofrece reintento)', async () => {
    expect(
      (await findOne({ forma_pago: 'CREDITO' }, [{ cuentas_pagar: { origen_id: 'g1' } }])).tesoreria_estado,
    ).toBeNull();
  });

  it('contado diferido pagado por OP → sin PENDIENTE', async () => {
    expect(
      (await findOne({ forma_pago: 'CONTADO' }, [{ cuentas_pagar: { origen_id: 'g1' } }])).tesoreria_estado,
    ).toBeNull();
  });

  it('contado pagado sin nada → PENDIENTE', async () => {
    expect((await findOne({ forma_pago: 'CONTADO' }, [])).tesoreria_estado).toBe('PENDIENTE');
  });
});

describe('GastosService.cuentaPago', () => {
  it('cuenta-pago: USD sin cuenta con regla general PYG → origen REGLA_GENERAL y conversion { tc: 7300 }', async () => {
    const prisma: any = {
      tes_reglas: {
        findMany: jest.fn().mockResolvedValue([
          {
            medio_pago_id: null,
            moneda_id: null,
            activo: true,
            cuenta_id: 'pyg',
            cuenta: { ...CUENTA_PYG, activo: true, empresa_id: 'emp' },
          },
        ]),
      },
      tes_cuentas: { findFirst: jest.fn() },
      moneda: {
        findUnique: jest.fn().mockResolvedValue({ codigo: 'USD' }),
        findFirst: jest.fn().mockResolvedValue({ id: 'mon-pyg' }),
      },
    };
    const service = new GastosService(prisma, {} as any, new GastosTesoreriaService(prisma), {} as any, {} as any);
    const r = await service.cuentaPago('emp', { medio_pago_id: 'mp', moneda_id: 'mon-usd', cotizacion: '7300' });
    expect(r).toMatchObject({
      cuenta: { id: 'pyg', nombre: 'Banco Continental', moneda: 'PYG' },
      origen: 'REGLA_GENERAL',
      conversion: { tc: 7300 },
    });
    expect(prisma.tes_cuentas.findFirst).not.toHaveBeenCalled();

    const sinTc = await service.cuentaPago('emp', { moneda_id: 'mon-usd', cotizacion: '1' });
    expect(sinTc.conversion).toEqual({ tc: null });
  });

  it('PYG desde una cuenta PYG → sin conversion; sin reglas → cuenta null con el aviso', async () => {
    const prisma: any = {
      tes_reglas: { findMany: jest.fn().mockResolvedValue([]) },
      tes_cuentas: { findFirst: jest.fn() },
      moneda: {
        findUnique: jest.fn().mockResolvedValue({ codigo: 'PYG' }),
        findFirst: jest.fn().mockResolvedValue({ id: 'mon-pyg' }),
      },
    };
    const service = new GastosService(prisma, {} as any, new GastosTesoreriaService(prisma), {} as any, {} as any);
    expect(await service.cuentaPago('emp', { moneda_id: 'mon-pyg' })).toEqual({
      cuenta: null,
      origen: null,
      conversion: null,
      avisos: [AVISO_SIN_REGLA_PAGO_GASTO],
    });
  });
});

describe('Ronda 1 — cuenta elegida, egreso anulado, reversa fallida y lock', () => {
  const reglaGeneral = {
    medio_pago_id: null,
    moneda_id: null,
    activo: true,
    cuenta_id: 'pyg',
    cuenta: { ...CUENTA_PYG, activo: true, empresa_id: 'emp' },
  };

  it('I1: guardar con la cuenta elegida inactiva o de otra empresa → 400 (no cae a la regla en silencio)', async () => {
    const prisma: any = {
      tes_cuentas: { findFirst: jest.fn().mockResolvedValue(null) },
      tes_reglas: { findMany: jest.fn().mockResolvedValue([reglaGeneral]) },
      moneda: { findFirst: jest.fn().mockResolvedValue({ id: 'mon-pyg' }) },
    };
    const service: any = new GastosService(prisma, {} as any, new GastosTesoreriaService(prisma), {} as any, {} as any);
    const intento = service.assertCuentaAceptaMoneda(prisma, 'emp', {
      cuentaTesoreriaId: 'cuenta-vieja',
      medioPagoId: 'mp',
      monedaId: 'mon-pyg',
      moneda: { codigo: 'PYG', cotizacion: 1 },
      total: 1000,
    });
    await expect(intento).rejects.toThrow(BadRequestException);
    await expect(intento).rejects.toThrow('La cuenta elegida en el gasto no está activa o no es de la empresa.');
    // Sin cuenta elegida, la regla vale.
    await expect(
      service.assertCuentaAceptaMoneda(prisma, 'emp', { moneda: { codigo: 'PYG', cotizacion: 1 }, total: 1000 }),
    ).resolves.toBeUndefined();
  });

  it('I2: egreso anulado en Tesorería → PENDIENTE con tesoreria_aviso; sin registro → PENDIENTE sin aviso', async () => {
    const prisma: any = {
      gasto_cab: {
        findFirst: jest
          .fn()
          .mockResolvedValue({
            id: 'g1',
            estado: 'pagada',
            forma_pago: 'CONTADO',
            pago_historico: false,
            anulado: false,
          }),
      },
      cont_documentos: { findFirst: jest.fn().mockResolvedValue(null) },
      // Vigente: ninguno; cualquiera: el anulado.
      tes_movimientos: {
        findFirst: jest.fn().mockResolvedValueOnce(null).mockResolvedValueOnce({ estado: 'ANULADO' }),
      },
      tes_cheques: { findFirst: jest.fn().mockResolvedValue(null) },
      orden_pago_proveedor_det: { findMany: jest.fn().mockResolvedValue([]) },
      pagos_proveedor: { findMany: jest.fn().mockResolvedValue([]) },
      rec_multi_gastos: { findMany: jest.fn().mockResolvedValue([]) },
    };
    const r: any = await new GastosService(prisma, {} as any, {} as any, {} as any, {} as any).findOne('g1', 'emp');
    expect(r.tesoreria_estado).toBe('PENDIENTE');
    expect(r.tesoreria_aviso).toBe('El egreso anterior fue anulado en Tesorería; reintentar crea uno nuevo.');
    expect(AVISO_EGRESO_ANULADO).toBe(r.tesoreria_aviso);
    expect(avisoTesoreria('PENDIENTE', null, null)).toBeNull();
    expect(avisoTesoreria('CONFIRMADO', { estado: 'ANULADO' }, { estado: 'CONFIRMADO' })).toBeNull();
  });

  it('si no se puede verificar la CxP, no ofrece reintento', async () => {
    const prisma: any = {
      gasto_cab: {
        findFirst: jest
          .fn()
          .mockResolvedValue({
            id: 'g1',
            estado: 'pagada',
            forma_pago: 'CONTADO',
            pago_historico: false,
            anulado: false,
          }),
      },
      cont_documentos: { findFirst: jest.fn().mockResolvedValue(null) },
      tes_movimientos: { findFirst: jest.fn().mockResolvedValue(null) },
      tes_cheques: { findFirst: jest.fn().mockResolvedValue(null) },
      orden_pago_proveedor_det: { findMany: jest.fn().mockRejectedValue(new Error('timeout')) },
      pagos_proveedor: { findMany: jest.fn().mockResolvedValue([]) },
      rec_multi_gastos: { findMany: jest.fn().mockResolvedValue([]) },
    };
    const r: any = await new GastosService(prisma, {} as any, {} as any, {} as any, {} as any).findOne('g1', 'emp');
    expect(r.tesoreria_estado).toBeNull();
    expect(r.tesoreria_aviso).toBe('No se pudo verificar Tesorería. Motivo: timeout');
  });

  // I12: una lectura de Tesorería que falla no se presenta como PENDIENTE.
  it('si falla la lectura del egreso, no dice PENDIENTE: estado null y el aviso con el motivo', async () => {
    const prisma: any = {
      gasto_cab: {
        findFirst: jest.fn().mockResolvedValue({ id: 'g1', estado: 'pagada', forma_pago: 'CONTADO', pago_historico: false, anulado: false }),
      },
      cont_documentos: { findFirst: jest.fn().mockResolvedValue(null) },
      tes_movimientos: { findFirst: jest.fn().mockRejectedValue(new Error('connection reset')) },
      tes_cheques: { findFirst: jest.fn().mockResolvedValue(null) },
    };
    const r: any = await new GastosService(prisma, {} as any, {} as any, {} as any, {} as any).findOne('g1', 'emp');
    expect(r.tesoreria_estado).toBeNull();
    expect(r.tesoreria_aviso).toBe('No se pudo verificar Tesorería. Motivo: connection reset');
  });

  it('lock: el registro bloquea la fila del gasto (FOR UPDATE) antes de mirar si ya hay egreso', async () => {
    const { service, tx } = tesoreria({});
    await service.integrarGasto('g1');
    expect(tx.$queryRaw).toHaveBeenCalledTimes(1);
    const [partes, id] = tx.$queryRaw.mock.calls[0];
    expect(partes.join('?')).toContain('FOR UPDATE');
    expect(id).toBe('g1');
    expect(tx.$queryRaw.mock.invocationCallOrder[0]).toBeLessThan(tx.gasto_cab.findFirst.mock.invocationCallOrder[0]);
    expect(tx.$queryRaw.mock.invocationCallOrder[0]).toBeLessThan(
      tx.tes_movimientos.findFirst.mock.invocationCallOrder[0],
    );
  });
});

describe('GastosService.avisoContable (N3, I7): el motivo viene del integrador', () => {
  function servicio(r: unknown) {
    const prisma: any = {
      gasto_cab: { findFirst: jest.fn().mockResolvedValue({ id: 'g1', anulado: false, numero_factura: '001' }) },
      audit_logs: { findFirst: jest.fn() },
    };
    const contabilidad = { integrarGasto: jest.fn().mockResolvedValue(r) };
    const service = new GastosService(prisma, contabilidad as any, {} as any, {} as any, {} as any);
    jest.spyOn(service, 'findOne').mockResolvedValue({ id: 'g1', tesoreria_estado: null } as any);
    return { service, prisma };
  }

  it('BORRADOR → "El asiento quedó en borrador: {motivo}"; SIN_ASIENTO → su motivo; el resto → nada', () => {
    const { service } = servicio(undefined);
    expect(service.avisoContable({ estado: 'BORRADOR', motivo: 'No hay período abierto (x)' })).toBe(
      'El asiento quedó en borrador: No hay período abierto (x)',
    );
    expect(service.avisoContable({ estado: 'SIN_ASIENTO', motivo: 'Sin asiento: falta mapear CAJA_GENERAL' })).toBe(
      'Sin asiento: falta mapear CAJA_GENERAL',
    );
    expect(service.avisoContable({ estado: 'CONFIRMADO' })).toBeUndefined();
    expect(service.avisoContable({ estado: 'SIN_MODULO' })).toBeUndefined();
    expect(service.avisoContable({ estado: 'NO_CORRESPONDE' })).toBeUndefined();
  });

  it('reintentar-contabilidad con falta de mapeo devuelve el motivo sin leer audit_logs', async () => {
    const { service, prisma } = servicio({ estado: 'SIN_ASIENTO', motivo: 'Sin asiento: falta mapear CAJA_GENERAL' });
    const r = await service.reintentarContabilidad('g1', 'emp', 'u1');
    expect(r.avisos).toEqual({ contabilidad: 'Sin asiento: falta mapear CAJA_GENERAL' });
    expect(prisma.audit_logs.findFirst).not.toHaveBeenCalled();
  });

  it('reintentar-contabilidad con el asiento en borrador lo avisa; confirmado no avisa', async () => {
    const borrador = servicio({ estado: 'BORRADOR', motivo: 'Asiento desbalanceado (DEBE=10 / HABER=12)' });
    expect((await borrador.service.reintentarContabilidad('g1', 'emp', 'u1')).avisos).toEqual({
      contabilidad: 'El asiento quedó en borrador: Asiento desbalanceado (DEBE=10 / HABER=12)',
    });
    const confirmado = servicio({ estado: 'CONFIRMADO' });
    expect((await confirmado.service.reintentarContabilidad('g1', 'emp', 'u1')).avisos).toEqual({});
  });
});

describe('GastosTesoreriaService — referencia legible y única (Task 9, N7)', () => {
  const sinFactura = {
    numero_factura: null,
    fecha_emision: new Date('2026-10-05T00:00:00.000Z'),
    descripcion: 'Combustible camioneta',
    proveedores: { personas: { razon_social: 'Estación Central S.A.' } },
  };

  it("sin factura: 'GASTO 05/10/2026 · Estación Central S.A.'", async () => {
    const { service, creados } = tesoreria(sinFactura);
    await service.integrarGasto('g1');
    expect(creados.movimientos[0].referencia).toBe('GASTO 05/10/2026 · Estación Central S.A.');
  });

  it('si otro egreso ya usa la referencia, agrega la descripción', async () => {
    const { service, creados, tx } = tesoreria(sinFactura);
    tx.tes_movimientos.findFirst.mockImplementation(async ({ where }: any) =>
      where.referencia === 'GASTO 05/10/2026 · Estación Central S.A.' ? { id: 'otro' } : null,
    );
    await service.integrarGasto('g1');
    // El mismo texto que el asiento: largo común de 50, se acorta el proveedor.
    expect(creados.movimientos[0].referencia).toBe('GASTO 05/10/2026 · Estación · Combustible camionet');
    expect(tx.tes_movimientos.findFirst).toHaveBeenCalledWith(
      expect.objectContaining({ where: { empresa_id: 'emp', referencia: 'GASTO 05/10/2026 · Estación Central S.A.', origen_id: { not: 'g1' } } }),
    );
  });

  it('si el repetido es un asiento (no un egreso), también agrega la descripción: el mismo texto en los dos', async () => {
    const { service, creados, tx } = tesoreria(sinFactura);
    tx.cont_documentos.findFirst.mockResolvedValue({ id: 'doc-otro' });
    await service.integrarGasto('g1');
    expect(creados.movimientos[0].referencia).toBe('GASTO 05/10/2026 · Estación · Combustible camionet');
  });
});
