import { BadRequestException } from '@nestjs/common';
import { GastosService } from './gastos.service';

/** Mock asíncrono sin `async` (lint `require-await`): la función corre y su valor sale en una promesa. */
const resuelve = (f: (...a: any[]) => any) => jest.fn((...a: any[]) => new Promise((res, rej) => { try { res(f(...a)); } catch (e) { rej(e instanceof Error ? e : new Error(String(e))); } }));

const EMPRESA = 'emp';

/** Valida el medio y la cuenta de una importación "pagar ahora" con las reglas del alta (Task 11, I1). */
function armar(o: { medioHabilitado?: boolean; cuenta?: { id: string; nombre: string; moneda: string } | null } = {}) {
  const prisma: any = {
    empresa_medio_pago: {
      findFirst: jest.fn().mockResolvedValue(o.medioHabilitado === false ? null : { id: 'emp-mp-1' }),
    },
  };
  const tesoreria = {
    resolverCuentaPago: jest.fn().mockResolvedValue({ cuenta: o.cuenta === undefined ? { id: 'cta-1', nombre: 'Caja', moneda: 'PYG' } : o.cuenta }),
  };
  const service = new GastosService(prisma, {} as any, tesoreria as any, {} as any, {} as any);
  return { service, prisma, tesoreria };
}

describe('GastosService.assertPagoImportacionValido', () => {
  it('medio habilitado y cuenta en guaraníes de la empresa → OK', async () => {
    const { service, prisma, tesoreria } = armar();
    await expect(service.assertPagoImportacionValido(EMPRESA, { medioPagoId: 'mp-1', cuentaTesoreriaId: 'cta-1' })).resolves.toBeUndefined();
    expect(prisma.empresa_medio_pago.findFirst).toHaveBeenCalledWith({
      where: { empresa_id: EMPRESA, medio_pago_id: 'mp-1', activo: true },
      select: { id: true },
    });
    expect(tesoreria.resolverCuentaPago).toHaveBeenCalledWith(prisma, EMPRESA, { cuentaTesoreriaId: 'cta-1', medioPagoId: 'mp-1', monedaId: null });
  });

  it('medio no habilitado para la empresa → 400', async () => {
    const { service } = armar({ medioHabilitado: false });
    await expect(service.assertPagoImportacionValido(EMPRESA, { medioPagoId: 'mp-1' })).rejects.toThrow(
      new BadRequestException('El medio de pago elegido no está habilitado para la empresa.'),
    );
  });

  it('cuenta de otra empresa o inactiva → 400 (la cuenta elegida no se reemplaza por la regla)', async () => {
    const { service } = armar({ cuenta: null });
    await expect(service.assertPagoImportacionValido(EMPRESA, { medioPagoId: 'mp-1', cuentaTesoreriaId: 'cta-ajena' })).rejects.toThrow(
      'La cuenta elegida en el gasto no está activa o no es de la empresa',
    );
  });

  it('cuenta en USD → 400: el importador paga en guaraníes', async () => {
    const { service } = armar({ cuenta: { id: 'cta-usd', nombre: 'Banco USD', moneda: 'USD' } });
    await expect(service.assertPagoImportacionValido(EMPRESA, { medioPagoId: 'mp-1', cuentaTesoreriaId: 'cta-usd' })).rejects.toThrow(
      'El pago está en guaraníes y la cuenta "Banco USD" está en USD. Elegí una cuenta en guaraníes.',
    );
  });

  it('sin cuenta elegida, la de la regla también tiene que aceptar guaraníes', async () => {
    const { service } = armar({ cuenta: { id: 'cta-usd', nombre: 'Banco USD', moneda: 'USD' } });
    await expect(service.assertPagoImportacionValido(EMPRESA, { medioPagoId: 'mp-1' })).rejects.toThrow(/es la cuenta configurada en Tesorería/);
  });
});

jest.mock('src/requisiciones/ejecucion-requisicion', () => ({
  aplicarEjecucionRequisicion: jest.fn(),
  monedaDelDocumento: jest.fn(() => Promise.resolve({})),
  revaluarEjecucionRequisicion: jest.fn(),
  revertirEjecucionRequisicion: jest.fn(),
}));

