import { HttpException } from '@nestjs/common';
import { submoduloHabilitado } from '../../auth/guards/submodulo.guard';
import { solicitudInvalida } from '../../common/utils/error-estructurado';
import { TesTransferenciasService } from './tes-transferencias.service';

jest.mock('../../auth/guards/submodulo.guard', () => ({ submoduloHabilitado: jest.fn() }));
const submodulo = submoduloHabilitado as jest.Mock;

const TRF = '11111111-1111-4111-8111-111111111111';

/**
 * Las transferencias no tienen cabecera propia y no entran en Conciliación →
 * "Sin asiento": si quedan sin asiento por falta de mapeo (spec 2026-10-13), se
 * regeneran desde Tesorería.
 */
describe('reintentar la contabilización de una transferencia', () => {
  const movimientos = [
    { id: 'mo', origen_tipo: 'TRANSFERENCIA_ORIGEN', estado: 'CONFIRMADO' },
    { id: 'md', origen_tipo: 'TRANSFERENCIA_DESTINO', estado: 'CONFIRMADO' },
  ];
  const crear = (opciones: { movs?: any[]; doc?: any; constancia?: any; resultado?: unknown } = {}) => {
    const prisma: any = {
      tes_movimientos: { findMany: jest.fn().mockResolvedValue(opciones.movs ?? movimientos) },
      cont_documentos: { findFirst: jest.fn().mockResolvedValue(opciones.doc ?? null) },
      audit_logs: { findFirst: jest.fn().mockResolvedValue(opciones.constancia ?? null) },
    };
    const contabilidad: any = { integrarTransferenciaTes: jest.fn().mockResolvedValue('resultado' in opciones ? opciones.resultado : undefined) };
    const service = new TesTransferenciasService(prisma, contabilidad, {} as any, {} as any);
    return { service, prisma, contabilidad };
  };
  const falla = async (p: Promise<unknown>) => {
    try {
      await p;
    } catch (e: any) {
      if (!(e instanceof HttpException)) throw e;
      const r = e.getResponse() as Record<string, unknown>;
      return { status: e.getStatus(), ...(typeof r === 'string' ? { message: r } : r) } as Record<string, any>;
    }
    throw new Error('no lanzó');
  };

  beforeEach(() => submodulo.mockReset().mockResolvedValue({ habilitado: true, fechaFinPrueba: null }));

  it('sin el submódulo CONTABILIDAD_CONCILIACION → 403 y no llama al integrador (F6)', async () => {
    submodulo.mockResolvedValue({ habilitado: false, causa: 'excluido', mensaje: 'El submódulo "CONTABILIDAD_CONCILIACION" está deshabilitado para esta empresa' });
    const { service, contabilidad } = crear({ doc: { id: 'doc-1' } });
    expect(await falla(service.reintentarContabilizacion('emp-1', TRF))).toMatchObject({ status: 403 });
    expect(submodulo).toHaveBeenCalledWith(expect.anything(), 'emp-1', 'CONTABILIDAD_CONCILIACION');
    expect(contabilidad.integrarTransferenciaTes).not.toHaveBeenCalled();
  });

  it('arma la llamada con los dos movimientos y avisa que quedó contabilizada', async () => {
    const { service, prisma, contabilidad } = crear({ doc: { id: 'doc-1' }, resultado: { generado: true } });

    await expect(service.reintentarContabilizacion('emp-1', TRF)).resolves.toEqual({ contabilizada: true, conceptosFaltantes: [], asiento: { generado: true, motivo: null } });

    expect(prisma.tes_movimientos.findMany.mock.calls[0][0].where).toEqual({ transferencia_id: TRF, empresa_id: 'emp-1' });
    expect(contabilidad.integrarTransferenciaTes).toHaveBeenCalledWith('mo', 'md', TRF, 'emp-1');
  });

  it('si sigue pendiente devuelve los conceptos de la última constancia de falta de mapeo', async () => {
    const { service, prisma } = crear({ constancia: { new_value: { origen_tipo: 'tes_transferencias', conceptos: ['DIFERENCIA_CAMBIO_GANADA'] } } });

    await expect(service.reintentarContabilizacion('emp-1', TRF)).resolves.toEqual({
      contabilizada: false,
      conceptosFaltantes: ['DIFERENCIA_CAMBIO_GANADA'],
      asiento: { generado: false, motivo: 'FALTA_MAPEO', conceptos: ['DIFERENCIA_CAMBIO_GANADA'] },
    });
    expect(prisma.audit_logs.findFirst.mock.calls[0][0].where).toEqual({ empresa_id: 'emp-1', action: 'CONT_FALTA_MAPEO', entity_type: 'tes_transferencias', entity_id: TRF });
  });

  it('sin período abierto: el motivo en asiento y sin conceptos', async () => {
    const { service } = crear({ resultado: { generado: false, motivo: 'SIN_PERIODO_ABIERTO' } });
    await expect(service.reintentarContabilizacion('emp-1', TRF)).resolves.toEqual({
      contabilizada: false,
      conceptosFaltantes: [],
      asiento: { generado: false, motivo: 'SIN_PERIODO_ABIERTO' },
    });
  });

  it('una transferencia de otra empresa (o sin sus dos puntas) → 404 TRANSFERENCIA_NO_ENCONTRADA', async () => {
    const { service, contabilidad } = crear({ movs: [] });
    expect(await falla(service.reintentarContabilizacion('emp-2', TRF))).toMatchObject({ status: 404, codigo: 'TRANSFERENCIA_NO_ENCONTRADA' });
    const solo = crear({ movs: [movimientos[0]] });
    expect(await falla(solo.service.reintentarContabilizacion('emp-1', TRF))).toMatchObject({ status: 404, codigo: 'TRANSFERENCIA_NO_ENCONTRADA' });
    expect(contabilidad.integrarTransferenciaTes).not.toHaveBeenCalled();
  });

  it('anulada entre la lectura y el asiento (la guarda del integrador en su transacción) → 400 TRANSFERENCIA_ANULADA, sin asiento (ronda 1)', async () => {
    const { service, contabilidad, prisma } = crear();
    contabilidad.integrarTransferenciaTes.mockRejectedValue(solicitudInvalida({ message: 'La transferencia está anulada: no se contabiliza', codigo: 'TRANSFERENCIA_ANULADA' }));
    expect(await falla(service.reintentarContabilizacion('emp-1', TRF))).toMatchObject({ status: 400, codigo: 'TRANSFERENCIA_ANULADA' });
    expect(prisma.cont_documentos.findFirst).not.toHaveBeenCalled();
  });

  it('una transferencia anulada no se contabiliza → 400 TRANSFERENCIA_ANULADA', async () => {
    const { service, contabilidad } = crear({ movs: movimientos.map((m) => ({ ...m, estado: 'ANULADO' })) });
    expect(await falla(service.reintentarContabilizacion('emp-1', TRF))).toMatchObject({ status: 400, codigo: 'TRANSFERENCIA_ANULADA' });
    expect(contabilidad.integrarTransferenciaTes).not.toHaveBeenCalled();
  });
});