/** Conversión de un costo cargado a mano en el de su gasto (B4) y orden de locks con `imp:` (F10). */
describe('GastosService - componente de importación', () => {
  const cuerpo = async (promesa: Promise<unknown>) => {
    try {
      await promesa;
    } catch (e: any) {
      return { status: e.getStatus?.(), ...e.getResponse() };
    }
    throw new Error('No lanzó');
  };

  function armarConversion(o: { estado?: string; componente?: Record<string, any> | null; documento?: { estado: string } | null } = {}) {
    const log: string[] = [];
    const componente = o.componente === undefined ? { id: 'comp-1', gasto_id: null, compra_id: null, cuenta_pagar_id: null, asentado_documento_id: null } : o.componente;
    const tx: any = {
      $executeRaw: resuelve((_s: TemplateStringsArray, ...v: any[]) => {
        log.push(`lock:${String(v[0])}`);
      }),
      imp_embarques: {
        findFirst: resuelve(() => {
          log.push('leer-embarque');
          return { id: 'emb-1', estado: o.estado ?? 'ARRIBADO' };
        }),
      },
      imp_componentes_costo: {
        findFirst: resuelve(() => {
          log.push('leer-componente');
          return componente;
        }),
        update: jest.fn(),
      },
      cont_documentos: { findFirst: jest.fn().mockResolvedValue(o.documento ?? null) },
    };
    const costeo = { recalcular: jest.fn() };
    const service = new GastosService({} as any, {} as any, {} as any, costeo as any, {} as any);
    const convertir = () =>
      (service as any).crearComponenteImportacion(tx, {
        gastoId: 'g1',
        empresaId: EMPRESA,
        embarqueId: 'emb-1',
        convertirComponenteId: 'comp-1',
        proveedorId: 'prov-1',
        monedaId: null,
        importe: 100,
        cotizacion: 1,
        fechaDevengo: new Date('2026-10-05'),
      });
    return { tx, log, convertir };
  }

  it('convertir un componente con CxP → COSTO_CON_CXP y no lo toca', async () => {
    const { tx, convertir } = armarConversion({ componente: { id: 'comp-1', gasto_id: null, compra_id: null, cuenta_pagar_id: 'cxp-1', asentado_documento_id: null } });
    expect(await cuerpo(convertir())).toMatchObject({ status: 409, codigo: 'COSTO_CON_CXP' });
    expect(tx.imp_componentes_costo.update).not.toHaveBeenCalled();
  });

  it('convertir uno asentado (documento CONFIRMADO) → COSTO_ASENTADO; con el documento REVERTIDO se convierte', async () => {
    const componente = { id: 'comp-1', gasto_id: null, compra_id: null, cuenta_pagar_id: null, asentado_documento_id: 'doc-1' };
    const asentado = armarConversion({ componente, documento: { estado: 'CONFIRMADO' } });
    expect(await cuerpo(asentado.convertir())).toMatchObject({ status: 409, codigo: 'COSTO_ASENTADO' });
    const revertido = armarConversion({ componente, documento: { estado: 'REVERTIDO' } });
    await revertido.convertir();
    expect(revertido.tx.imp_componentes_costo.update).toHaveBeenCalled();
  });

  it('embarque CERRADO o SELLADO: la regla de hoy (400) y no llega a leer el componente', async () => {
    for (const estado of ['CERRADO', 'SELLADO']) {
      const { log, convertir } = armarConversion({ estado });
      await expect(convertir()).rejects.toThrow(/No se puede imputar un gasto a un embarque/);
      expect(log).not.toContain('leer-componente');
    }
  });

  it('toma imp: antes de leer el embarque y el componente', async () => {
    const { log, convertir } = armarConversion();
    await convertir();
    expect(log[0]).toBe('lock:imp:emb-1');
    expect(log.indexOf('lock:imp:emb-1')).toBeLessThan(log.indexOf('leer-componente'));
  });

  it('anular un gasto imputado: imp: va después de req: y antes del FOR UPDATE de su CxP', async () => {
    const orden: string[] = [];
    const tx: any = {
      $queryRaw: resuelve((strings: TemplateStringsArray) => {
        orden.push(String(strings[0]).includes('gasto_cab') ? 'for-update-gasto' : 'for-update-cxp');
        return [];
      }),
      $executeRaw: resuelve((_s: TemplateStringsArray, ...v: any[]) => {
        orden.push(String(v[0]).split(':')[0]);
      }),
      gasto_cab: {
        findFirst: jest.fn().mockResolvedValue({ id: 'g1', empresa_id: 'emp', anulado: false, requisicion_id: 'req-1', embarque_id: 'emb-1', rendicion_viatico_id: null, fecha_emision: new Date('2026-10-05') }),
        updateMany: jest.fn().mockResolvedValue({ count: 1 }),
      },
      gasto_det: { findMany: jest.fn().mockResolvedValue([]) },
      cuentas_pagar: { updateMany: jest.fn() },
      imp_componentes_costo: { updateMany: jest.fn().mockResolvedValue({ count: 0 }) },
    };
    const contabilidad = { revertirDocumento: jest.fn() };
    const tesoreria = { revertirGasto: jest.fn() };
    const service = new GastosService({} as any, contabilidad as any, tesoreria as any, { recalcular: jest.fn() } as any, {} as any);
    jest.spyOn(service as any, 'assertAnulable').mockResolvedValue(null);
    await service.anularEnTx(tx, 'g1', 'emp', 'u1', 'Error');
    expect(orden.slice(0, 4)).toEqual(['for-update-gasto', 'req', 'imp', 'for-update-cxp']);
  });
});
